From 1502697e8d51381fe2864a4e9bcd9cc91c6546f6 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sun, 4 Jan 2015 21:15:16 +0100 Subject: [PATCH 001/323] Added a class containing names (constants) that will be used in the trace transformation --- .../overture/codegen/traces/TraceNames.java | 128 ++++++++++++++++++ 1 file changed, 128 insertions(+) create mode 100644 core/codegen/src/main/java/org/overture/codegen/traces/TraceNames.java diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/TraceNames.java b/core/codegen/src/main/java/org/overture/codegen/traces/TraceNames.java new file mode 100644 index 0000000000..04798956bb --- /dev/null +++ b/core/codegen/src/main/java/org/overture/codegen/traces/TraceNames.java @@ -0,0 +1,128 @@ +package org.overture.codegen.traces; + +public class TraceNames +{ + // Related to TraceNode + + public String voidValueEnclosingClassName() + { + return "Utils"; + } + + public String voidValueFieldName() + { + return "VOID_VALUE"; + } + + // Related to the AlternativeTraceNode + + public String altTraceNodeNodeClassName() + { + return "AlternativeTraceNode"; + } + + public String altTraceNodeNamePrefix() + { + return "alternatives_"; + } + + // Related to the StatementTraceNode + + public String stmTraceNodeClassName() + { + return "StatementTraceNode"; + } + + public String stmTraceNodeNamePrefix() + { + return "apply_"; + } + + // Related to the CallStatement + + public String callStmClassTypeName() + { + return "CallStatement"; + } + + public String callStmNamePrefix() + { + return "callStm_"; + } + + public String callStmMethodNamePrefix() + { + return "execute"; + } + + public String callStmMethodParamName() + { + return "instance"; + } + + public String callStmArgNamePrefix() + { + return "arg_"; + } + + public String callStmResultNamePrefix() + { + return "result_"; + } + + // Related to the SequenceTraceNode + + public String seqTraceNodeNamePrefix() + { + return "sequence_"; + } + + public String seqClassTypeName() + { + return "SequenceTraceNode"; + } + + // Related to the ConcurrentTraceNode + + public String concTraceNodeNamePrefix() + { + return "concurrent_"; + } + + public String concTraceNodeNodeClassName() + { + return "ConcurrentTraceNode"; + } + + // Related to the RepeatTraceNode + + public String repeatTraceNodeNamePrefix() + { + return "repeat_"; + } + + public String repeatTraceNodeNodeClassName() + { + return "RepeatTraceNode"; + } + + public String runtimePackage() + { + return "org.overture.codegen.runtime"; + } + + //Name of the method that when invoked executes the trace + + public String runTraceMethodName() + { + return "Run"; + } + + // Name of the method that is used to add child trace nodes to + // a parent trace node + + public String addMethodName() + { + return "add"; + } +} From 0948a035acc2f5aab9624c39ec22ded0819bcf36 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sun, 4 Jan 2015 21:56:10 +0100 Subject: [PATCH 002/323] Added a simple analysis to determine if a named trace can be code generated --- .../traces/TraceSupportedAnalysis.java | 46 +++++++++++++++++++ 1 file changed, 46 insertions(+) create mode 100644 core/codegen/src/main/java/org/overture/codegen/traces/TraceSupportedAnalysis.java diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/TraceSupportedAnalysis.java b/core/codegen/src/main/java/org/overture/codegen/traces/TraceSupportedAnalysis.java new file mode 100644 index 0000000000..62e0defaa4 --- /dev/null +++ b/core/codegen/src/main/java/org/overture/codegen/traces/TraceSupportedAnalysis.java @@ -0,0 +1,46 @@ +package org.overture.codegen.traces; + +import org.overture.codegen.cgast.analysis.AnalysisException; +import org.overture.codegen.cgast.analysis.DepthFirstAnalysisAdaptor; +import org.overture.codegen.cgast.statements.ASuperCallStmCG; + +/** + * This analysis determines if a named trace can be code + * generated. + * + * Code generation of traces currently does not support call object + * statements which contain explicit field module names + * different from the name of the enclosing class. Example: + * + * A quoted method call is only supported if the explicit + * module name is equal to that of the enclosing class. Say A + * is a sub class of S and 'a' is an instance of A then a.A`op(); + * is allowed (although it is the same as a.op()). However, + * a.S`op(); is not allowed. + * + * This is already reported as unsupported at the IR level so there + * is no need for this analysis to detect this case. + * + * The super call statement is, however, not supported by the code + * generator when it does appear in traces. Therefore, this analysis + * will detect this case. + * + * @author pvj + * + */ +public class TraceSupportedAnalysis extends DepthFirstAnalysisAdaptor +{ + private boolean usesSuperCall = false; + + @Override + public void caseASuperCallStmCG(ASuperCallStmCG node) + throws AnalysisException + { + usesSuperCall = true; + } + + public boolean usesSuperCall() + { + return usesSuperCall; + } +} From 6ea684d76cfb8003a1fdbda6913887bf74c4e5eb Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sun, 4 Jan 2015 22:07:38 +0100 Subject: [PATCH 003/323] Added an analysis to cast down a variable expression to a certain class type. The analysis is used to generate traces. --- .../codegen/traces/VarExpCasting.java | 29 +++++++++++++++++++ 1 file changed, 29 insertions(+) create mode 100644 core/codegen/src/main/java/org/overture/codegen/traces/VarExpCasting.java diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/VarExpCasting.java b/core/codegen/src/main/java/org/overture/codegen/traces/VarExpCasting.java new file mode 100644 index 0000000000..9ff6dc7175 --- /dev/null +++ b/core/codegen/src/main/java/org/overture/codegen/traces/VarExpCasting.java @@ -0,0 +1,29 @@ +package org.overture.codegen.traces; + +import org.overture.codegen.cgast.analysis.AnalysisException; +import org.overture.codegen.cgast.analysis.DepthFirstAnalysisAdaptor; +import org.overture.codegen.cgast.expressions.ACastUnaryExpCG; +import org.overture.codegen.cgast.expressions.SVarExpCG; +import org.overture.codegen.trans.assistants.TransAssistantCG; + +public class VarExpCasting extends DepthFirstAnalysisAdaptor +{ + private String className; + private TransAssistantCG transAssistant; + + public VarExpCasting(TransAssistantCG transAssistant, String className) + { + this.className = className; + this.transAssistant = transAssistant; + } + + @Override + public void defaultInSVarExpCG(SVarExpCG node) throws AnalysisException + { + ACastUnaryExpCG castVar = new ACastUnaryExpCG(); + transAssistant.replaceNodeWith(node, castVar); + + castVar.setType(transAssistant.consClassType(className)); + castVar.setExp(node); + } +} From 22a8d4fe91fb5ad65d8bcb307fcc764860866b74 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sun, 4 Jan 2015 22:30:29 +0100 Subject: [PATCH 004/323] Added an analysis to make ensure that object designators are local. If an object designators appearing in a call statement is not local (its self or an instance variable etc.) then this analysis ensures that the member invoked is accesssed via the parameter 'instance' passed to the method executing the call statement of a trace. For example a trace a.op() in class S must be generated as ((S) instance).a.op() --- .../EnsureLocalObjDesignatorAnalysis.java | 127 ++++++++++++++++++ 1 file changed, 127 insertions(+) create mode 100644 core/codegen/src/main/java/org/overture/codegen/traces/EnsureLocalObjDesignatorAnalysis.java diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/EnsureLocalObjDesignatorAnalysis.java b/core/codegen/src/main/java/org/overture/codegen/traces/EnsureLocalObjDesignatorAnalysis.java new file mode 100644 index 0000000000..c8c3815a10 --- /dev/null +++ b/core/codegen/src/main/java/org/overture/codegen/traces/EnsureLocalObjDesignatorAnalysis.java @@ -0,0 +1,127 @@ +package org.overture.codegen.traces; + +import org.overture.codegen.cgast.INode; +import org.overture.codegen.cgast.SExpCG; +import org.overture.codegen.cgast.analysis.AnalysisException; +import org.overture.codegen.cgast.analysis.AnswerAdaptor; +import org.overture.codegen.cgast.expressions.AIdentifierVarExpCG; +import org.overture.codegen.cgast.expressions.SVarExpCG; +import org.overture.codegen.cgast.statements.AApplyObjectDesignatorCG; +import org.overture.codegen.cgast.statements.AFieldObjectDesignatorCG; +import org.overture.codegen.cgast.statements.AIdentifierObjectDesignatorCG; +import org.overture.codegen.cgast.statements.ANewObjectDesignatorCG; +import org.overture.codegen.cgast.statements.ASelfObjectDesignatorCG; +import org.overture.codegen.cgast.types.AClassTypeCG; +import org.overture.codegen.logging.Logger; +import org.overture.codegen.trans.assistants.TransAssistantCG; + +public class EnsureLocalObjDesignatorAnalysis extends AnswerAdaptor +{ + private TransAssistantCG transAssistant; + private TraceNames tracePrefixes; + private String traceEnclosingClass; + + public EnsureLocalObjDesignatorAnalysis(TransAssistantCG transAssistant, TraceNames tracePrefixes, String traceEnclosingClass) + { + this.transAssistant = transAssistant; + this.traceEnclosingClass = traceEnclosingClass; + this.tracePrefixes = tracePrefixes; + } + + @Override + public AIdentifierObjectDesignatorCG caseAApplyObjectDesignatorCG(AApplyObjectDesignatorCG node) + throws AnalysisException + { + return node.getObject().apply(this); + } + + @Override + public AIdentifierObjectDesignatorCG caseAFieldObjectDesignatorCG(AFieldObjectDesignatorCG node) + throws AnalysisException + { + return node.getObject().apply(this); + } + + @Override + public AIdentifierObjectDesignatorCG caseAIdentifierObjectDesignatorCG( + AIdentifierObjectDesignatorCG node) throws AnalysisException + { + SExpCG exp = node.getExp(); + + if (exp instanceof SVarExpCG) + { + SVarExpCG varExp = (SVarExpCG) exp; + Boolean isLocal = varExp.getIsLocal(); + + if (isLocal != null) + { + if (!isLocal) + { + AIdentifierObjectDesignatorCG objId = consObjId(); + + AFieldObjectDesignatorCG fieldObj = new AFieldObjectDesignatorCG(); + fieldObj.setFieldModule(traceEnclosingClass); + fieldObj.setFieldName(varExp.getName()); + fieldObj.setObject(objId); + + transAssistant.replaceNodeWith(node, fieldObj); + + + return objId; + } + return null; + } + } + + Logger.getLog().printErrorln("Could not determine if variable declaration " + + "was local or not (in IsLocalObjDesignatorAnalysis)"); + + return null; + } + + @Override + public AIdentifierObjectDesignatorCG caseANewObjectDesignatorCG(ANewObjectDesignatorCG node) + throws AnalysisException + { + // Nothing to be done + return null; + } + + @Override + public AIdentifierObjectDesignatorCG caseASelfObjectDesignatorCG(ASelfObjectDesignatorCG node) + throws AnalysisException + { + AIdentifierObjectDesignatorCG objId = consObjId(); + transAssistant.replaceNodeWith(node, objId); + + return objId; + } + + private AIdentifierObjectDesignatorCG consObjId() + { + String name = tracePrefixes.callStmMethodParamName(); + AClassTypeCG classType = transAssistant.consClassType(traceEnclosingClass); + AIdentifierVarExpCG idVar = transAssistant.consIdentifierVar(name, classType); + + AIdentifierObjectDesignatorCG objId = new AIdentifierObjectDesignatorCG(); + objId.setExp(idVar); + + return objId; + } + + @Override + public AIdentifierObjectDesignatorCG createNewReturnValue(INode node) + throws AnalysisException + { + assert false : "Should not happen"; + return null; + } + + @Override + public AIdentifierObjectDesignatorCG createNewReturnValue(Object node) + throws AnalysisException + { + assert false : "Should not happen"; + return null; + } +} From 87c4afc5cf50acefa5661c03c817b4db2a5c66bb Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sun, 4 Jan 2015 22:36:56 +0100 Subject: [PATCH 005/323] Added functionality to generate a toString representation of a call statement in a trace --- .../traces/ICallStmToStringMethodBuilder.java | 10 ++ .../traces/JavaCallStmToStringBuilder.java | 103 ++++++++++++++++++ 2 files changed, 113 insertions(+) create mode 100644 core/codegen/src/main/java/org/overture/codegen/traces/ICallStmToStringMethodBuilder.java create mode 100644 core/codegen/src/main/java/org/overture/codegen/traces/JavaCallStmToStringBuilder.java diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/ICallStmToStringMethodBuilder.java b/core/codegen/src/main/java/org/overture/codegen/traces/ICallStmToStringMethodBuilder.java new file mode 100644 index 0000000000..923340c016 --- /dev/null +++ b/core/codegen/src/main/java/org/overture/codegen/traces/ICallStmToStringMethodBuilder.java @@ -0,0 +1,10 @@ +package org.overture.codegen.traces; + +import org.overture.codegen.cgast.SStmCG; +import org.overture.codegen.cgast.declarations.AMethodDeclCG; +import org.overture.codegen.ir.IRInfo; + +public interface ICallStmToStringMethodBuilder +{ + public AMethodDeclCG consToString(IRInfo info, SStmCG callStm); +} diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/JavaCallStmToStringBuilder.java b/core/codegen/src/main/java/org/overture/codegen/traces/JavaCallStmToStringBuilder.java new file mode 100644 index 0000000000..62d1359d7e --- /dev/null +++ b/core/codegen/src/main/java/org/overture/codegen/traces/JavaCallStmToStringBuilder.java @@ -0,0 +1,103 @@ +package org.overture.codegen.traces; + +import java.util.LinkedList; + +import org.overture.codegen.cgast.SExpCG; +import org.overture.codegen.cgast.SObjectDesignatorCG; +import org.overture.codegen.cgast.SStmCG; +import org.overture.codegen.cgast.STypeCG; +import org.overture.codegen.cgast.declarations.AMethodDeclCG; +import org.overture.codegen.cgast.expressions.AApplyExpCG; +import org.overture.codegen.cgast.expressions.ASeqConcatBinaryExpCG; +import org.overture.codegen.cgast.statements.ACallObjectStmCG; +import org.overture.codegen.cgast.statements.APlainCallStmCG; +import org.overture.codegen.cgast.statements.AReturnStmCG; +import org.overture.codegen.cgast.types.AClassTypeCG; +import org.overture.codegen.cgast.types.AStringTypeCG; +import org.overture.codegen.ir.IRInfo; +import org.overture.codegen.logging.Logger; +import org.overture.codegen.vdm2java.JavaClassCreatorBase; + +public class JavaCallStmToStringBuilder extends JavaClassCreatorBase implements ICallStmToStringMethodBuilder +{ + @Override + public AMethodDeclCG consToString(IRInfo info, SStmCG callStm) + { + AMethodDeclCG toStringMethod = consToStringSignature(); + + AReturnStmCG body = new AReturnStmCG(); + + if (callStm instanceof APlainCallStmCG) + { + APlainCallStmCG plainCall = (APlainCallStmCG) callStm; + + STypeCG type = plainCall.getClassType(); + String name = plainCall.getName(); + LinkedList args = plainCall.getArgs(); + + String prefix = ""; + + if (type instanceof AClassTypeCG) + { + prefix = ((AClassTypeCG) type).getName() + "`"; + } + + prefix += name; + + body.setExp(appendArgs(info, args, prefix)); + + } else if (callStm instanceof ACallObjectStmCG) + { + ACallObjectStmCG callObj = (ACallObjectStmCG) callStm; + + SObjectDesignatorCG obj = callObj.getDesignator(); + String field = callObj.getFieldName(); + LinkedList args = callObj.getArgs(); + + String prefix = obj.toString(); + prefix += "." + field; + + body.setExp(appendArgs(info, args, prefix)); + } else + { + Logger.getLog().printErrorln("Expected statement to be a call statement or call object statement. Got: " + + callStm); + body.setExp(info.getExpAssistant().consStringLiteral("Unknown", false)); + } + + toStringMethod.setBody(body); + + return toStringMethod; + } + + private SExpCG appendArgs(IRInfo info, LinkedList args, String prefix) + { + if (args == null || args.isEmpty()) + { + return info.getExpAssistant().consStringLiteral(prefix + "()", false); + } + + ASeqConcatBinaryExpCG str = new ASeqConcatBinaryExpCG(); + str.setType(new AStringTypeCG()); + str.setLeft(info.getExpAssistant().consStringLiteral(prefix + "(", false)); + + ASeqConcatBinaryExpCG next = str; + + for (SExpCG arg : args) + { + ASeqConcatBinaryExpCG tmp = new ASeqConcatBinaryExpCG(); + tmp.setType(new AStringTypeCG()); + + AApplyExpCG utilsToStrCall = consUtilsToStringCall(); + utilsToStrCall.getArgs().add(arg.clone()); + tmp.setLeft(utilsToStrCall); + + next.setRight(tmp); + next = tmp; + } + + next.setRight(info.getExpAssistant().consStringLiteral(")", false)); + + return str; + } +} From 0304844919a9ae772f561a04df7d929dba1f5ed2 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sun, 4 Jan 2015 22:41:45 +0100 Subject: [PATCH 006/323] Added an iteratin strategy to handle generation of the traces let be st trace declaration --- .../codegen/traces/TraceLetBeStStrategy.java | 124 ++++++++++++++++++ 1 file changed, 124 insertions(+) create mode 100644 core/codegen/src/main/java/org/overture/codegen/traces/TraceLetBeStStrategy.java diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/TraceLetBeStStrategy.java b/core/codegen/src/main/java/org/overture/codegen/traces/TraceLetBeStStrategy.java new file mode 100644 index 0000000000..05b29a1f33 --- /dev/null +++ b/core/codegen/src/main/java/org/overture/codegen/traces/TraceLetBeStStrategy.java @@ -0,0 +1,124 @@ +package org.overture.codegen.traces; + +import java.util.List; + +import org.overture.codegen.cgast.SExpCG; +import org.overture.codegen.cgast.SPatternCG; +import org.overture.codegen.cgast.SStmCG; +import org.overture.codegen.cgast.STypeCG; +import org.overture.codegen.cgast.analysis.AnalysisException; +import org.overture.codegen.cgast.declarations.AVarDeclCG; +import org.overture.codegen.cgast.expressions.AIdentifierVarExpCG; +import org.overture.codegen.cgast.patterns.AIdentifierPatternCG; +import org.overture.codegen.cgast.statements.ABlockStmCG; +import org.overture.codegen.cgast.statements.ACallObjectExpStmCG; +import org.overture.codegen.cgast.statements.AContinueStmCG; +import org.overture.codegen.cgast.statements.AIfStmCG; +import org.overture.codegen.cgast.statements.ALocalPatternAssignmentStmCG; +import org.overture.codegen.cgast.types.SSetTypeCG; +import org.overture.codegen.ir.ITempVarGen; +import org.overture.codegen.trans.TempVarPrefixes; +import org.overture.codegen.trans.assistants.TransAssistantCG; +import org.overture.codegen.trans.iterator.ILanguageIterator; +import org.overture.codegen.trans.let.LetBeStStrategy; + +public class TraceLetBeStStrategy extends LetBeStStrategy +{ + protected TraceNodeData nodeData; + protected AVarDeclCG altTests; + protected AIdentifierPatternCG id; + protected TraceNames tracePrefixes; + + public TraceLetBeStStrategy(TransAssistantCG transformationAssistant, + SExpCG suchThat, SSetTypeCG setType, + ILanguageIterator langIterator, ITempVarGen tempGen, + TempVarPrefixes varPrefixes, TraceNames tracePrefixes, + AIdentifierPatternCG id, AVarDeclCG altTests, TraceNodeData nodeData) + { + super(transformationAssistant, suchThat, setType, langIterator, tempGen, varPrefixes); + + this.tracePrefixes = tracePrefixes; + this.id = id; + this.altTests = altTests; + this.nodeData = nodeData; + } + + @Override + public List getOuterBlockDecls(AIdentifierVarExpCG setVar, + List patterns) throws AnalysisException + { + for (SPatternCG id : patterns) + { + AVarDeclCG decl = transAssistant.consIdDecl(setType, id); + decl.setFinal(true); + decls.add(decl); + } + + return packDecl(altTests); + } + + @Override + public List getPreForLoopStms(AIdentifierVarExpCG setVar, + List patterns, SPatternCG pattern) + { + return null; + } + + @Override + public SExpCG getForLoopCond(AIdentifierVarExpCG setVar, + List patterns, SPatternCG pattern) + throws AnalysisException + { + return langIterator.getForLoopCond(setVar, patterns, pattern); + } + + @Override + public AVarDeclCG getNextElementDeclared(AIdentifierVarExpCG setVar, + List patterns, SPatternCG pattern) + throws AnalysisException + { + AVarDeclCG nextElementDecl = decls.get(count++); + tagNextElementDeclared(nextElementDecl); + + nextElementDecl.setExp(langIterator.consNextElementCall(setVar)); + + return nextElementDecl; + } + + @Override + public ALocalPatternAssignmentStmCG getNextElementAssigned( + AIdentifierVarExpCG setVar, List patterns, + SPatternCG pattern) throws AnalysisException + { + return null; + } + + @Override + public List getForLoopStms(AIdentifierVarExpCG setVar, + List patterns, SPatternCG pattern) + { + ABlockStmCG block = new ABlockStmCG(); + + AIfStmCG ifStm = new AIfStmCG(); + ifStm.setIfExp(transAssistant.getInfo().getExpAssistant().negate(suchThat.clone())); + ifStm.setThenStm(new AContinueStmCG()); + + block.getStatements().add(ifStm); + block.getStatements().add(nodeData.getStms()); + + STypeCG instanceType = altTests.getType().clone(); + String addName = tracePrefixes.addMethodName(); + AIdentifierVarExpCG arg = nodeData.getNodeVar(); + ACallObjectExpStmCG addCall = transAssistant.consInstanceCallStm(instanceType, id.getName(), addName, arg); + block.getStatements().add(addCall); + + return packStm(block); + } + + @Override + public List getPostOuterBlockStms(AIdentifierVarExpCG setVar, + List patterns) + { + return null; + } +} From 1b9cfe1eede1681e66b5c103f1aa9924f805f7f0 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sun, 4 Jan 2015 22:53:11 +0100 Subject: [PATCH 007/323] Added an analysis that generates the individual constructs of a trace (repeat, concurrent, let be st etc.) --- .../codegen/traces/TraceNodeData.java | 26 + .../codegen/traces/TraceStmsBuilder.java | 611 ++++++++++++++++++ 2 files changed, 637 insertions(+) create mode 100644 core/codegen/src/main/java/org/overture/codegen/traces/TraceNodeData.java create mode 100644 core/codegen/src/main/java/org/overture/codegen/traces/TraceStmsBuilder.java diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/TraceNodeData.java b/core/codegen/src/main/java/org/overture/codegen/traces/TraceNodeData.java new file mode 100644 index 0000000000..83a7c8461c --- /dev/null +++ b/core/codegen/src/main/java/org/overture/codegen/traces/TraceNodeData.java @@ -0,0 +1,26 @@ +package org.overture.codegen.traces; + +import org.overture.codegen.cgast.expressions.AIdentifierVarExpCG; +import org.overture.codegen.cgast.statements.ABlockStmCG; + +public class TraceNodeData +{ + private AIdentifierVarExpCG nodeVar; + private ABlockStmCG stms; + + public TraceNodeData(AIdentifierVarExpCG nodeVar, ABlockStmCG stms) + { + this.nodeVar = nodeVar; + this.stms = stms; + } + + public AIdentifierVarExpCG getNodeVar() + { + return nodeVar; + } + + public ABlockStmCG getStms() + { + return stms; + } +} diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/TraceStmsBuilder.java b/core/codegen/src/main/java/org/overture/codegen/traces/TraceStmsBuilder.java new file mode 100644 index 0000000000..2143877f38 --- /dev/null +++ b/core/codegen/src/main/java/org/overture/codegen/traces/TraceStmsBuilder.java @@ -0,0 +1,611 @@ +package org.overture.codegen.traces; + +import java.util.LinkedList; +import java.util.List; + +import org.overture.codegen.cgast.INode; +import org.overture.codegen.cgast.SDeclCG; +import org.overture.codegen.cgast.SExpCG; +import org.overture.codegen.cgast.SObjectDesignatorCG; +import org.overture.codegen.cgast.SPatternCG; +import org.overture.codegen.cgast.SStmCG; +import org.overture.codegen.cgast.STraceDeclCG; +import org.overture.codegen.cgast.STypeCG; +import org.overture.codegen.cgast.analysis.AnalysisException; +import org.overture.codegen.cgast.analysis.AnswerAdaptor; +import org.overture.codegen.cgast.declarations.AClassDeclCG; +import org.overture.codegen.cgast.declarations.AFieldDeclCG; +import org.overture.codegen.cgast.declarations.AFormalParamLocalParamCG; +import org.overture.codegen.cgast.declarations.AMethodDeclCG; +import org.overture.codegen.cgast.declarations.AVarDeclCG; +import org.overture.codegen.cgast.expressions.AAnonymousClassExpCG; +import org.overture.codegen.cgast.expressions.AApplyExpCG; +import org.overture.codegen.cgast.expressions.ACastUnaryExpCG; +import org.overture.codegen.cgast.expressions.AExplicitVarExpCG; +import org.overture.codegen.cgast.expressions.AFieldExpCG; +import org.overture.codegen.cgast.expressions.AIdentifierVarExpCG; +import org.overture.codegen.cgast.expressions.AIntLiteralExpCG; +import org.overture.codegen.cgast.expressions.ANewExpCG; +import org.overture.codegen.cgast.expressions.SVarExpCG; +import org.overture.codegen.cgast.name.ATypeNameCG; +import org.overture.codegen.cgast.patterns.AIdentifierPatternCG; +import org.overture.codegen.cgast.patterns.ASetMultipleBindCG; +import org.overture.codegen.cgast.statements.ABlockStmCG; +import org.overture.codegen.cgast.statements.ACallObjectExpStmCG; +import org.overture.codegen.cgast.statements.ACallObjectStmCG; +import org.overture.codegen.cgast.statements.AIdentifierObjectDesignatorCG; +import org.overture.codegen.cgast.statements.APlainCallStmCG; +import org.overture.codegen.cgast.statements.AReturnStmCG; +import org.overture.codegen.cgast.statements.ASkipStmCG; +import org.overture.codegen.cgast.statements.SCallStmCG; +import org.overture.codegen.cgast.traces.AApplyExpTraceCoreDeclCG; +import org.overture.codegen.cgast.traces.ABracketedExpTraceCoreDeclCG; +import org.overture.codegen.cgast.traces.AConcurrentExpTraceCoreDeclCG; +import org.overture.codegen.cgast.traces.ALetBeStBindingTraceDeclCG; +import org.overture.codegen.cgast.traces.ALetDefBindingTraceDeclCG; +import org.overture.codegen.cgast.traces.ARepeatTraceDeclCG; +import org.overture.codegen.cgast.traces.ATraceDeclTermCG; +import org.overture.codegen.cgast.types.AClassTypeCG; +import org.overture.codegen.cgast.types.AExternalTypeCG; +import org.overture.codegen.cgast.types.AMethodTypeCG; +import org.overture.codegen.cgast.types.AObjectTypeCG; +import org.overture.codegen.cgast.types.AVoidTypeCG; +import org.overture.codegen.cgast.types.SSetTypeCG; +import org.overture.codegen.ir.IRConstants; +import org.overture.codegen.ir.IRInfo; +import org.overture.codegen.ir.SourceNode; +import org.overture.codegen.logging.Logger; +import org.overture.codegen.trans.TempVarPrefixes; +import org.overture.codegen.trans.assistants.TransAssistantCG; +import org.overture.codegen.trans.iterator.ILanguageIterator; +import org.overture.codegen.trans.uniontypes.ObjectDesignatorToExpCG; + +public class TraceStmsBuilder extends AnswerAdaptor +{ + private IRInfo info; + private List classes; + private TransAssistantCG transAssistant; + private TempVarPrefixes varPrefixes; + private ILanguageIterator langIterator; + private ICallStmToStringMethodBuilder toStringBuilder; + + private TraceNames tracePrefixes; + private String traceEnclosingClass; + + public TraceStmsBuilder(IRInfo info, List classes, + TransAssistantCG transAssistant, TempVarPrefixes varPrefixes, + TraceNames tracePrefixes, ILanguageIterator langIterator, + ICallStmToStringMethodBuilder toStringBuilder, + String traceEnclosingClass) + { + this.info = info; + this.classes = classes; + this.transAssistant = transAssistant; + this.varPrefixes = varPrefixes; + this.langIterator = langIterator; + this.toStringBuilder = toStringBuilder; + + this.tracePrefixes = tracePrefixes; + this.traceEnclosingClass = traceEnclosingClass; + } + + @Override + public TraceNodeData caseATraceDeclTermCG(ATraceDeclTermCG node) + throws AnalysisException + { + String name = info.getTempVarNameGen().nextVarName(tracePrefixes.altTraceNodeNamePrefix()); + AClassTypeCG classType = transAssistant.consClassType(tracePrefixes.altTraceNodeNodeClassName()); + + if (node.getTraceDecls().size() == 1) + { + return node.getTraceDecls().getFirst().apply(this); + } + { + AVarDeclCG altTests = transAssistant.consDecl(name, classType, transAssistant.consDefaultConsCall(classType)); + + ABlockStmCG stms = new ABlockStmCG(); + stms.getLocalDefs().add(altTests); + + List addStms = new LinkedList(); + + for (STraceDeclCG traceDecl : node.getTraceDecls()) + { + TraceNodeData nodeData = traceDecl.apply(this); + + stms.getStatements().add(nodeData.getStms()); + addStms.add(transAssistant.consInstanceCallStm(classType, name, tracePrefixes.addMethodName(), nodeData.getNodeVar())); + } + + return new TraceNodeData(transAssistant.consIdentifierVar(name, classType.clone()), stms); + } + } + + @Override + public TraceNodeData caseAApplyExpTraceCoreDeclCG( + AApplyExpTraceCoreDeclCG node) throws AnalysisException + { + List argDecls = replaceArgsWithVars(node.getCallStm()); + + AClassTypeCG callStmType = transAssistant.consClassType(tracePrefixes.callStmClassTypeName()); + String callStmName = info.getTempVarNameGen().nextVarName(tracePrefixes.callStmNamePrefix()); + AAnonymousClassExpCG callStmCreation = new AAnonymousClassExpCG(); + callStmCreation.setType(callStmType); + callStmCreation.getMethods().add(consExecuteMethod(node.getCallStm().clone())); + callStmCreation.getMethods().add(toStringBuilder.consToString(info, node.getCallStm())); + AVarDeclCG callStmDecl = transAssistant.consDecl(callStmName, callStmType.clone(), callStmCreation); + + AClassTypeCG stmTraceNodeType = transAssistant.consClassType(tracePrefixes.stmTraceNodeClassName()); + ANewExpCG newStmTraceNodeExp = transAssistant.consDefaultConsCall(stmTraceNodeType); + newStmTraceNodeExp.getArgs().add(transAssistant.consIdentifierVar(callStmName, callStmType.clone())); + + String stmNodeName = info.getTempVarNameGen().nextVarName(tracePrefixes.stmTraceNodeNamePrefix()); + AVarDeclCG stmNodeDecl = transAssistant.consDecl(stmNodeName, stmTraceNodeType.clone(), newStmTraceNodeExp); + + ABlockStmCG decls = new ABlockStmCG(); + decls.getLocalDefs().addAll(argDecls); + decls.getLocalDefs().add(callStmDecl); + decls.getLocalDefs().add(stmNodeDecl); + + return new TraceNodeData(transAssistant.consIdentifierVar(stmNodeName, stmTraceNodeType.clone()), decls); + } + + @Override + public TraceNodeData caseABracketedExpTraceCoreDeclCG( + ABracketedExpTraceCoreDeclCG node) throws AnalysisException + { + return buildFromDeclTerms(node.getTerms()); + } + + @Override + public TraceNodeData caseAConcurrentExpTraceCoreDeclCG( + AConcurrentExpTraceCoreDeclCG node) throws AnalysisException + { + String name = info.getTempVarNameGen().nextVarName(tracePrefixes.concTraceNodeNamePrefix()); + + AClassTypeCG classType = transAssistant.consClassType(tracePrefixes.concTraceNodeNodeClassName()); + + AVarDeclCG concNodeDecl = transAssistant.consDecl(name, classType, transAssistant.consDefaultConsCall(classType)); + + ABlockStmCG stms = new ABlockStmCG(); + stms.getLocalDefs().add(concNodeDecl); + + List addStms = new LinkedList(); + + // The number of declarations is > 1 + for (STraceDeclCG term : node.getDecls()) + { + TraceNodeData nodeData = term.apply(this); + stms.getStatements().add(nodeData.getStms()); + + AIdentifierVarExpCG var = nodeData.getNodeVar(); + addStms.add(transAssistant.consInstanceCallStm(classType, name, tracePrefixes.addMethodName(), var)); + } + + stms.getStatements().addAll(addStms); + + return new TraceNodeData(transAssistant.consIdentifierVar(name, classType.clone()), stms); + } + + @Override + public TraceNodeData caseALetBeStBindingTraceDeclCG( + ALetBeStBindingTraceDeclCG node) throws AnalysisException + { + String name = info.getTempVarNameGen().nextVarName(tracePrefixes.altTraceNodeNamePrefix()); + + AClassTypeCG classType = transAssistant.consClassType(tracePrefixes.altTraceNodeNodeClassName()); + + AIdentifierPatternCG id = transAssistant.consIdPattern(name); + + AVarDeclCG altTests = transAssistant.consDecl(name, classType, transAssistant.consDefaultConsCall(classType)); + + ASetMultipleBindCG bind = node.getBind(); + STraceDeclCG body = node.getBody(); + SExpCG exp = node.getStExp(); + + TraceNodeData bodyTraceData = body.apply(this); + + SSetTypeCG setType = transAssistant.getSetTypeCloned(bind.getSet()); + TraceLetBeStStrategy strategy = new TraceLetBeStStrategy(transAssistant, exp, setType, langIterator, info.getTempVarNameGen(), varPrefixes, tracePrefixes, id, altTests, bodyTraceData); + + if (transAssistant.hasEmptySet(bind)) + { + transAssistant.cleanUpBinding(bind); + return new TraceNodeData(null, wrap(new ASkipStmCG())); + } + + LinkedList patterns = bind.getPatterns(); + ABlockStmCG outerBlock = transAssistant.consIterationBlock(patterns, bind.getSet(), info.getTempVarNameGen(), strategy); + + return new TraceNodeData(transAssistant.consIdentifierVar(name, classType.clone()), wrap(outerBlock)); + } + + @Override + public TraceNodeData caseALetDefBindingTraceDeclCG( + ALetDefBindingTraceDeclCG node) throws AnalysisException + { + ABlockStmCG declBlock = new ABlockStmCG(); + + for (SDeclCG dec : node.getLocalDecls()) + { + if (dec instanceof AFieldDeclCG) + { + AFieldDeclCG field = (AFieldDeclCG) dec; + + AVarDeclCG varDecl = transAssistant.consDecl(field.getName(), field.getType().clone(), field.getInitial().clone()); + varDecl.setFinal(true); + declBlock.getLocalDefs().add(varDecl); + } else + { + Logger.getLog().printErrorln("Expected field declarations when processing the let def binding in a trace definition. Got: " + + node); + } + + } + TraceNodeData bodyNodeData = node.getBody().apply(this); + + ABlockStmCG resultingStms = new ABlockStmCG(); + resultingStms.getStatements().add(declBlock); + resultingStms.getStatements().add(bodyNodeData.getStms()); + + return new TraceNodeData(bodyNodeData.getNodeVar(), resultingStms); + } + + @Override + public TraceNodeData caseARepeatTraceDeclCG(ARepeatTraceDeclCG node) + throws AnalysisException + { + Long from = node.getFrom(); + Long to = node.getTo(); + + if (from == 1 && to == 1) + { + return node.getCore().apply(this); + } else + { + String name = info.getTempVarNameGen().nextVarName(tracePrefixes.repeatTraceNodeNamePrefix()); + + TraceNodeData traceData = node.getCore().apply(this); + + AIdentifierVarExpCG varArg = traceData.getNodeVar(); + AIntLiteralExpCG fromArg = info.getExpAssistant().consIntLiteral(from); + AIntLiteralExpCG toArg = info.getExpAssistant().consIntLiteral(to); + + AClassTypeCG repeat = transAssistant.consClassType(tracePrefixes.repeatTraceNodeNamePrefix()); + + ABlockStmCG block = new ABlockStmCG(); + block.getStatements().add(traceData.getStms()); + block.getStatements().add(consDecl(tracePrefixes.repeatTraceNodeNodeClassName(), name, varArg, fromArg, toArg)); + + return new TraceNodeData(transAssistant.consIdentifierVar(name, repeat), block); + } + } + + private List replaceArgsWithVars(SStmCG callStm) + { + List args = null; + List decls = new LinkedList(); + if (callStm instanceof SCallStmCG) + { + args = ((SCallStmCG) callStm).getArgs(); + } else if (callStm instanceof ACallObjectStmCG) + { + args = ((ACallObjectStmCG) callStm).getArgs(); + } else + { + Logger.getLog().printErrorln("Expected a call statement or call object statement. Got: " + + callStm); + return decls; + } + + for (SExpCG arg : args) + { + if (!(arg instanceof SVarExpCG)) + { + String argName = info.getTempVarNameGen().nextVarName(tracePrefixes.callStmArgNamePrefix()); + STypeCG type = arg.getType(); + + AVarDeclCG argDecl = transAssistant.consDecl(argName, type.clone(), arg.clone()); + argDecl.setFinal(true); + decls.add(argDecl); + + transAssistant.replaceNodeWith(arg, transAssistant.consIdentifierVar(argName, type.clone())); + } + + } + + return decls; + } + + private AMethodDeclCG consExecuteMethod(SStmCG stm) + { + AMethodTypeCG methodType = new AMethodTypeCG(); + methodType.setResult(new AObjectTypeCG()); + + AMethodDeclCG execMethod = new AMethodDeclCG(); + execMethod.setAbstract(false); + execMethod.setAccess(IRConstants.PUBLIC); + execMethod.setAsync(false); + execMethod.setBody(makeInstanceCall(stm)); + execMethod.setIsConstructor(false); + execMethod.setMethodType(methodType); + execMethod.setName(tracePrefixes.callStmMethodNamePrefix()); + execMethod.setStatic(false); + + AFormalParamLocalParamCG instanceParam = new AFormalParamLocalParamCG(); + instanceParam.setType(new AObjectTypeCG()); + instanceParam.setPattern(transAssistant.consIdPattern(tracePrefixes.callStmMethodParamName())); + + execMethod.getFormalParams().add(instanceParam); + + return execMethod; + } + + + public TraceNodeData buildFromDeclTerms(List terms) + throws AnalysisException + { + String name = info.getTempVarNameGen().nextVarName(tracePrefixes.seqTraceNodeNamePrefix()); + + AClassTypeCG classType = transAssistant.consClassType(tracePrefixes.seqClassTypeName()); + + AVarDeclCG seqNodeDecl = transAssistant.consDecl(name, classType, transAssistant.consDefaultConsCall(classType)); + + ABlockStmCG stms = new ABlockStmCG(); + stms.getLocalDefs().add(seqNodeDecl); + + List addStms = new LinkedList(); + + for (ATraceDeclTermCG term : terms) + { + TraceNodeData nodeData = term.apply(this); + stms.getStatements().add(nodeData.getStms()); + + AIdentifierVarExpCG var = nodeData.getNodeVar(); + addStms.add(transAssistant.consInstanceCallStm(classType, name, tracePrefixes.addMethodName(), var)); + } + + stms.getStatements().addAll(addStms); + + return new TraceNodeData(transAssistant.consIdentifierVar(name, classType.clone()), stms); + } + + private SStmCG makeInstanceCall(SStmCG stm) + { + if (stm instanceof ACallObjectStmCG) + { + // Assume the class enclosing the trace to be S + // self.op(42) becomes ((S)instance).op(42) + // a.op(42) remains a.op(42) if a is local + // a.op(42) becomes ((S)instance).a.op(42) if a is an instance variable + + ACallObjectStmCG callObj = (ACallObjectStmCG) stm; + ensureLocalObjDesignator(callObj.getDesignator()); + + if (callObj.getType() instanceof AVoidTypeCG) + { + return handleVoidValueReturn(stm); + } else + { + try + { + return handleCallStmResult(callObj); + + } catch (AnalysisException e) + { + } + } + } else if (stm instanceof APlainCallStmCG) + { + // Assume the class enclosing the trace to be S + // Example: op(42) becomes ((S)instance).op(42) + try + { + return handlePlainCallStm((APlainCallStmCG) stm); + } catch (AnalysisException e) + { + } + } + // Super call statements are not supported and this case should not be reached! + + Logger.getLog().printErrorln("Got unexpected statement type in TraceStmsBuilder: " + + stm); + + return stm; + } + + private SStmCG handleVoidValueReturn(SStmCG stm) + { + AExternalTypeCG traceNodeClassType = new AExternalTypeCG(); + traceNodeClassType.setName(tracePrefixes.voidValueEnclosingClassName()); + + AExplicitVarExpCG voidValue = new AExplicitVarExpCG(); + voidValue.setType(new AObjectTypeCG()); + voidValue.setClassType(traceNodeClassType); + voidValue.setIsLambda(false); + voidValue.setIsLocal(true); + voidValue.setName(tracePrefixes.voidValueFieldName()); + + AReturnStmCG returnVoidVal = new AReturnStmCG(); + returnVoidVal.setExp(voidValue); + + ABlockStmCG block = new ABlockStmCG(); + + block.getStatements().add(stm); + block.getStatements().add(returnVoidVal); + + return block; + } + + private SStmCG handleCallStmResult(ACallObjectStmCG callObj) + throws AnalysisException + { + AFieldExpCG field = new AFieldExpCG(); + field.setMemberName(callObj.getFieldName()); + field.setObject(callObj.getDesignator().apply(new ObjectDesignatorToExpCG(info, classes))); + field.setType(info.getTypeAssistant().getFieldType(classes, traceEnclosingClass, callObj.getFieldName())); + + AApplyExpCG apply = new AApplyExpCG(); + apply.setRoot(field); + apply.setType(callObj.getType().clone()); + + for (SExpCG arg : callObj.getArgs()) + { + apply.getArgs().add(arg.clone()); + } + + apply.setSourceNode(callObj.getSourceNode()); + apply.setTag(callObj.getSourceNode()); + + String resultName = info.getTempVarNameGen().nextVarName(tracePrefixes.callStmResultNamePrefix()); + + AVarDeclCG resultDecl = transAssistant.consDecl(resultName, callObj.getType().clone(), apply); + AReturnStmCG returnStm = new AReturnStmCG(); + returnStm.setExp(transAssistant.consIdentifierVar(resultName, callObj.getType().clone())); + + ABlockStmCG stms = new ABlockStmCG(); + stms.getLocalDefs().add(resultDecl); + stms.getStatements().add(returnStm); + + return stms; + } + + private SStmCG handlePlainCallStm(APlainCallStmCG callStmCG) + throws AnalysisException + { + if (callStmCG.getIsStatic()) + { + return callStmCG; + } + + List args = callStmCG.getArgs(); + STypeCG classType = callStmCG.getClassType(); + STypeCG type = callStmCG.getType(); + String name = callStmCG.getName(); + + SourceNode sourceNode = callStmCG.getSourceNode(); + + AClassTypeCG consClassType = transAssistant.consClassType(traceEnclosingClass); + + ACastUnaryExpCG cast = new ACastUnaryExpCG(); + cast.setType(consClassType); + cast.setExp(transAssistant.consIdentifierVar(tracePrefixes.callStmMethodParamName(), consClassType.clone())); + + if (type instanceof AVoidTypeCG) + { + ACallObjectExpStmCG paramExp = new ACallObjectExpStmCG(); + paramExp.setObj(cast); + + paramExp.setFieldName(name); + paramExp.setType(type.clone()); + + for (SExpCG arg : args) + { + paramExp.getArgs().add(arg.clone()); + } + + paramExp.setSourceNode(sourceNode); + + return handleVoidValueReturn(paramExp); + } else + { + AFieldExpCG field = new AFieldExpCG(); + String fieldModule = classType instanceof AClassTypeCG ? ((AClassTypeCG) classType).getName() + : traceEnclosingClass; + field.setType(info.getTypeAssistant().getMethodType(info, classes, fieldModule, name, args)); + field.setMemberName(name); + field.setObject(cast); + + AApplyExpCG apply = new AApplyExpCG(); + apply.setType(type.clone()); + apply.setRoot(field); + apply.setSourceNode(callStmCG.getSourceNode()); + + for (SExpCG arg : args) + { + apply.getArgs().add(arg.clone()); + } + + String resultName = info.getTempVarNameGen().nextVarName(tracePrefixes.callStmResultNamePrefix()); + AVarDeclCG resultDecl = transAssistant.consDecl(resultName, type.clone(), apply); + + AReturnStmCG returnStm = new AReturnStmCG(); + returnStm.setExp(transAssistant.consIdentifierVar(resultName, type.clone())); + + ABlockStmCG stms = new ABlockStmCG(); + stms.getLocalDefs().add(resultDecl); + stms.getStatements().add(returnStm); + + return stms; + + } + } + + private void ensureLocalObjDesignator(SObjectDesignatorCG obj) + { + try + { + AIdentifierObjectDesignatorCG objId = obj.apply(new EnsureLocalObjDesignatorAnalysis(transAssistant, tracePrefixes, traceEnclosingClass)); + + if (objId != null) + { + objId.apply(new VarExpCasting(transAssistant, traceEnclosingClass)); + } + + } catch (AnalysisException e) + { + Logger.getLog().printErrorln("Problems encountered when attempting to ensuring a local object designator in TraceStmsBuilder"); + e.printStackTrace(); + } + } + + private ABlockStmCG consDecl(String classTypeName, String varName, + SExpCG... args) + { + ATypeNameCG typeName = transAssistant.consTypeNameForClass(classTypeName); + + AClassTypeCG classType = transAssistant.consClassType(classTypeName); + + ANewExpCG newExp = new ANewExpCG(); + newExp.setName(typeName); + newExp.setType(classType); + + for (SExpCG arg : args) + { + newExp.getArgs().add(arg); + } + + return wrap(transAssistant.consDecl(varName, classType.clone(), newExp)); + } + + public ABlockStmCG wrap(AVarDeclCG decl) + { + ABlockStmCG block = new ABlockStmCG(); + block.getLocalDefs().add(decl); + + return block; + } + + public ABlockStmCG wrap(SStmCG stm) + { + ABlockStmCG block = new ABlockStmCG(); + block.getStatements().add(stm); + + return block; + } + + @Override + public TraceNodeData createNewReturnValue(INode node) + throws AnalysisException + { + assert false : "This should never happen"; + return null; + } + + @Override + public TraceNodeData createNewReturnValue(Object node) + throws AnalysisException + { + assert false : "This should never happen"; + return null; + } +} From 2561d16aedd8e7261b365a255ed791322a13d179 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Mon, 5 Jan 2015 08:18:25 +0100 Subject: [PATCH 008/323] Updates to the constants supporting generation of traces --- .../overture/codegen/traces/TraceNames.java | 20 +++++++++++++++---- 1 file changed, 16 insertions(+), 4 deletions(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/TraceNames.java b/core/codegen/src/main/java/org/overture/codegen/traces/TraceNames.java index 04798956bb..84d7ef34fc 100644 --- a/core/codegen/src/main/java/org/overture/codegen/traces/TraceNames.java +++ b/core/codegen/src/main/java/org/overture/codegen/traces/TraceNames.java @@ -4,14 +4,14 @@ public class TraceNames { // Related to TraceNode - public String voidValueEnclosingClassName() + public String traceNodeNodeClassName() { - return "Utils"; + return "TraceNode"; } - public String voidValueFieldName() + public String executeTestsMethodName() { - return "VOID_VALUE"; + return "executeTests"; } // Related to the AlternativeTraceNode @@ -125,4 +125,16 @@ public String addMethodName() { return "add"; } + + // Utility stuff + + public String voidValueEnclosingClassName() + { + return "Utils"; + } + + public String voidValueFieldName() + { + return "VOID_VALUE"; + } } From 9b6938b5fe76b63a593099f9dc5044d640db0c58 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Mon, 5 Jan 2015 08:26:48 +0100 Subject: [PATCH 009/323] Added a traces transformation This transformation generates IR statements that describe a "trace tree" that can be expanded and then executed --- .../codegen/traces/TracesTransformation.java | 190 ++++++++++++++++++ 1 file changed, 190 insertions(+) create mode 100644 core/codegen/src/main/java/org/overture/codegen/traces/TracesTransformation.java diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/TracesTransformation.java b/core/codegen/src/main/java/org/overture/codegen/traces/TracesTransformation.java new file mode 100644 index 0000000000..58cc87b364 --- /dev/null +++ b/core/codegen/src/main/java/org/overture/codegen/traces/TracesTransformation.java @@ -0,0 +1,190 @@ +package org.overture.codegen.traces; + +import java.util.List; + +import org.overture.codegen.cgast.SStmCG; +import org.overture.codegen.cgast.analysis.AnalysisException; +import org.overture.codegen.cgast.analysis.DepthFirstAnalysisAdaptor; +import org.overture.codegen.cgast.declarations.AClassDeclCG; +import org.overture.codegen.cgast.declarations.AMethodDeclCG; +import org.overture.codegen.cgast.declarations.ANamedTraceDeclCG; +import org.overture.codegen.cgast.expressions.AIdentifierVarExpCG; +import org.overture.codegen.cgast.expressions.ATypeArgExpCG; +import org.overture.codegen.cgast.statements.ABlockStmCG; +import org.overture.codegen.cgast.statements.APlainCallStmCG; +import org.overture.codegen.cgast.types.AExternalTypeCG; +import org.overture.codegen.cgast.types.AMethodTypeCG; +import org.overture.codegen.cgast.types.AVoidTypeCG; +import org.overture.codegen.ir.IRConstants; +import org.overture.codegen.ir.IRInfo; +import org.overture.codegen.logging.Logger; +import org.overture.codegen.trans.TempVarPrefixes; +import org.overture.codegen.trans.assistants.TransAssistantCG; +import org.overture.codegen.trans.iterator.ILanguageIterator; + +public class TracesTransformation extends DepthFirstAnalysisAdaptor +{ + private IRInfo irInfo; + private List classes; + private TransAssistantCG transAssistant; + private TempVarPrefixes tempVarPrefixes; + private ILanguageIterator langIterator; + private ICallStmToStringMethodBuilder toStringBuilder; + private TraceNames tracePrefixes; + + public TracesTransformation(IRInfo irInfo, List classes, + TransAssistantCG transAssistant, TempVarPrefixes tempVarPrefixes, + TraceNames tracePrefixes, ILanguageIterator langIterator, + ICallStmToStringMethodBuilder toStringBuilder) + { + this.irInfo = irInfo; + this.classes = classes; + this.transAssistant = transAssistant; + this.tempVarPrefixes = tempVarPrefixes; + this.langIterator = langIterator; + this.toStringBuilder = toStringBuilder; + + this.tracePrefixes = tracePrefixes; + } + + @Override + public void caseANamedTraceDeclCG(ANamedTraceDeclCG node) + throws AnalysisException + { + if (!traceIsSupported(node)) + { + irInfo.addTransformationWarning(node, "The super call statement is not supported " + + "in traces, and as a consequence the trace is not generated."); + return; + } + + AClassDeclCG enclosingClass = node.getAncestor(AClassDeclCG.class); + + if (enclosingClass != null) + { + enclosingClass.getMethods().add(consTraceMethod(node)); + } else + { + Logger.getLog().printErrorln("Class enclosing trace could not be found so the " + + "generated trace could not be added as a method to the corresponding class"); + } + } + + private boolean traceIsSupported(ANamedTraceDeclCG node) + { + TraceSupportedAnalysis supportedAnalysis = new TraceSupportedAnalysis(); + try + { + node.apply(supportedAnalysis); + } catch (AnalysisException e) + { + Logger.getLog().printErrorln("Could not determine if a trace could be code generated"); + e.printStackTrace(); + return false; + } + + return !supportedAnalysis.usesSuperCall(); + } + + private AMethodDeclCG consTraceMethod(ANamedTraceDeclCG node) + throws AnalysisException + { + AMethodTypeCG methodType = new AMethodTypeCG(); + methodType.setResult(new AVoidTypeCG()); + + AMethodDeclCG traceMethod = new AMethodDeclCG(); + traceMethod.setAbstract(false); + traceMethod.setAccess(IRConstants.PUBLIC); + traceMethod.setBody(consTraceMethodBody(node)); + traceMethod.setIsConstructor(false); + traceMethod.setStatic(true); + traceMethod.setMethodType(methodType); + traceMethod.setName(getTraceName(node) + "_" + + tracePrefixes.runTraceMethodName()); + + return traceMethod; + } + + private SStmCG buildTestExecutionStms(AIdentifierVarExpCG nodeVar, + String traceEnclosingClassName) + { + AExternalTypeCG utilsType = new AExternalTypeCG(); + utilsType.setName(tracePrefixes.traceNodeNodeClassName()); + + APlainCallStmCG executeTestsCall = new APlainCallStmCG(); + executeTestsCall.setClassType(utilsType); + executeTestsCall.setName(tracePrefixes.executeTestsMethodName()); + executeTestsCall.setType(new AVoidTypeCG()); + + ATypeArgExpCG typeArg = new ATypeArgExpCG(); + typeArg.setType(transAssistant.consClassType(traceEnclosingClassName)); + + executeTestsCall.getArgs().add(nodeVar.clone()); + executeTestsCall.getArgs().add(typeArg); + + return executeTestsCall; + } + + private SStmCG consTraceMethodBody(ANamedTraceDeclCG node) + throws AnalysisException + { + String traceEnclosingClass = getTraceEnclosingClass(node); + TraceStmsBuilder stmBuilder = new TraceStmsBuilder(irInfo, classes, transAssistant, + tempVarPrefixes, tracePrefixes, langIterator, toStringBuilder, traceEnclosingClass); + + TraceNodeData nodeData = stmBuilder.buildFromDeclTerms(node.getTerms()); + + ABlockStmCG stms = new ABlockStmCG(); + stms.getStatements().add(nodeData.getStms()); + stms.getStatements().add(buildTestExecutionStms(nodeData.getNodeVar(), getClassName(node))); + + return stms; + } + + private String getTraceEnclosingClass(ANamedTraceDeclCG trace) + { + if (trace != null) + { + AClassDeclCG enclosingClass = trace.getAncestor(AClassDeclCG.class); + if (enclosingClass != null) + { + return enclosingClass.getName(); + } + } + + Logger.getLog().printErrorln("Could not find class declaration enclosing the trace node " + + trace + " in TraceStmsBuilder"); + + return null; + } + + private String getTraceName(ANamedTraceDeclCG node) + { + String methodName = getClassName(node); + + for (int i = 0; i < node.getPathname().size(); i++) + { + methodName += "_" + node.getPathname().get(i).getName(); + } + + return methodName; + } + + private String getClassName(ANamedTraceDeclCG node) + { + AClassDeclCG enclosingClass = node.getAncestor(AClassDeclCG.class); + + String traceClassName = ""; + if (enclosingClass != null) + { + traceClassName = enclosingClass.getName(); + } else + { + Logger.getLog().printErrorln("Could not find enclosing class for " + + node); + traceClassName = "Unknown"; + } + + return traceClassName; + } +} From 0c7fef39da9a5625bb1c65cc621400d38ab78d43 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Mon, 5 Jan 2015 08:29:06 +0100 Subject: [PATCH 010/323] Added the trace name constants to the 'CodeGenBase' class --- .../java/org/overture/codegen/ir/CodeGenBase.java | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/ir/CodeGenBase.java b/core/codegen/src/main/java/org/overture/codegen/ir/CodeGenBase.java index 24e1425ae3..097f438688 100644 --- a/core/codegen/src/main/java/org/overture/codegen/ir/CodeGenBase.java +++ b/core/codegen/src/main/java/org/overture/codegen/ir/CodeGenBase.java @@ -1,6 +1,7 @@ package org.overture.codegen.ir; import org.overture.codegen.logging.ILogger; +import org.overture.codegen.traces.TraceNames; import org.overture.codegen.trans.TempVarPrefixes; import org.overture.codegen.trans.assistants.TransAssistantCG; @@ -34,12 +35,14 @@ public class CodeGenBase protected IRGenerator generator; protected TransAssistantCG transAssistant; protected TempVarPrefixes varPrefixes; + protected TraceNames tracePrefixes; public CodeGenBase(ILogger log) { super(); - this.varPrefixes = new TempVarPrefixes(); this.generator = new IRGenerator(log, OBJ_INIT_CALL_NAME_PREFIX); + this.varPrefixes = new TempVarPrefixes(); + this.tracePrefixes = new TraceNames(); } public void setIRGenerator(IRGenerator generator) @@ -86,4 +89,14 @@ public TempVarPrefixes getTempVarPrefixes() { return varPrefixes; } + + public TraceNames getTracePrefixes() + { + return tracePrefixes; + } + + public void setTracePrefixes(TraceNames tracePrefixes) + { + this.tracePrefixes = tracePrefixes; + } } \ No newline at end of file From 00d23faf05092ce1b98430b1bcdd653f649cf074 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Mon, 5 Jan 2015 08:31:09 +0100 Subject: [PATCH 011/323] Added the traces transformation to the list of transformations used in the Java code generator --- .../org/overture/codegen/vdm2java/JavaTransSeries.java | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaTransSeries.java b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaTransSeries.java index 5d9e649f48..968e521f9f 100644 --- a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaTransSeries.java +++ b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaTransSeries.java @@ -7,6 +7,8 @@ import org.overture.codegen.cgast.expressions.AIntLiteralExpCG; import org.overture.codegen.cgast.types.AExternalTypeCG; import org.overture.codegen.ir.IRInfo; +import org.overture.codegen.traces.JavaCallStmToStringBuilder; +import org.overture.codegen.traces.TracesTransformation; import org.overture.codegen.trans.IPostCheckCreator; import org.overture.codegen.trans.IsExpTransformation; import org.overture.codegen.trans.PostCheckTransformation; @@ -35,7 +37,7 @@ public class JavaTransSeries { private JavaCodeGen codeGen; - + public JavaTransSeries(JavaCodeGen codeGen) { this.codeGen = codeGen; @@ -61,7 +63,8 @@ public DepthFirstAnalysisAdaptor[] consAnalyses(List classes, PostCheckTransformation postCheckTransformation = new PostCheckTransformation(postCheckCreator, irInfo, transAssistant, FUNC_RESULT_NAME_PREFIX, new JavaValueSemanticsTag(false)); IsExpTransformation isExpTransformation = new IsExpTransformation(irInfo, transAssistant, IS_EXP_SUBJECT_NAME_PREFIX); SeqConversionTransformation seqConversionTransformation = new SeqConversionTransformation(transAssistant); - + TracesTransformation tracesTransformation = new TracesTransformation(irInfo, classes, transAssistant, codeGen.getTempVarPrefixes(), codeGen.getTracePrefixes(), langIterator, new JavaCallStmToStringBuilder()); + // Concurrency related transformations SentinelTransformation concurrencytransform = new SentinelTransformation(irInfo, classes); MainClassConcTransformation mainclassTransform = new MainClassConcTransformation(irInfo, classes); @@ -76,7 +79,7 @@ public DepthFirstAnalysisAdaptor[] consAnalyses(List classes, funcValueTransformation, transVisitor, patternTransformation, preCheckTransformation, postCheckTransformation, isExpTransformation, unionTypeTransformation, - javaToStringTransformation, concurrencytransform, + javaToStringTransformation, concurrencytransform, tracesTransformation, mutexTransform, mainclassTransform, seqConversionTransformation, instanceVarPPEval }; return analyses; From 886c7b33802041f985f4a1a1024e319b507fcb0b Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Mon, 5 Jan 2015 08:40:42 +0100 Subject: [PATCH 012/323] Made generation of traces an option in the IR settings --- .../main/java/org/overture/codegen/ir/IRSettings.java | 11 +++++++++++ .../overture/codegen/traces/TracesTransformation.java | 5 +++++ 2 files changed, 16 insertions(+) diff --git a/core/codegen/src/main/java/org/overture/codegen/ir/IRSettings.java b/core/codegen/src/main/java/org/overture/codegen/ir/IRSettings.java index fd74f8a4d5..a57a2789ee 100644 --- a/core/codegen/src/main/java/org/overture/codegen/ir/IRSettings.java +++ b/core/codegen/src/main/java/org/overture/codegen/ir/IRSettings.java @@ -29,6 +29,7 @@ public class IRSettings private boolean generatePreCondChecks; private boolean generatePostConds; private boolean generatePostCondChecks; + private boolean generateTraces; public IRSettings() { @@ -93,4 +94,14 @@ public void setGeneratePostCondChecks(boolean generatePostCondChecks) { this.generatePostCondChecks = generatePostCondChecks; } + + public boolean generateTraces() + { + return generateTraces; + } + + public void setGenerateTraces(boolean generateTraces) + { + this.generateTraces = generateTraces; + } } diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/TracesTransformation.java b/core/codegen/src/main/java/org/overture/codegen/traces/TracesTransformation.java index 58cc87b364..b1843b69d6 100644 --- a/core/codegen/src/main/java/org/overture/codegen/traces/TracesTransformation.java +++ b/core/codegen/src/main/java/org/overture/codegen/traces/TracesTransformation.java @@ -51,6 +51,11 @@ public TracesTransformation(IRInfo irInfo, List classes, public void caseANamedTraceDeclCG(ANamedTraceDeclCG node) throws AnalysisException { + if(!irInfo.getSettings().generateTraces()) + { + return; + } + if (!traceIsSupported(node)) { irInfo.addTransformationWarning(node, "The super call statement is not supported " From d0e7075f3e90218a0ab750eaf45e17180fafb45f Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Mon, 5 Jan 2015 08:41:43 +0100 Subject: [PATCH 013/323] 'JavaCodeGenMain' generates traces by default --- .../main/java/org/overture/codegen/vdm2java/JavaCodeGenMain.java | 1 + 1 file changed, 1 insertion(+) diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGenMain.java b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGenMain.java index 7f15b662df..a8b1b65017 100644 --- a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGenMain.java +++ b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGenMain.java @@ -57,6 +57,7 @@ public static void main(String[] args) irSettings.setGeneratePreCondChecks(false); irSettings.setGeneratePostConds(false); irSettings.setGeneratePostCondChecks(false); + irSettings.setGenerateTraces(true); JavaSettings javaSettings = new JavaSettings(); javaSettings.setDisableCloning(false); From ba31ff37f3edc7c516d6343390449f327ca966ca Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Mon, 5 Jan 2015 09:05:27 +0100 Subject: [PATCH 014/323] Fix: The TraceLetBeStStrategy did not take into account that the suchThat condition could be 'null' --- .../codegen/traces/TraceLetBeStStrategy.java | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/TraceLetBeStStrategy.java b/core/codegen/src/main/java/org/overture/codegen/traces/TraceLetBeStStrategy.java index 05b29a1f33..53a2ba8e14 100644 --- a/core/codegen/src/main/java/org/overture/codegen/traces/TraceLetBeStStrategy.java +++ b/core/codegen/src/main/java/org/overture/codegen/traces/TraceLetBeStStrategy.java @@ -99,11 +99,14 @@ public List getForLoopStms(AIdentifierVarExpCG setVar, { ABlockStmCG block = new ABlockStmCG(); - AIfStmCG ifStm = new AIfStmCG(); - ifStm.setIfExp(transAssistant.getInfo().getExpAssistant().negate(suchThat.clone())); - ifStm.setThenStm(new AContinueStmCG()); - - block.getStatements().add(ifStm); + if (suchThat != null) + { + AIfStmCG ifStm = new AIfStmCG(); + ifStm.setIfExp(transAssistant.getInfo().getExpAssistant().negate(suchThat.clone())); + ifStm.setThenStm(new AContinueStmCG()); + block.getStatements().add(ifStm); + } + block.getStatements().add(nodeData.getStms()); STypeCG instanceType = altTests.getType().clone(); From 59d04a7103c4a03548cd0fcdd1c28ce1efc838a2 Mon Sep 17 00:00:00 2001 From: George Kanakis Date: Mon, 5 Jan 2015 12:12:51 +0100 Subject: [PATCH 015/323] new runtime classes to support static operations. --- .../runtime/StaticOperationsCounters.java | 22 ++++ .../codegen/runtime/StaticSentinel.java | 111 ++++++++++++++++++ core/codegen/.gitignore | 8 -- 3 files changed, 133 insertions(+), 8 deletions(-) create mode 100644 core/codegen-runtime/src/main/java/org/overture/codegen/runtime/StaticOperationsCounters.java create mode 100644 core/codegen-runtime/src/main/java/org/overture/codegen/runtime/StaticSentinel.java delete mode 100644 core/codegen/.gitignore diff --git a/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/StaticOperationsCounters.java b/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/StaticOperationsCounters.java new file mode 100644 index 0000000000..e74b0543bd --- /dev/null +++ b/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/StaticOperationsCounters.java @@ -0,0 +1,22 @@ +package org.overture.codegen.runtime; + + +public class StaticOperationsCounters +{ + public static int methodnumber = 50; + public volatile static long[] act = new long[methodnumber]; //holds the #act history counter. + public volatile static long[] fin = new long[methodnumber]; //holds the #fin history counter. + public volatile static long[] req = new long[methodnumber]; //holds the #req history counter. + public volatile static long[] active = new long[methodnumber]; //holds the #active history counter. + public volatile static long[] waiting = new long[methodnumber]; //holds the #waiting history counter. + +// public StaticOperationsCounters() +// { +// +// act = new long[nrf]; +// fin = new long[(int)nrf]; +// req = new long[(int)nrf]; +// active = new long[(int)nrf]; +// waiting = new long[(int)nrf]; +// } +} diff --git a/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/StaticSentinel.java b/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/StaticSentinel.java new file mode 100644 index 0000000000..2263839a30 --- /dev/null +++ b/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/StaticSentinel.java @@ -0,0 +1,111 @@ +package org.overture.codegen.runtime; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.util.Map; + +public class StaticSentinel +{ + + static Map m; + static StaticOperationsCounters counter; + +// public StaticSentinel(long fnr) +// { +// counter = new StaticOperationsCounters((int)fnr); +// } + + public synchronized static void entering(String classname, long fnr) { + //int fnr = (int) fnr2; //Here the long value is casted into in to be used as index to the arrays. + requesting(classname,(int)fnr);//the #req counter is changed to add one to it. + try{ + if(!evalPP(classname,fnr)) //the first evaluation of the permition predicate. + { + waiting(classname, (int)fnr, +1);//if the permission predicate is false. It add one to the #waiting counter. + while (!evalPP(classname,fnr))//reevaluation of the permission predicate. + { + Sentinel.class.wait(); //actual thread wait method. This freeze the thread waiting for the execution of its method. + } + waiting(classname,(int)fnr, -1); //if predicate changes to true, #waiting is changed to remove one. + } + }catch(InterruptedException e){} + activating(classname,(int)fnr);//the #act and the #active counters are change to add one to them + } + //this method is registering the termination of a method. + public synchronized static void leaving(String classname, int fnr2){ + int fn = fnr2; + m.put(classname, counter.fin[fn]++);//fin[fn]++; //changes the #fin counter adding one to it. + m.put(classname, counter.active[fn]--); //changes the #active counter removing one to it. + stateChanged(); + } + //this method notifies the threads that a counter has be changed to reevaluate their permission predicates. + public synchronized static void stateChanged(){ + StaticSentinel.class.notifyAll(); + } + //The method that actually changes the #req history counter. + private synchronized static void requesting(String classname,int fn){ + m.put(classname, counter.req[fn]++); + stateChanged(); + } + //The method that actually changing the #act and #active history counters. + private synchronized static void activating(String classname,int fn){ + m.put(classname, counter.act[fn]++); + m.put(classname, counter.active[fn]++); + stateChanged(); + } + //The method that actually changing the #waiting history counter. + //The offset defines how many methods of the same name are waiting. + private synchronized static void waiting(String classname, int fnr, int offset){ + m.put(classname, counter.waiting[fnr] += offset); + stateChanged(); + } + + public static boolean evalPP(String ClassName, Long fnr) + { + try{ + Class c = Class.forName(ClassName); + Method m = c.getDeclaredMethod("evaluatePP", Number.class); + Object o = m.invoke(c.newInstance(), fnr); + + return (Boolean) o; + } catch (ClassNotFoundException e) + { + System.out.println("class not found!!"); + } catch (NoSuchMethodException e) + { + System.out.println("method not found!!"); + } catch (SecurityException e) + { + System.out.println("alla not found!!"); + } catch (IllegalAccessException e) + { + System.out.println("invoke did not work!!"); + } catch (IllegalArgumentException e) + { + System.out.println("false arguments!!"); + } catch (InvocationTargetException e) + { + System.out.println("invocation target not found!!"); + } catch (InstantiationException e) + { + System.out.println("new instance not applied!!"); + } + return true; + } +// public static boolean evalPP(String ClassName, Long fnr) +// { +// try{ +// Class c = Class.forName(ClassName); +// Method m = c.getDeclaredMethod(null, Number.class); +// Object o = m.invoke(null, fnr); +// +// return (Boolean) o; +// } +// catch(Exception e) +// { +// +// } +// return true; +// } + +} diff --git a/core/codegen/.gitignore b/core/codegen/.gitignore deleted file mode 100644 index 12c5231300..0000000000 --- a/core/codegen/.gitignore +++ /dev/null @@ -1,8 +0,0 @@ -/target -/target -/target -/target -/target -/target -/target -/target From f2f4f92e8feff17d0510ce837443d9643250c067 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Fri, 23 Jan 2015 07:59:53 +0100 Subject: [PATCH 016/323] Support for traces is only imported if needed --- .../main/java/org/overture/codegen/vdm2java/JavaFormat.java | 5 +++++ .../src/main/resources/JavaTemplates/Declarations/Class.vm | 5 +++++ 2 files changed, 10 insertions(+) diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaFormat.java b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaFormat.java index 24f482f10d..0d88e0aaad 100644 --- a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaFormat.java +++ b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaFormat.java @@ -933,4 +933,9 @@ public static boolean isScoped(ABlockStmCG block) { return block != null && block.getScoped() != null && block.getScoped(); } + + public boolean importTraceSupport(AClassDeclCG node) + { + return info.getSettings().generateTraces() && !node.getTraces().isEmpty(); + } } diff --git a/core/codegen/src/main/resources/JavaTemplates/Declarations/Class.vm b/core/codegen/src/main/resources/JavaTemplates/Declarations/Class.vm index 045fdb8ca7..306a1d2a27 100644 --- a/core/codegen/src/main/resources/JavaTemplates/Declarations/Class.vm +++ b/core/codegen/src/main/resources/JavaTemplates/Declarations/Class.vm @@ -12,6 +12,11 @@ $package #**#import org.overture.codegen.runtime.*; #end ## +#if ($JavaFormat.importTraceSupport($node)) +#**#import org.overture.codegen.runtime.traces.*;## +#end +## +## #set( $abstract = "") #if ($node.getAbstract()) #set( $abstract = "abstract") From eb530470e8a32b5e86cdad3675b2b95f4c7b4bdc Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Fri, 23 Jan 2015 08:12:28 +0100 Subject: [PATCH 017/323] The generated trace method now takes a test accumulator as argument. The test accumulator is a strategy (in the sense of the design pattern) used to hold the test collection. --- .../org/overture/codegen/traces/TraceNames.java | 10 ++++++++++ .../codegen/traces/TracesTransformation.java | 14 ++++++++++++++ 2 files changed, 24 insertions(+) diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/TraceNames.java b/core/codegen/src/main/java/org/overture/codegen/traces/TraceNames.java index 84d7ef34fc..2b66594b42 100644 --- a/core/codegen/src/main/java/org/overture/codegen/traces/TraceNames.java +++ b/core/codegen/src/main/java/org/overture/codegen/traces/TraceNames.java @@ -137,4 +137,14 @@ public String voidValueFieldName() { return "VOID_VALUE"; } + + public String testAccumulatorClassName() + { + return "TestAccumulator"; + } + + public String traceMethodParamName() + { + return "testAccumulator"; + } } diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/TracesTransformation.java b/core/codegen/src/main/java/org/overture/codegen/traces/TracesTransformation.java index b1843b69d6..f3c38a71e0 100644 --- a/core/codegen/src/main/java/org/overture/codegen/traces/TracesTransformation.java +++ b/core/codegen/src/main/java/org/overture/codegen/traces/TracesTransformation.java @@ -6,12 +6,14 @@ import org.overture.codegen.cgast.analysis.AnalysisException; import org.overture.codegen.cgast.analysis.DepthFirstAnalysisAdaptor; import org.overture.codegen.cgast.declarations.AClassDeclCG; +import org.overture.codegen.cgast.declarations.AFormalParamLocalParamCG; import org.overture.codegen.cgast.declarations.AMethodDeclCG; import org.overture.codegen.cgast.declarations.ANamedTraceDeclCG; import org.overture.codegen.cgast.expressions.AIdentifierVarExpCG; import org.overture.codegen.cgast.expressions.ATypeArgExpCG; import org.overture.codegen.cgast.statements.ABlockStmCG; import org.overture.codegen.cgast.statements.APlainCallStmCG; +import org.overture.codegen.cgast.types.AClassTypeCG; import org.overture.codegen.cgast.types.AExternalTypeCG; import org.overture.codegen.cgast.types.AMethodTypeCG; import org.overture.codegen.cgast.types.AVoidTypeCG; @@ -94,10 +96,20 @@ private boolean traceIsSupported(ANamedTraceDeclCG node) private AMethodDeclCG consTraceMethod(ANamedTraceDeclCG node) throws AnalysisException { + AClassTypeCG testAccType = transAssistant.consClassType(tracePrefixes.testAccumulatorClassName()); + AMethodTypeCG methodType = new AMethodTypeCG(); methodType.setResult(new AVoidTypeCG()); + methodType.getParams().add(testAccType); + + AFormalParamLocalParamCG instanceParam = new AFormalParamLocalParamCG(); + instanceParam.setType(testAccType.clone()); + instanceParam.setPattern(transAssistant.consIdPattern(tracePrefixes.traceMethodParamName())); AMethodDeclCG traceMethod = new AMethodDeclCG(); + + traceMethod.getFormalParams().add(instanceParam); + traceMethod.setAbstract(false); traceMethod.setAccess(IRConstants.PUBLIC); traceMethod.setBody(consTraceMethodBody(node)); @@ -126,6 +138,8 @@ private SStmCG buildTestExecutionStms(AIdentifierVarExpCG nodeVar, executeTestsCall.getArgs().add(nodeVar.clone()); executeTestsCall.getArgs().add(typeArg); + executeTestsCall.getArgs().add(transAssistant.consIdentifierVar(tracePrefixes.traceMethodParamName(), + transAssistant.consClassType(tracePrefixes.testAccumulatorClassName()))); return executeTestsCall; } From dd6ee6768042827f3683ae04a77e4f114ad2042e Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Fri, 23 Jan 2015 08:16:29 +0100 Subject: [PATCH 018/323] The parameter type was missing from the trace node call statement method declaration --- .../java/org/overture/codegen/traces/TraceStmsBuilder.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/TraceStmsBuilder.java b/core/codegen/src/main/java/org/overture/codegen/traces/TraceStmsBuilder.java index 2143877f38..b5056e1701 100644 --- a/core/codegen/src/main/java/org/overture/codegen/traces/TraceStmsBuilder.java +++ b/core/codegen/src/main/java/org/overture/codegen/traces/TraceStmsBuilder.java @@ -320,7 +320,8 @@ private AMethodDeclCG consExecuteMethod(SStmCG stm) { AMethodTypeCG methodType = new AMethodTypeCG(); methodType.setResult(new AObjectTypeCG()); - + methodType.getParams().add(new AObjectTypeCG()); + AMethodDeclCG execMethod = new AMethodDeclCG(); execMethod.setAbstract(false); execMethod.setAccess(IRConstants.PUBLIC); From acbf48d9c566e9f8d3b5a835607f24f5192f320d Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Fri, 23 Jan 2015 08:19:03 +0100 Subject: [PATCH 019/323] Improved reporting of unsupported nodes in core/codegen --- .../org/overture/codegen/traces/TermVisitorCG.java | 10 +++++++++- .../overture/codegen/traces/TraceDeclVisitorCG.java | 2 -- .../org/overture/codegen/visitor/DeclVisitorCG.java | 3 ++- .../codegen/visitor/MultipleBindVisitorCG.java | 10 +++++++++- 4 files changed, 20 insertions(+), 5 deletions(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/TermVisitorCG.java b/core/codegen/src/main/java/org/overture/codegen/traces/TermVisitorCG.java index b1c65491f5..64234f082a 100644 --- a/core/codegen/src/main/java/org/overture/codegen/traces/TermVisitorCG.java +++ b/core/codegen/src/main/java/org/overture/codegen/traces/TermVisitorCG.java @@ -20,7 +20,15 @@ public STermCG caseATraceDefinitionTerm(ATraceDefinitionTerm node, for(PTraceDefinition traceDef : node.getList()) { STraceDeclCG traceDefCg = traceDef.apply(question.getTraceDeclVisitor(), question); - termCg.getTraceDecls().add(traceDefCg); + + if(traceDefCg != null) + { + termCg.getTraceDecls().add(traceDefCg); + } + else + { + return null; + } } return termCg; diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/TraceDeclVisitorCG.java b/core/codegen/src/main/java/org/overture/codegen/traces/TraceDeclVisitorCG.java index b79ffa9518..5d21d80257 100644 --- a/core/codegen/src/main/java/org/overture/codegen/traces/TraceDeclVisitorCG.java +++ b/core/codegen/src/main/java/org/overture/codegen/traces/TraceDeclVisitorCG.java @@ -56,8 +56,6 @@ public STraceDeclCG caseALetBeStBindingTraceDefinition( if (!(multipleBindCg instanceof ASetMultipleBindCG)) { - question.addUnsupportedNode(node, "Generation of a multiple set bind was expected to yield " - + "a ASetMultipleBindCG. Got: " + multipleBindCg); return null; } diff --git a/core/codegen/src/main/java/org/overture/codegen/visitor/DeclVisitorCG.java b/core/codegen/src/main/java/org/overture/codegen/visitor/DeclVisitorCG.java index ab5fa6bf53..991631c10c 100644 --- a/core/codegen/src/main/java/org/overture/codegen/visitor/DeclVisitorCG.java +++ b/core/codegen/src/main/java/org/overture/codegen/visitor/DeclVisitorCG.java @@ -117,7 +117,8 @@ public SDeclCG caseANamedTraceDefinition(ANamedTraceDefinition node, } else { - Logger.getLog().printErrorln("Expected term to be of type ATraceDeclTermCG. Got: " + termCg); + // Some sub-construct of the term must be unsupported + return null; } } diff --git a/core/codegen/src/main/java/org/overture/codegen/visitor/MultipleBindVisitorCG.java b/core/codegen/src/main/java/org/overture/codegen/visitor/MultipleBindVisitorCG.java index 60f3604751..99300ffa59 100644 --- a/core/codegen/src/main/java/org/overture/codegen/visitor/MultipleBindVisitorCG.java +++ b/core/codegen/src/main/java/org/overture/codegen/visitor/MultipleBindVisitorCG.java @@ -49,7 +49,15 @@ public SMultipleBindCG caseASetMultipleBind(ASetMultipleBind node, for (PPattern pattern : patterns) { SPatternCG patternTempCg = pattern.apply(question.getPatternVisitor(), question); - patternsCg.add(patternTempCg); + + if(patternTempCg != null) + { + patternsCg.add(patternTempCg); + } + else + { + return null; + } } SExpCG setCg = set.apply(question.getExpVisitor(), question); From fea81940647f609d120bdf2981823356fee10e85 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Fri, 23 Jan 2015 08:27:07 +0100 Subject: [PATCH 020/323] Now the type of an unsupported IR node is also supported --- .../java/org/overture/codegen/vdm2java/JavaCodeGenUtil.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGenUtil.java b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGenUtil.java index 604b210a40..7ce18d1915 100644 --- a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGenUtil.java +++ b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGenUtil.java @@ -337,7 +337,8 @@ public static void printUnsupportedIrNodes(Set unsupportedNodes) for (VdmNodeInfo vdmNodeInfo : nodesSorted) { - Logger.getLog().print(vdmNodeInfo.getNode().toString()); + Logger.getLog().print(vdmNodeInfo.getNode().toString() + + " (" + vdmNodeInfo.getNode().getClass().getSimpleName() + ")"); ILexLocation location = locationAssistant.findLocation(vdmNodeInfo.getNode()); From a5690b959376a5d8e307cedf905fdb5f6c1ea030 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Fri, 23 Jan 2015 08:32:20 +0100 Subject: [PATCH 021/323] Added test for code generation of traces without reduction --- .../org/overture/codegen/tests/TestFlags.java | 1 + .../codegen/tests/TracesNoReductionTest.java | 32 +++++++++++++++++++ .../tests/TracesNoReductionTestCase.java | 27 ++++++++++++++++ 3 files changed, 60 insertions(+) create mode 100644 core/codegen/src/test/java/org/overture/codegen/tests/TracesNoReductionTest.java create mode 100644 core/codegen/src/test/java/org/overture/codegen/tests/TracesNoReductionTestCase.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/TestFlags.java b/core/codegen/src/test/java/org/overture/codegen/tests/TestFlags.java index 67747ac269..13180a70cc 100644 --- a/core/codegen/src/test/java/org/overture/codegen/tests/TestFlags.java +++ b/core/codegen/src/test/java/org/overture/codegen/tests/TestFlags.java @@ -37,4 +37,5 @@ public class TestFlags public static final boolean BIND_TESTS_ON = false; public static final boolean PRE_POST_TESTS_ON = false; public static final boolean RT_TESTS_ON = false; + public static final boolean TRACES_NO_REDUCTION_TESTS_ON = false; } diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/TracesNoReductionTest.java b/core/codegen/src/test/java/org/overture/codegen/tests/TracesNoReductionTest.java new file mode 100644 index 0000000000..63834fe699 --- /dev/null +++ b/core/codegen/src/test/java/org/overture/codegen/tests/TracesNoReductionTest.java @@ -0,0 +1,32 @@ +package org.overture.codegen.tests; + +import java.io.File; +import java.io.IOException; +import java.lang.reflect.InvocationTargetException; + +import junit.framework.Test; +import junit.framework.TestSuite; + +import org.overture.ast.lex.LexLocation; +import org.overture.test.framework.BaseTestSuite; +import org.overture.test.framework.Properties; + +public class TracesNoReductionTest extends BaseTestSuite +{ + public static final String ROOT = "src" + File.separatorChar + "test" + + File.separatorChar + "resources" + File.separatorChar + + "traces_no_reduction_specs"; + + public static Test suite() throws IllegalArgumentException, + SecurityException, InstantiationException, IllegalAccessException, + InvocationTargetException, NoSuchMethodException, IOException + { + LexLocation.absoluteToStringLocation = false; + Properties.recordTestResults = TestFlags.TRACES_NO_REDUCTION_TESTS_ON; + + String name = "Traces no reduction test case"; + TestSuite test = createTestCompleteFile(name, ROOT, TracesNoReductionTestCase.class, ""); + return test; + } +} + diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/TracesNoReductionTestCase.java b/core/codegen/src/test/java/org/overture/codegen/tests/TracesNoReductionTestCase.java new file mode 100644 index 0000000000..dd5fa59999 --- /dev/null +++ b/core/codegen/src/test/java/org/overture/codegen/tests/TracesNoReductionTestCase.java @@ -0,0 +1,27 @@ +package org.overture.codegen.tests; + +import java.io.File; + +import org.overture.codegen.ir.IRSettings; + +public class TracesNoReductionTestCase extends SpecificationTestCase +{ + public TracesNoReductionTestCase() + { + super(); + } + + public TracesNoReductionTestCase(File file) + { + super(file); + } + + @Override + public IRSettings getIrSettings() + { + IRSettings irSettings = super.getIrSettings(); + irSettings.setGenerateTraces(true); + + return irSettings; + } +} From 28f9d31cb6482b74ebf99fc3e8d13b3fad181953 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sat, 24 Jan 2015 12:00:11 +0100 Subject: [PATCH 022/323] Fix: The 'add' statements were missing for the construction of the AlternativeTraceNode --- .../main/java/org/overture/codegen/traces/TraceStmsBuilder.java | 2 ++ 1 file changed, 2 insertions(+) diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/TraceStmsBuilder.java b/core/codegen/src/main/java/org/overture/codegen/traces/TraceStmsBuilder.java index b5056e1701..d4a31235f4 100644 --- a/core/codegen/src/main/java/org/overture/codegen/traces/TraceStmsBuilder.java +++ b/core/codegen/src/main/java/org/overture/codegen/traces/TraceStmsBuilder.java @@ -115,6 +115,8 @@ public TraceNodeData caseATraceDeclTermCG(ATraceDeclTermCG node) stms.getStatements().add(nodeData.getStms()); addStms.add(transAssistant.consInstanceCallStm(classType, name, tracePrefixes.addMethodName(), nodeData.getNodeVar())); } + + stms.getStatements().addAll(addStms); return new TraceNodeData(transAssistant.consIdentifierVar(name, classType.clone()), stms); } From 3331fefe986538db67dd68f22f8ee938f458f4b0 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sat, 24 Jan 2015 23:27:00 +0100 Subject: [PATCH 023/323] Refactoring of test handlers in the core/codegen test execution system --- .../tests/utils/EntryBasedTestHandler.java | 20 +-- .../utils/ExecutableSpecTestHandler.java | 23 +++- .../tests/utils/ExecutableTestHandler.java | 126 +++++++++++++++++- .../tests/utils/JavaExecutionResult.java | 22 +++ .../codegen/tests/utils/TestHandler.java | 60 ++------- 5 files changed, 185 insertions(+), 66 deletions(-) create mode 100644 core/codegen/src/test/java/org/overture/codegen/tests/utils/JavaExecutionResult.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/EntryBasedTestHandler.java b/core/codegen/src/test/java/org/overture/codegen/tests/utils/EntryBasedTestHandler.java index 4dcbcac206..72e8cc1db0 100644 --- a/core/codegen/src/test/java/org/overture/codegen/tests/utils/EntryBasedTestHandler.java +++ b/core/codegen/src/test/java/org/overture/codegen/tests/utils/EntryBasedTestHandler.java @@ -21,31 +21,17 @@ */ package org.overture.codegen.tests.utils; -import java.io.File; - import org.overture.ast.lex.Dialect; import org.overture.config.Release; -import org.overture.config.Settings; -import org.overture.interpreter.util.InterpreterUtil; -import org.overture.interpreter.values.Value; public abstract class EntryBasedTestHandler extends ExecutableTestHandler { - protected static final String ENTRY_CLASS_NAME = "Entry"; - protected static final String ENTRY_METHOD_CALL = "Run()"; - protected static final String JAVA_ENTRY_CALL = ENTRY_CLASS_NAME + "." - + ENTRY_METHOD_CALL; - protected static final String VDM_ENTRY_CALL = ENTRY_CLASS_NAME + "`" - + ENTRY_METHOD_CALL; - public EntryBasedTestHandler(Release release, Dialect dialect) { super(release, dialect); } - @Override - public Value interpretVdm(File intputFile) throws Exception - { - return InterpreterUtil.interpret(Settings.dialect, VDM_ENTRY_CALL, intputFile); - } + abstract public String getVdmEntry(); + + abstract public String getJavaEntry(); } diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExecutableSpecTestHandler.java b/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExecutableSpecTestHandler.java index 7c69b94511..9ae96c5d53 100644 --- a/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExecutableSpecTestHandler.java +++ b/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExecutableSpecTestHandler.java @@ -29,6 +29,9 @@ import org.overture.codegen.ir.CodeGenBase; import org.overture.codegen.ir.IRConstants; import org.overture.config.Release; +import org.overture.config.Settings; +import org.overture.interpreter.util.InterpreterUtil; +import org.overture.interpreter.values.Value; public class ExecutableSpecTestHandler extends EntryBasedTestHandler { @@ -41,7 +44,7 @@ public ExecutableSpecTestHandler(Release release, Dialect dialect) public void writeGeneratedCode(File parent, File resultFile) throws IOException { - injectArgIntoMainClassFile(parent, JAVA_ENTRY_CALL); + injectArgIntoMainClassFile(parent, getJavaEntry()); List content = TestUtils.readJavaModulesFromResultFile(resultFile); @@ -107,4 +110,22 @@ private void injectSerializableInterface(StringBuffer classCgStr, classCgStr.replace(min, firstLeftBraceIdx, replacement); } } + + @Override + public String getJavaEntry() + { + return "Entry.Run()"; + } + + @Override + public String getVdmEntry() + { + return "Entry`Run()"; + } + + @Override + public Value interpretVdm(File intputFile) throws Exception + { + return InterpreterUtil.interpret(Settings.dialect, getVdmEntry(), intputFile); + } } diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExecutableTestHandler.java b/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExecutableTestHandler.java index cfbcdda80b..4245d86aae 100644 --- a/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExecutableTestHandler.java +++ b/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExecutableTestHandler.java @@ -22,6 +22,11 @@ package org.overture.codegen.tests.utils; import java.io.File; +import java.io.FileInputStream; +import java.io.IOException; +import java.io.ObjectInputStream; +import java.util.LinkedList; +import java.util.List; import org.overture.ast.lex.Dialect; import org.overture.config.Release; @@ -30,11 +35,130 @@ public abstract class ExecutableTestHandler extends TestHandler { + public static final String MAIN_CLASS = "Exp"; + + public static final String SERIALIZE_METHOD = + " public static void serialize(){\n" + + " try{\n" + + " File file = new File(\"myData.bin\");\n" + + " FileOutputStream fout = new FileOutputStream( file );\n" + + " ObjectOutputStream oos = new ObjectOutputStream(fout);\n" + + " Object exp = null;\n" + + " try{\n" + + " exp = exp();\n" + + " } catch(Exception e){\n" + + " exp = e.getMessage();\n" + + " }\n" + + " java.lang.System.out.println(exp);\n" + + " oos.writeObject( exp );\n" + + " oos.close();\n" + + " }catch(Exception ex){\n" + + " ex.printStackTrace();\n " + + " }\n" + + " }\n"; + + public String getMainClass() + { + StringBuilder methodsMerged = new StringBuilder(); + + for(String method : getMainClassMethods()) + { + methodsMerged.append(method).append("\n\n"); + } + + return + " import java.io.File;\n" + + "import java.io.FileOutputStream;\n" + + "import java.io.ObjectOutputStream;\n" + + "import org.overture.codegen.runtime.*;\n" + + "import org.overture.codegen.runtime.traces.*;\n" + + "import java.util.*;\n\n" + + "public class Exp {\n" + + " public static Object exp()\n" + + " {\n" + + " return %s;\n" + + " }\n\n" + + " public static void main(String[] args)" + + " {\n" + + " serialize();\n" + + " }\n\n" + + SERIALIZE_METHOD + + methodsMerged + + "}\n"; + } + + private static final String CG_VALUE_BINARY_FILE = "target" + + File.separatorChar + "cgtest" + File.separatorChar + "myData.bin"; + public ExecutableTestHandler(Release release, Dialect dialect) { Settings.release = release; Settings.dialect = dialect; } - + public abstract Value interpretVdm(File intputFile) throws Exception; + + public List getMainClassMethods() + { + return new LinkedList(); + } + + public void injectArgIntoMainClassFile(File parent, String body) + throws IOException + { + File mainClassFile = getMainClassFile(parent); + writeToFile(String.format(getMainClass(), body), mainClassFile); + } + + private File getMainClassFile(File parent) throws IOException + { + return getFile(parent, MAIN_CLASS); + } + + public JavaExecutionResult runJava(File folder) + { + FileInputStream fin = null; + ObjectInputStream ois = null; + + try + { + String processOutput = JavaExecution.run(folder, ExecutableTestHandler.MAIN_CLASS); + + File dataFile = new File(CG_VALUE_BINARY_FILE); + fin = new FileInputStream(dataFile); + ois = new ObjectInputStream(fin); + Object cgValue = (Object) ois.readObject(); + + return new JavaExecutionResult(processOutput, cgValue); + + } catch (Exception e) + { + e.printStackTrace(); + } finally + { + if (fin != null) + { + try + { + fin.close(); + } catch (IOException e) + { + e.printStackTrace(); + } + } + + if (ois != null) + { + try + { + ois.close(); + } catch (IOException e) + { + e.printStackTrace(); + } + } + } + + return null; + } } diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/JavaExecutionResult.java b/core/codegen/src/test/java/org/overture/codegen/tests/utils/JavaExecutionResult.java new file mode 100644 index 0000000000..647c9e9b5a --- /dev/null +++ b/core/codegen/src/test/java/org/overture/codegen/tests/utils/JavaExecutionResult.java @@ -0,0 +1,22 @@ +package org.overture.codegen.tests.utils; + +public class JavaExecutionResult +{ + private String processOutput; + private Object executionResult; + + public JavaExecutionResult(String processOutput, Object executionResult) + { + this.processOutput = processOutput; + this.executionResult = executionResult; + } + + public String getProcessOutput() + { + return processOutput; + } + public Object getExecutionResult() + { + return executionResult; + } +} diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/TestHandler.java b/core/codegen/src/test/java/org/overture/codegen/tests/utils/TestHandler.java index d70f9ebaaa..691a8ad5a7 100644 --- a/core/codegen/src/test/java/org/overture/codegen/tests/utils/TestHandler.java +++ b/core/codegen/src/test/java/org/overture/codegen/tests/utils/TestHandler.java @@ -39,41 +39,19 @@ public abstract class TestHandler { public static final String QUOTES_PACKAGE_NAME = "quotes"; - public static final String MAIN_CLASS = "Exp"; - - public static final String SERIALIZE_METHOD = - - " public static void serialize(){" + " try{" - + " File file = new File(\"myData.bin\");" - + " FileOutputStream fout = new FileOutputStream( file );" - + " ObjectOutputStream oos = new ObjectOutputStream(fout);" - + " Object exp = null;" - + " try{" - + " exp = exp();" - + " } catch(Exception e){" - + " exp = e.getMessage();" - + " }" - + " java.lang.System.out.println(exp);" - + " oos.writeObject( exp );" - + " oos.close();" - + " }catch(Exception ex){ " - + " ex.printStackTrace(); " - + " }" + " }"; - - public static final String EXP_WRAPPER_CODE = "import java.io.File;" - + "import java.io.FileOutputStream;" - + "import java.io.ObjectOutputStream;" - + "import org.overture.codegen.runtime.*;" + "import java.util.*; " - + "public class Exp { " - - + " public static Object exp(){ return %s ; } " - - + " public static void main(String[] args){ " - + " serialize(); " - + " } " - + SERIALIZE_METHOD - + "}"; - + protected File currentInputFile = null; + protected File currentResultFile = null; + + public void setCurrentInputFile(File currentInputFile) + { + this.currentInputFile = currentInputFile; + } + + public void setCurrentResultFile(File currentResultFile) + { + this.currentResultFile = currentResultFile; + } + public TestHandler() { initVdmEnv(); @@ -88,13 +66,6 @@ public void initVdmEnv() public abstract void writeGeneratedCode(File parent, File resultFile) throws IOException; - public void injectArgIntoMainClassFile(File parent, String argument) - throws IOException - { - File mainClassFile = getMainClassFile(parent); - writeToFile(String.format(EXP_WRAPPER_CODE, argument), mainClassFile); - } - public void writeToFile(String toWrite, File file) throws IOException { PrintWriter writer = new PrintWriter(new OutputStreamWriter(new FileOutputStream(file, false), "UTF-8")); @@ -116,11 +87,6 @@ public File getFile(File parent, String className) throws IOException return file; } - private File getMainClassFile(File parent) throws IOException - { - return getFile(parent, MAIN_CLASS); - } - public String readFromFile(File resultFile) throws IOException { return GeneralUtils.readFromFile(resultFile).replace('#', ' '); From ee33368411d50b1ae5a3c97afb3e1804dd8ea002 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sat, 24 Jan 2015 23:29:00 +0100 Subject: [PATCH 024/323] Updated the core/codegen test execution system to work with the new test handlers --- .../codegen/tests/utils/CompileTests.java | 74 +++++++++++-------- 1 file changed, 43 insertions(+), 31 deletions(-) diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/CompileTests.java b/core/codegen/src/test/java/org/overture/codegen/tests/utils/CompileTests.java index aa96a636ac..06bdc4b0b3 100644 --- a/core/codegen/src/test/java/org/overture/codegen/tests/utils/CompileTests.java +++ b/core/codegen/src/test/java/org/overture/codegen/tests/utils/CompileTests.java @@ -22,9 +22,7 @@ package org.overture.codegen.tests.utils; import java.io.File; -import java.io.FileInputStream; import java.io.IOException; -import java.io.ObjectInputStream; import java.lang.reflect.Method; import java.net.URL; import java.net.URLClassLoader; @@ -45,6 +43,7 @@ import org.overture.codegen.tests.PrePostTest; import org.overture.codegen.tests.RtTest; import org.overture.codegen.tests.SpecificationTest; +import org.overture.codegen.tests.TracesNoReductionTest; import org.overture.codegen.tests.UnionTypeTest; import org.overture.codegen.utils.GeneralCodeGenUtils; import org.overture.codegen.utils.GeneralUtils; @@ -54,8 +53,6 @@ public class CompileTests { - private static final String CG_VALUE_BINARY_FILE = "target" - + File.separatorChar + "cgtest" + File.separatorChar + "myData.bin"; private static final String TEMP_DIR = "target" + File.separatorChar + "cgtest"; private static final String SRC_JAVA_LIB = ".." + File.separatorChar @@ -86,7 +83,8 @@ public class CompileTests public static final boolean PRE_POST_TESTS = true; public static final boolean RUN_EXECUTING_CLASSIC_SPEC_TESTS = true; public static final boolean RUN_CONFIGURED_CLONE_TESTS = true; - + public static final boolean RUN_TRACE_TESTS = true; + private List testInputFiles; private List resultFiles; @@ -183,6 +181,11 @@ private void runTests() throws IOException runConfiguredCloningTests(); } + if(RUN_TRACE_TESTS) + { + runTraceTests(); + } + long endTimeMs = System.currentTimeMillis(); long totalTimeMs = endTimeMs - startTimeMs; @@ -194,6 +197,20 @@ private void runTests() throws IOException + String.format("%02d:%02d", minutes, seconds) + "."); } + private void runTraceTests() throws IOException + { + System.out.println("Beginning Trace no reduction tests..\n"); + + testInputFiles = TestUtils.getTestInputFiles(new File(TracesNoReductionTest.ROOT)); + resultFiles = TestUtils.getFiles(new File(TracesNoReductionTest.ROOT), RESULT_FILE_EXTENSION); + + runTests(testInputFiles, resultFiles, new TraceHandler(Release.VDM_10, Dialect.VDM_RT), false); + + System.out.println("\n********"); + System.out.println("Finished with Trace no reduction tests"); + System.out.println("********\n"); + } + private void runRtTests() throws IOException { System.out.println("Beginning RT tests..\n"); @@ -438,16 +455,18 @@ public void runTests(List testInputFiles, List resultFiles, for (int i = 0; i < testCount; i++) { File currentInputFile = testInputFiles.get(i); + testHandler.setCurrentInputFile(currentInputFile); GeneralUtils.deleteFolderContents(parent, FOLDER_NAMES_TO_AVOID); // Calculating the Java result: - File file = resultFiles.get(i); + File currentResultFile = resultFiles.get(i); - testHandler.writeGeneratedCode(parent, file); + testHandler.setCurrentResultFile(currentResultFile); + testHandler.writeGeneratedCode(parent, currentResultFile); boolean compileOk = JavaCommandLineCompiler.compile(parent, null); - System.out.println("Test:" + testNumber + " (" + (1 + i) + "). Name: " + file.getName() + System.out.println("Test:" + testNumber + " (" + (1 + i) + "). Name: " + currentResultFile.getName() + " " + (compileOk ? "Compile OK" : "ERROR")); if (!compileOk) @@ -460,11 +479,16 @@ public void runTests(List testInputFiles, List resultFiles, ExecutableTestHandler executableTestHandler = (ExecutableTestHandler) testHandler; // Calculating the VDM Result: - Object vdmResult; - + Object vdmResult = null; + try { vdmResult = executableTestHandler.interpretVdm(currentInputFile); + + if(vdmResult == null) + { + return; + } } catch (ContextException ce1) { @@ -475,31 +499,19 @@ public void runTests(List testInputFiles, List resultFiles, e1.printStackTrace(); return; } - - String javaResult = JavaExecution.run(parent, TestHandler.MAIN_CLASS); + + JavaExecutionResult javaResult = executableTestHandler.runJava(parent); - File dataFile = new File(CG_VALUE_BINARY_FILE); - FileInputStream fin = new FileInputStream(dataFile); - ObjectInputStream ois = new ObjectInputStream(fin); - - Object cgValue = null; - try - { - cgValue = (Object) ois.readObject(); - } catch (ClassNotFoundException e) + if(javaResult == null) { - e.printStackTrace(); return; - } finally - { - ois.close(); } - + boolean equal = false; if(vdmResult instanceof ContextException) { - String cgValueStr = cgValue.toString(); + String cgValueStr = javaResult.getExecutionResult().toString(); String vdmValueStr = ((ContextException) vdmResult).getMessage(); equal = vdmValueStr.contains(cgValueStr); @@ -508,7 +520,7 @@ public void runTests(List testInputFiles, List resultFiles, { // Comparison of VDM and Java results ComparisonCG comp = new ComparisonCG(currentInputFile); - equal = comp.compare(cgValue, (Value) vdmResult); + equal = comp.compare(javaResult.getExecutionResult(), (Value) vdmResult); } if (printInput) @@ -516,7 +528,7 @@ public void runTests(List testInputFiles, List resultFiles, String vdmInput = GeneralUtils.readFromFile(currentInputFile); System.out.println("VDM: " + vdmInput); - String generatedCode = GeneralUtils.readFromFile(file).replace('#', ' '); + String generatedCode = GeneralUtils.readFromFile(currentResultFile).replace('#', ' '); System.out.println("Java: " + generatedCode); } else { @@ -524,7 +536,7 @@ public void runTests(List testInputFiles, List resultFiles, } System.out.println("VDM ~> " + toShortString(vdmResult)); - System.out.print("Java ~> " + toShortString(javaResult)); + System.out.print("Java ~> " + toShortString(javaResult.getProcessOutput())); if (equal) { @@ -540,7 +552,7 @@ public void runTests(List testInputFiles, List resultFiles, private String toShortString(Object result) { - final int MAX = 200; + final int MAX = 1000; String str = result.toString(); if (str.length() > MAX) From 52e5b6303b157d88d1f03ff8f0d239bd4df99277 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sat, 24 Jan 2015 23:36:30 +0100 Subject: [PATCH 025/323] Added a trace test handler to the core/codegen test execution system --- core/codegen/pom.xml | 5 + .../codegen/tests/utils/TraceHandler.java | 168 ++++++++++++++++++ 2 files changed, 173 insertions(+) create mode 100644 core/codegen/src/test/java/org/overture/codegen/tests/utils/TraceHandler.java diff --git a/core/codegen/pom.xml b/core/codegen/pom.xml index f862ca9740..db5e3dd651 100644 --- a/core/codegen/pom.xml +++ b/core/codegen/pom.xml @@ -61,6 +61,11 @@ jalopy jalopy 1.5rc3 + + + org.overturetool.core.combinatorialtesting + ctruntime + ${project.version} diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/TraceHandler.java b/core/codegen/src/test/java/org/overture/codegen/tests/utils/TraceHandler.java new file mode 100644 index 0000000000..6f9f6d66ed --- /dev/null +++ b/core/codegen/src/test/java/org/overture/codegen/tests/utils/TraceHandler.java @@ -0,0 +1,168 @@ +package org.overture.codegen.tests.utils; + +import java.io.File; +import java.io.IOException; +import java.net.ServerSocket; +import java.util.LinkedList; +import java.util.List; + +import javax.xml.parsers.ParserConfigurationException; +import javax.xml.xpath.XPathExpressionException; + +import org.apache.commons.io.FileUtils; +import org.junit.Assert; +import org.overture.ast.lex.Dialect; +import org.overture.codegen.logging.Logger; +import org.overture.codegen.runtime.traces.TestAccumulator; +import org.overture.config.Release; +import org.overture.ct.ctruntime.TraceRunnerMain; +import org.overture.ct.ctruntime.utils.CtHelper; +import org.overture.ct.ctruntime.utils.Data; +import org.overture.ct.ctruntime.utils.TraceReductionInfo; +import org.overture.ct.ctruntime.utils.TraceResult; +import org.overture.ct.ctruntime.utils.TraceResultReader; +import org.overture.ct.ctruntime.utils.TraceTest; +import org.overture.interpreter.values.SeqValue; +import org.overture.interpreter.values.Value; +import org.xml.sax.SAXException; + +public class TraceHandler extends ExecutableSpecTestHandler +{ + // The socket is used to communicate with the trace interpreter + protected ServerSocket socket; + protected static final int SOCKET_TIMEOUT = 0; + protected static final int PORT = 8889; + + public TraceHandler(Release release, Dialect dialect) + { + super(release, dialect); + } + + public String getTraceName() + { + return "T1"; + } + + @Override + public String getVdmEntry() + { + return getTraceName(); + } + + @Override + public String getJavaEntry() + { + return "computeTests()"; + } + + public List getMainClassMethods() + { + String computeTestsMethod = + " public static TestAccumulator computeTests()\n" + + " {\n" + + " InMemoryTestAccumulator acc = new InMemoryTestAccumulator();\n" + + " Entry.Entry_T1_Run(acc);\n" + + " return acc;\n" + + " }\n"; + + List methods = new LinkedList(); + methods.add(computeTestsMethod); + + return methods; + } + + @Override + public Value interpretVdm(File intputFile) throws Exception + { + File vdmTraceResultFile = computeVdmTraceResult(currentInputFile); + + List testResult = new TraceResultReader().read(vdmTraceResultFile); + + if (testResult.size() != 1 || !testResult.get(0).traceName.equals(getTraceName())) + { + Logger.getLog().printErrorln("Expected a single trace named " + getTraceName() + "!. Got: " + + testResult); + return null; + } + + TraceResult t1 = testResult.get(0); + + StringBuilder sb = new StringBuilder(); + + for (TraceTest t : t1.tests) + { + sb.append(t.toString()).append('\n'); + } + + return new SeqValue(sb.toString()); + } + + @Override + public JavaExecutionResult runJava(File folder) + { + JavaExecutionResult javaResult = super.runJava(folder); + + TestAccumulator acc = (TestAccumulator) javaResult.getExecutionResult(); + + return new JavaExecutionResult(javaResult.getProcessOutput(), acc.toString()); + } + + public File computeVdmTraceResult(File specFile) throws IOException, + XPathExpressionException, SAXException, + ParserConfigurationException + { + // The client thread will close the socket + socket = new ServerSocket(PORT); + socket.setSoTimeout(SOCKET_TIMEOUT); + final Data data = new Data(); + + File traceFolder = new File("target" + File.separatorChar + "cgtest" + + File.separatorChar + "traceoutput"); + + traceFolder.mkdirs(); + + final File actualOutputFile = new File(traceFolder, "Entry-" + + getVdmEntry() + ".xml"); + + CtHelper testHelper = new CtHelper(); + Thread t = testHelper.consCtClientThread(socket, data); + t.setDaemon(false); + t.start(); + + File destFile = new File(traceFolder, specFile.getName() + ".vdmpp"); + FileUtils.copyFile(specFile, destFile); + + TraceRunnerMain.USE_SYSTEM_EXIT = false; + TraceReductionInfo info = new TraceReductionInfo(); + + String[] buildArgs = new String[] { + "-h", + "localhost", + "-p", + PORT + "", + "-k", + "whatever", + "-e", + "Entry", + "-vdmpp", + "-r", + "vdm10", + "-t", + getVdmEntry(), + "-tracefolder", + traceFolder.toURI().toASCIIString(), + destFile.toURI().toASCIIString(), + "-traceReduction", + "{" + info.getSubset() + "," + + info.getReductionType().toString() + "," + + info.getSeed() + "}" }; + + TraceRunnerMain.main(buildArgs); + + final String message = data.getMessage(); + + Assert.assertTrue("Test did not succeed", message.contains("status=\"completed\" progress=\"100\"")); + + return actualOutputFile; + } +} From bc461f27437830660ac4ff190ab3714b29f9ecfa Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sat, 24 Jan 2015 23:41:25 +0100 Subject: [PATCH 026/323] Added the notion of a void value to the codegen runtime --- .../java/org/overture/codegen/runtime/Utils.java | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/Utils.java b/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/Utils.java index 03db40030e..e119781f94 100644 --- a/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/Utils.java +++ b/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/Utils.java @@ -21,8 +21,16 @@ */ package org.overture.codegen.runtime; + public class Utils { + public static final Object VOID_VALUE = new Object(); + + public static boolean isVoidValue(Object value) + { + return value == VOID_VALUE; + } + public static int hashCode(Object... fields) { if(fields == null) @@ -89,6 +97,10 @@ public static String toString(Object obj) { return "nil"; } + else if(obj == VOID_VALUE) + { + return "()"; + } else if(obj instanceof Number) { Number n = (Number) obj; From c74d9b6f095d9150540c80a3dfa1868f872c6395 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sat, 24 Jan 2015 23:46:52 +0100 Subject: [PATCH 027/323] Added some unit tests to exercise Java code generation of traces The unit tests focus on exercising the different constructs of a trace that can be expanded. --- .../traces_no_reduction_specs/Alternative1 | 18 +++++++++++++ .../AlternativeConcurrent1 | 26 +++++++++++++++++++ .../AlternativeRepeat1 | 19 ++++++++++++++ .../traces_no_reduction_specs/Concurrent1 | 19 ++++++++++++++ .../traces_no_reduction_specs/Concurrent2 | 19 ++++++++++++++ .../ConcurrentAlternative1 | 26 +++++++++++++++++++ .../ConcurrentRepeat1 | 19 ++++++++++++++ .../traces_no_reduction_specs/LetBeSt1 | 16 ++++++++++++ .../traces_no_reduction_specs/LetDef1 | 16 ++++++++++++ .../traces_no_reduction_specs/Repeat1 | 13 ++++++++++ .../RepeatAlternative1 | 18 +++++++++++++ .../RepeatConcurrent1 | 17 ++++++++++++ .../SingleStatement1 | 14 ++++++++++ 13 files changed, 240 insertions(+) create mode 100644 core/codegen/src/test/resources/traces_no_reduction_specs/Alternative1 create mode 100644 core/codegen/src/test/resources/traces_no_reduction_specs/AlternativeConcurrent1 create mode 100644 core/codegen/src/test/resources/traces_no_reduction_specs/AlternativeRepeat1 create mode 100644 core/codegen/src/test/resources/traces_no_reduction_specs/Concurrent1 create mode 100644 core/codegen/src/test/resources/traces_no_reduction_specs/Concurrent2 create mode 100644 core/codegen/src/test/resources/traces_no_reduction_specs/ConcurrentAlternative1 create mode 100644 core/codegen/src/test/resources/traces_no_reduction_specs/ConcurrentRepeat1 create mode 100644 core/codegen/src/test/resources/traces_no_reduction_specs/LetBeSt1 create mode 100644 core/codegen/src/test/resources/traces_no_reduction_specs/LetDef1 create mode 100644 core/codegen/src/test/resources/traces_no_reduction_specs/Repeat1 create mode 100644 core/codegen/src/test/resources/traces_no_reduction_specs/RepeatAlternative1 create mode 100644 core/codegen/src/test/resources/traces_no_reduction_specs/RepeatConcurrent1 create mode 100644 core/codegen/src/test/resources/traces_no_reduction_specs/SingleStatement1 diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/Alternative1 b/core/codegen/src/test/resources/traces_no_reduction_specs/Alternative1 new file mode 100644 index 0000000000..70929656e3 --- /dev/null +++ b/core/codegen/src/test/resources/traces_no_reduction_specs/Alternative1 @@ -0,0 +1,18 @@ +class Entry + +operations + +op : () ==> nat +op () == return 32; + +functions + +f : () -> nat +f () == 23; + +traces + +T1: + op() | f() + +end Entry \ No newline at end of file diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/AlternativeConcurrent1 b/core/codegen/src/test/resources/traces_no_reduction_specs/AlternativeConcurrent1 new file mode 100644 index 0000000000..c9c92abe6c --- /dev/null +++ b/core/codegen/src/test/resources/traces_no_reduction_specs/AlternativeConcurrent1 @@ -0,0 +1,26 @@ +class Entry + +operations + +op1 : () ==> () +op1 () == skip; + +op2 : () ==> () +op2 () == skip; + + +functions + +fun1 : () -> nat +fun1 () == 1; + +fun2 : () -> nat +fun2 () == 1; + +traces + +T1: + +||(op1(), op2()) | ||(fun1(), fun2()) ; + +end Entry \ No newline at end of file diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/AlternativeRepeat1 b/core/codegen/src/test/resources/traces_no_reduction_specs/AlternativeRepeat1 new file mode 100644 index 0000000000..c22a0c8e20 --- /dev/null +++ b/core/codegen/src/test/resources/traces_no_reduction_specs/AlternativeRepeat1 @@ -0,0 +1,19 @@ +class Entry + +operations + +op : () ==> () +op () == skip; + +functions + +fun : () -> nat +fun () == 1; + +traces + +T1: + +( op(){1,2} | fun(){1,2} ); + +end Entry \ No newline at end of file diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/Concurrent1 b/core/codegen/src/test/resources/traces_no_reduction_specs/Concurrent1 new file mode 100644 index 0000000000..3a6d0f58de --- /dev/null +++ b/core/codegen/src/test/resources/traces_no_reduction_specs/Concurrent1 @@ -0,0 +1,19 @@ +class Entry + +operations + +op1 : () ==> () +op1 () == skip; + +op2 : () ==> () +op2 () == skip; + +op3 : () ==> () +op3 () == skip; + +traces + +T1: +|| (op1(), op2(), op3()); + +end Entry \ No newline at end of file diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/Concurrent2 b/core/codegen/src/test/resources/traces_no_reduction_specs/Concurrent2 new file mode 100644 index 0000000000..2f64be5409 --- /dev/null +++ b/core/codegen/src/test/resources/traces_no_reduction_specs/Concurrent2 @@ -0,0 +1,19 @@ +class Entry + +functions + +fun1 : nat -> nat +fun1 (a) == a; + +fun2 : nat -> nat +fun2 (b) == b; + +traces + +T1: + +let x in set {1,2,3} +in + || (fun1(x), fun2(x)); + +end Entry \ No newline at end of file diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/ConcurrentAlternative1 b/core/codegen/src/test/resources/traces_no_reduction_specs/ConcurrentAlternative1 new file mode 100644 index 0000000000..77f7ab8713 --- /dev/null +++ b/core/codegen/src/test/resources/traces_no_reduction_specs/ConcurrentAlternative1 @@ -0,0 +1,26 @@ +class Entry + +operations + +op1 : () ==> () +op1 () == skip; + +op2 : () ==> () +op2 () == skip; + +functions + +fun1 : () -> nat +fun1 () == 1; + +fun2 : () -> nat +fun2 () == 2; + + +traces + +T1: + +||( (op1() | op2()) , (fun1() | fun2()) ); + +end Entry \ No newline at end of file diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/ConcurrentRepeat1 b/core/codegen/src/test/resources/traces_no_reduction_specs/ConcurrentRepeat1 new file mode 100644 index 0000000000..5c10387bc5 --- /dev/null +++ b/core/codegen/src/test/resources/traces_no_reduction_specs/ConcurrentRepeat1 @@ -0,0 +1,19 @@ +class Entry + +operations + +op : () ==> () +op () == skip; + +functions + +fun : () -> nat +fun () == 1; + +traces + +T1: + +||( op(){1,2} , fun(){1,2} ); + +end Entry \ No newline at end of file diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/LetBeSt1 b/core/codegen/src/test/resources/traces_no_reduction_specs/LetBeSt1 new file mode 100644 index 0000000000..df20728ded --- /dev/null +++ b/core/codegen/src/test/resources/traces_no_reduction_specs/LetBeSt1 @@ -0,0 +1,16 @@ +class Entry + +functions + +fun : nat -> nat +fun (a) == a; + +traces + +T1: + +let a in set {1,2,3} be st a > 1 +in + fun(a); + +end Entry \ No newline at end of file diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/LetDef1 b/core/codegen/src/test/resources/traces_no_reduction_specs/LetDef1 new file mode 100644 index 0000000000..bbabd96dfd --- /dev/null +++ b/core/codegen/src/test/resources/traces_no_reduction_specs/LetDef1 @@ -0,0 +1,16 @@ +class Entry + +functions + +fun : nat -> nat +fun (a) == a; + +traces + +T1: + +let a in set {1,2,3} +in + fun(a); + +end Entry \ No newline at end of file diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/Repeat1 b/core/codegen/src/test/resources/traces_no_reduction_specs/Repeat1 new file mode 100644 index 0000000000..77b30efacf --- /dev/null +++ b/core/codegen/src/test/resources/traces_no_reduction_specs/Repeat1 @@ -0,0 +1,13 @@ +class Entry + +operations + +op : () ==> () +op () == skip; + +traces + +T1: +(op() ){1,50}; + +end Entry \ No newline at end of file diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/RepeatAlternative1 b/core/codegen/src/test/resources/traces_no_reduction_specs/RepeatAlternative1 new file mode 100644 index 0000000000..9bdc679f80 --- /dev/null +++ b/core/codegen/src/test/resources/traces_no_reduction_specs/RepeatAlternative1 @@ -0,0 +1,18 @@ +class Entry + +operations + +op : () ==> nat +op () == return 32; + +functions + +f : () -> nat +f () == 23; + +traces + +T1: +(op() | f()){1,3}; + +end Entry \ No newline at end of file diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/RepeatConcurrent1 b/core/codegen/src/test/resources/traces_no_reduction_specs/RepeatConcurrent1 new file mode 100644 index 0000000000..2f753ed2f1 --- /dev/null +++ b/core/codegen/src/test/resources/traces_no_reduction_specs/RepeatConcurrent1 @@ -0,0 +1,17 @@ +class Entry + +operations + +op1 : () ==> () +op1 () == skip; + +op2 : () ==> () +op2 () == skip; + +traces + +T1: + +(|| (op1(), op2())){1,2}; + +end Entry \ No newline at end of file diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/SingleStatement1 b/core/codegen/src/test/resources/traces_no_reduction_specs/SingleStatement1 new file mode 100644 index 0000000000..97252039ac --- /dev/null +++ b/core/codegen/src/test/resources/traces_no_reduction_specs/SingleStatement1 @@ -0,0 +1,14 @@ +class Entry + +operations + +op : () ==> () +op () == skip; + +traces + +T1: + +op(); + +end Entry \ No newline at end of file From 72d2a83e756dc8d4efbe26c00747357ce1423901 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sat, 24 Jan 2015 23:52:53 +0100 Subject: [PATCH 028/323] Generated result files for the unit tests used to exercise Java code generation of traces --- .../Alternative1.result | 61 ++++++++++ .../AlternativeConcurrent1.result | 103 +++++++++++++++++ .../AlternativeRepeat1.result | 68 +++++++++++ .../Concurrent1.result | 82 +++++++++++++ .../Concurrent2.result | 67 +++++++++++ .../ConcurrentAlternative1.result | 109 ++++++++++++++++++ .../ConcurrentRepeat1.result | 65 +++++++++++ .../traces_no_reduction_specs/LetBeSt1.result | 52 +++++++++ .../traces_no_reduction_specs/LetDef1.result | 47 ++++++++ .../traces_no_reduction_specs/Repeat1.result | 46 ++++++++ .../RepeatAlternative1.result | 66 +++++++++++ .../RepeatConcurrent1.result | 68 +++++++++++ .../SingleStatement1.result | 41 +++++++ 13 files changed, 875 insertions(+) create mode 100644 core/codegen/src/test/resources/traces_no_reduction_specs/Alternative1.result create mode 100644 core/codegen/src/test/resources/traces_no_reduction_specs/AlternativeConcurrent1.result create mode 100644 core/codegen/src/test/resources/traces_no_reduction_specs/AlternativeRepeat1.result create mode 100644 core/codegen/src/test/resources/traces_no_reduction_specs/Concurrent1.result create mode 100644 core/codegen/src/test/resources/traces_no_reduction_specs/Concurrent2.result create mode 100644 core/codegen/src/test/resources/traces_no_reduction_specs/ConcurrentAlternative1.result create mode 100644 core/codegen/src/test/resources/traces_no_reduction_specs/ConcurrentRepeat1.result create mode 100644 core/codegen/src/test/resources/traces_no_reduction_specs/LetBeSt1.result create mode 100644 core/codegen/src/test/resources/traces_no_reduction_specs/LetDef1.result create mode 100644 core/codegen/src/test/resources/traces_no_reduction_specs/Repeat1.result create mode 100644 core/codegen/src/test/resources/traces_no_reduction_specs/RepeatAlternative1.result create mode 100644 core/codegen/src/test/resources/traces_no_reduction_specs/RepeatConcurrent1.result create mode 100644 core/codegen/src/test/resources/traces_no_reduction_specs/SingleStatement1.result diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/Alternative1.result b/core/codegen/src/test/resources/traces_no_reduction_specs/Alternative1.result new file mode 100644 index 0000000000..6a0e914d88 --- /dev/null +++ b/core/codegen/src/test/resources/traces_no_reduction_specs/Alternative1.result @@ -0,0 +1,61 @@ +import org.overture.codegen.runtime.*; +import org.overture.codegen.runtime.traces.*; + +import java.util.*; + + +public class Entry { + public Entry() { + } + + private Number op() { + return 32L; + } + + private static Number f() { + return 23L; + } + + public String toString() { + return "Entry{}"; + } + + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + SequenceTraceNode sequence_1 = new SequenceTraceNode(); + AlternativeTraceNode alternatives_1 = new AlternativeTraceNode(); + CallStatement callStm_1 = new CallStatement() { + public Object execute(final Object instance) { + Number result_1 = ((Entry) instance).op(); + + return result_1; + } + + public String toString() { + return "op()"; + } + }; + + StatementTraceNode apply_1 = new StatementTraceNode(callStm_1); + + CallStatement callStm_2 = new CallStatement() { + public Object execute(final Object instance) { + return f(); + } + + public String toString() { + return "f()"; + } + }; + + StatementTraceNode apply_2 = new StatementTraceNode(callStm_2); + + alternatives_1.add(apply_1); + alternatives_1.add(apply_2); + + sequence_1.add(alternatives_1); + + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator); + } +} + +########## diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/AlternativeConcurrent1.result b/core/codegen/src/test/resources/traces_no_reduction_specs/AlternativeConcurrent1.result new file mode 100644 index 0000000000..94a7435f9b --- /dev/null +++ b/core/codegen/src/test/resources/traces_no_reduction_specs/AlternativeConcurrent1.result @@ -0,0 +1,103 @@ +import org.overture.codegen.runtime.*; +import org.overture.codegen.runtime.traces.*; + +import java.util.*; + + +public class Entry { + public Entry() { + } + + private void op1() { + //Skip; + } + + private void op2() { + //Skip; + } + + private static Number fun1() { + return 1L; + } + + private static Number fun2() { + return 1L; + } + + public String toString() { + return "Entry{}"; + } + + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + SequenceTraceNode sequence_1 = new SequenceTraceNode(); + AlternativeTraceNode alternatives_1 = new AlternativeTraceNode(); + ConcurrentTraceNode concurrent_1 = new ConcurrentTraceNode(); + CallStatement callStm_1 = new CallStatement() { + public Object execute(final Object instance) { + ((Entry) instance).op1(); + + return Utils.VOID_VALUE; + } + + public String toString() { + return "op1()"; + } + }; + + StatementTraceNode apply_1 = new StatementTraceNode(callStm_1); + + CallStatement callStm_2 = new CallStatement() { + public Object execute(final Object instance) { + ((Entry) instance).op2(); + + return Utils.VOID_VALUE; + } + + public String toString() { + return "op2()"; + } + }; + + StatementTraceNode apply_2 = new StatementTraceNode(callStm_2); + + concurrent_1.add(apply_1); + concurrent_1.add(apply_2); + + ConcurrentTraceNode concurrent_2 = new ConcurrentTraceNode(); + CallStatement callStm_3 = new CallStatement() { + public Object execute(final Object instance) { + return fun1(); + } + + public String toString() { + return "fun1()"; + } + }; + + StatementTraceNode apply_3 = new StatementTraceNode(callStm_3); + + CallStatement callStm_4 = new CallStatement() { + public Object execute(final Object instance) { + return fun2(); + } + + public String toString() { + return "fun2()"; + } + }; + + StatementTraceNode apply_4 = new StatementTraceNode(callStm_4); + + concurrent_2.add(apply_3); + concurrent_2.add(apply_4); + + alternatives_1.add(concurrent_1); + alternatives_1.add(concurrent_2); + + sequence_1.add(alternatives_1); + + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator); + } +} + +########## diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/AlternativeRepeat1.result b/core/codegen/src/test/resources/traces_no_reduction_specs/AlternativeRepeat1.result new file mode 100644 index 0000000000..b956afc23e --- /dev/null +++ b/core/codegen/src/test/resources/traces_no_reduction_specs/AlternativeRepeat1.result @@ -0,0 +1,68 @@ +import org.overture.codegen.runtime.*; +import org.overture.codegen.runtime.traces.*; + +import java.util.*; + + +public class Entry { + public Entry() { + } + + private void op() { + //Skip; + } + + private static Number fun() { + return 1L; + } + + public String toString() { + return "Entry{}"; + } + + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + SequenceTraceNode sequence_1 = new SequenceTraceNode(); + SequenceTraceNode sequence_2 = new SequenceTraceNode(); + AlternativeTraceNode alternatives_2 = new AlternativeTraceNode(); + CallStatement callStm_1 = new CallStatement() { + public Object execute(final Object instance) { + ((Entry) instance).op(); + + return Utils.VOID_VALUE; + } + + public String toString() { + return "op()"; + } + }; + + StatementTraceNode apply_1 = new StatementTraceNode(callStm_1); + + RepeatTraceNode repeat_1 = new RepeatTraceNode(apply_1, 1L, 2L); + + CallStatement callStm_2 = new CallStatement() { + public Object execute(final Object instance) { + return fun(); + } + + public String toString() { + return "fun()"; + } + }; + + StatementTraceNode apply_2 = new StatementTraceNode(callStm_2); + + RepeatTraceNode repeat_2 = new RepeatTraceNode(apply_2, 1L, 2L); + + alternatives_2.add(repeat_1); + alternatives_2.add(repeat_2); + + sequence_2.add(alternatives_2); + + sequence_1.add(sequence_2); + + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator); + } +} + +########## diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/Concurrent1.result b/core/codegen/src/test/resources/traces_no_reduction_specs/Concurrent1.result new file mode 100644 index 0000000000..2cf505ef3a --- /dev/null +++ b/core/codegen/src/test/resources/traces_no_reduction_specs/Concurrent1.result @@ -0,0 +1,82 @@ +import org.overture.codegen.runtime.*; +import org.overture.codegen.runtime.traces.*; + +import java.util.*; + + +public class Entry { + public Entry() { + } + + private void op1() { + //Skip; + } + + private void op2() { + //Skip; + } + + private void op3() { + //Skip; + } + + public String toString() { + return "Entry{}"; + } + + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + SequenceTraceNode sequence_1 = new SequenceTraceNode(); + ConcurrentTraceNode concurrent_1 = new ConcurrentTraceNode(); + CallStatement callStm_1 = new CallStatement() { + public Object execute(final Object instance) { + ((Entry) instance).op1(); + + return Utils.VOID_VALUE; + } + + public String toString() { + return "op1()"; + } + }; + + StatementTraceNode apply_1 = new StatementTraceNode(callStm_1); + + CallStatement callStm_2 = new CallStatement() { + public Object execute(final Object instance) { + ((Entry) instance).op2(); + + return Utils.VOID_VALUE; + } + + public String toString() { + return "op2()"; + } + }; + + StatementTraceNode apply_2 = new StatementTraceNode(callStm_2); + + CallStatement callStm_3 = new CallStatement() { + public Object execute(final Object instance) { + ((Entry) instance).op3(); + + return Utils.VOID_VALUE; + } + + public String toString() { + return "op3()"; + } + }; + + StatementTraceNode apply_3 = new StatementTraceNode(callStm_3); + + concurrent_1.add(apply_1); + concurrent_1.add(apply_2); + concurrent_1.add(apply_3); + + sequence_1.add(concurrent_1); + + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator); + } +} + +########## diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/Concurrent2.result b/core/codegen/src/test/resources/traces_no_reduction_specs/Concurrent2.result new file mode 100644 index 0000000000..d9a434fd64 --- /dev/null +++ b/core/codegen/src/test/resources/traces_no_reduction_specs/Concurrent2.result @@ -0,0 +1,67 @@ +import org.overture.codegen.runtime.*; +import org.overture.codegen.runtime.traces.*; + +import java.util.*; + + +public class Entry { + public Entry() { + } + + private static Number fun1(final Number a) { + return a; + } + + private static Number fun2(final Number b) { + return b; + } + + public String toString() { + return "Entry{}"; + } + + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + SequenceTraceNode sequence_1 = new SequenceTraceNode(); + AlternativeTraceNode alternatives_2 = new AlternativeTraceNode(); + VDMSet set_1 = SetUtil.set(1L, 2L, 3L); + + for (Iterator iterator_1 = set_1.iterator(); iterator_1.hasNext();) { + final Number x = ((Number) iterator_1.next()); + ConcurrentTraceNode concurrent_1 = new ConcurrentTraceNode(); + CallStatement callStm_1 = new CallStatement() { + public Object execute(final Object instance) { + return fun1(x); + } + + public String toString() { + return "fun1(" + Utils.toString(x) + ")"; + } + }; + + StatementTraceNode apply_1 = new StatementTraceNode(callStm_1); + + CallStatement callStm_2 = new CallStatement() { + public Object execute(final Object instance) { + return fun2(x); + } + + public String toString() { + return "fun2(" + Utils.toString(x) + ")"; + } + }; + + StatementTraceNode apply_2 = new StatementTraceNode(callStm_2); + + concurrent_1.add(apply_1); + concurrent_1.add(apply_2); + + alternatives_2.add(concurrent_1); + } + + sequence_1.add(alternatives_2); + + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator); + } +} + +########## diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/ConcurrentAlternative1.result b/core/codegen/src/test/resources/traces_no_reduction_specs/ConcurrentAlternative1.result new file mode 100644 index 0000000000..6db75b980e --- /dev/null +++ b/core/codegen/src/test/resources/traces_no_reduction_specs/ConcurrentAlternative1.result @@ -0,0 +1,109 @@ +import org.overture.codegen.runtime.*; +import org.overture.codegen.runtime.traces.*; + +import java.util.*; + + +public class Entry { + public Entry() { + } + + private void op1() { + //Skip; + } + + private void op2() { + //Skip; + } + + private static Number fun1() { + return 1L; + } + + private static Number fun2() { + return 2L; + } + + public String toString() { + return "Entry{}"; + } + + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + SequenceTraceNode sequence_1 = new SequenceTraceNode(); + ConcurrentTraceNode concurrent_1 = new ConcurrentTraceNode(); + SequenceTraceNode sequence_2 = new SequenceTraceNode(); + AlternativeTraceNode alternatives_2 = new AlternativeTraceNode(); + CallStatement callStm_1 = new CallStatement() { + public Object execute(final Object instance) { + ((Entry) instance).op1(); + + return Utils.VOID_VALUE; + } + + public String toString() { + return "op1()"; + } + }; + + StatementTraceNode apply_1 = new StatementTraceNode(callStm_1); + + CallStatement callStm_2 = new CallStatement() { + public Object execute(final Object instance) { + ((Entry) instance).op2(); + + return Utils.VOID_VALUE; + } + + public String toString() { + return "op2()"; + } + }; + + StatementTraceNode apply_2 = new StatementTraceNode(callStm_2); + + alternatives_2.add(apply_1); + alternatives_2.add(apply_2); + + sequence_2.add(alternatives_2); + + SequenceTraceNode sequence_3 = new SequenceTraceNode(); + AlternativeTraceNode alternatives_3 = new AlternativeTraceNode(); + CallStatement callStm_3 = new CallStatement() { + public Object execute(final Object instance) { + return fun1(); + } + + public String toString() { + return "fun1()"; + } + }; + + StatementTraceNode apply_3 = new StatementTraceNode(callStm_3); + + CallStatement callStm_4 = new CallStatement() { + public Object execute(final Object instance) { + return fun2(); + } + + public String toString() { + return "fun2()"; + } + }; + + StatementTraceNode apply_4 = new StatementTraceNode(callStm_4); + + alternatives_3.add(apply_3); + alternatives_3.add(apply_4); + + sequence_3.add(alternatives_3); + + concurrent_1.add(sequence_2); + concurrent_1.add(sequence_3); + + sequence_1.add(concurrent_1); + + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator); + } +} + +########## diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/ConcurrentRepeat1.result b/core/codegen/src/test/resources/traces_no_reduction_specs/ConcurrentRepeat1.result new file mode 100644 index 0000000000..943760c66e --- /dev/null +++ b/core/codegen/src/test/resources/traces_no_reduction_specs/ConcurrentRepeat1.result @@ -0,0 +1,65 @@ +import org.overture.codegen.runtime.*; +import org.overture.codegen.runtime.traces.*; + +import java.util.*; + + +public class Entry { + public Entry() { + } + + private void op() { + //Skip; + } + + private static Number fun() { + return 1L; + } + + public String toString() { + return "Entry{}"; + } + + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + SequenceTraceNode sequence_1 = new SequenceTraceNode(); + ConcurrentTraceNode concurrent_1 = new ConcurrentTraceNode(); + CallStatement callStm_1 = new CallStatement() { + public Object execute(final Object instance) { + ((Entry) instance).op(); + + return Utils.VOID_VALUE; + } + + public String toString() { + return "op()"; + } + }; + + StatementTraceNode apply_1 = new StatementTraceNode(callStm_1); + + RepeatTraceNode repeat_1 = new RepeatTraceNode(apply_1, 1L, 2L); + + CallStatement callStm_2 = new CallStatement() { + public Object execute(final Object instance) { + return fun(); + } + + public String toString() { + return "fun()"; + } + }; + + StatementTraceNode apply_2 = new StatementTraceNode(callStm_2); + + RepeatTraceNode repeat_2 = new RepeatTraceNode(apply_2, 1L, 2L); + + concurrent_1.add(repeat_1); + concurrent_1.add(repeat_2); + + sequence_1.add(concurrent_1); + + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator); + } +} + +########## diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/LetBeSt1.result b/core/codegen/src/test/resources/traces_no_reduction_specs/LetBeSt1.result new file mode 100644 index 0000000000..273d518ea2 --- /dev/null +++ b/core/codegen/src/test/resources/traces_no_reduction_specs/LetBeSt1.result @@ -0,0 +1,52 @@ +import org.overture.codegen.runtime.*; +import org.overture.codegen.runtime.traces.*; + +import java.util.*; + + +public class Entry { + public Entry() { + } + + private static Number fun(final Number a) { + return a; + } + + public String toString() { + return "Entry{}"; + } + + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + SequenceTraceNode sequence_1 = new SequenceTraceNode(); + AlternativeTraceNode alternatives_2 = new AlternativeTraceNode(); + VDMSet set_1 = SetUtil.set(1L, 2L, 3L); + + for (Iterator iterator_1 = set_1.iterator(); iterator_1.hasNext();) { + final Number a = ((Number) iterator_1.next()); + + if (!(a.longValue() > 1L)) { + continue; + } + + CallStatement callStm_1 = new CallStatement() { + public Object execute(final Object instance) { + return fun(a); + } + + public String toString() { + return "fun(" + Utils.toString(a) + ")"; + } + }; + + StatementTraceNode apply_1 = new StatementTraceNode(callStm_1); + + alternatives_2.add(apply_1); + } + + sequence_1.add(alternatives_2); + + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator); + } +} + +########## diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/LetDef1.result b/core/codegen/src/test/resources/traces_no_reduction_specs/LetDef1.result new file mode 100644 index 0000000000..a11fc21204 --- /dev/null +++ b/core/codegen/src/test/resources/traces_no_reduction_specs/LetDef1.result @@ -0,0 +1,47 @@ +import org.overture.codegen.runtime.*; +import org.overture.codegen.runtime.traces.*; + +import java.util.*; + + +public class Entry { + public Entry() { + } + + private static Number fun(final Number a) { + return a; + } + + public String toString() { + return "Entry{}"; + } + + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + SequenceTraceNode sequence_1 = new SequenceTraceNode(); + AlternativeTraceNode alternatives_2 = new AlternativeTraceNode(); + VDMSet set_1 = SetUtil.set(1L, 2L, 3L); + + for (Iterator iterator_1 = set_1.iterator(); iterator_1.hasNext();) { + final Number a = ((Number) iterator_1.next()); + CallStatement callStm_1 = new CallStatement() { + public Object execute(final Object instance) { + return fun(a); + } + + public String toString() { + return "fun(" + Utils.toString(a) + ")"; + } + }; + + StatementTraceNode apply_1 = new StatementTraceNode(callStm_1); + + alternatives_2.add(apply_1); + } + + sequence_1.add(alternatives_2); + + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator); + } +} + +########## diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/Repeat1.result b/core/codegen/src/test/resources/traces_no_reduction_specs/Repeat1.result new file mode 100644 index 0000000000..cdd1db137c --- /dev/null +++ b/core/codegen/src/test/resources/traces_no_reduction_specs/Repeat1.result @@ -0,0 +1,46 @@ +import org.overture.codegen.runtime.*; +import org.overture.codegen.runtime.traces.*; + +import java.util.*; + + +public class Entry { + public Entry() { + } + + private void op() { + //Skip; + } + + public String toString() { + return "Entry{}"; + } + + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + SequenceTraceNode sequence_1 = new SequenceTraceNode(); + SequenceTraceNode sequence_2 = new SequenceTraceNode(); + CallStatement callStm_1 = new CallStatement() { + public Object execute(final Object instance) { + ((Entry) instance).op(); + + return Utils.VOID_VALUE; + } + + public String toString() { + return "op()"; + } + }; + + StatementTraceNode apply_1 = new StatementTraceNode(callStm_1); + + sequence_2.add(apply_1); + + RepeatTraceNode repeat_1 = new RepeatTraceNode(sequence_2, 1L, 50L); + + sequence_1.add(repeat_1); + + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator); + } +} + +########## diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/RepeatAlternative1.result b/core/codegen/src/test/resources/traces_no_reduction_specs/RepeatAlternative1.result new file mode 100644 index 0000000000..6104c76f87 --- /dev/null +++ b/core/codegen/src/test/resources/traces_no_reduction_specs/RepeatAlternative1.result @@ -0,0 +1,66 @@ +import org.overture.codegen.runtime.*; +import org.overture.codegen.runtime.traces.*; + +import java.util.*; + + +public class Entry { + public Entry() { + } + + private Number op() { + return 32L; + } + + private static Number f() { + return 23L; + } + + public String toString() { + return "Entry{}"; + } + + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + SequenceTraceNode sequence_1 = new SequenceTraceNode(); + SequenceTraceNode sequence_2 = new SequenceTraceNode(); + AlternativeTraceNode alternatives_2 = new AlternativeTraceNode(); + CallStatement callStm_1 = new CallStatement() { + public Object execute(final Object instance) { + Number result_1 = ((Entry) instance).op(); + + return result_1; + } + + public String toString() { + return "op()"; + } + }; + + StatementTraceNode apply_1 = new StatementTraceNode(callStm_1); + + CallStatement callStm_2 = new CallStatement() { + public Object execute(final Object instance) { + return f(); + } + + public String toString() { + return "f()"; + } + }; + + StatementTraceNode apply_2 = new StatementTraceNode(callStm_2); + + alternatives_2.add(apply_1); + alternatives_2.add(apply_2); + + sequence_2.add(alternatives_2); + + RepeatTraceNode repeat_1 = new RepeatTraceNode(sequence_2, 1L, 3L); + + sequence_1.add(repeat_1); + + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator); + } +} + +########## diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/RepeatConcurrent1.result b/core/codegen/src/test/resources/traces_no_reduction_specs/RepeatConcurrent1.result new file mode 100644 index 0000000000..fa64cd4fbd --- /dev/null +++ b/core/codegen/src/test/resources/traces_no_reduction_specs/RepeatConcurrent1.result @@ -0,0 +1,68 @@ +import org.overture.codegen.runtime.*; +import org.overture.codegen.runtime.traces.*; + +import java.util.*; + + +public class Entry { + public Entry() { + } + + private void op1() { + //Skip; + } + + private void op2() { + //Skip; + } + + public String toString() { + return "Entry{}"; + } + + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + SequenceTraceNode sequence_1 = new SequenceTraceNode(); + SequenceTraceNode sequence_2 = new SequenceTraceNode(); + ConcurrentTraceNode concurrent_1 = new ConcurrentTraceNode(); + CallStatement callStm_1 = new CallStatement() { + public Object execute(final Object instance) { + ((Entry) instance).op1(); + + return Utils.VOID_VALUE; + } + + public String toString() { + return "op1()"; + } + }; + + StatementTraceNode apply_1 = new StatementTraceNode(callStm_1); + + CallStatement callStm_2 = new CallStatement() { + public Object execute(final Object instance) { + ((Entry) instance).op2(); + + return Utils.VOID_VALUE; + } + + public String toString() { + return "op2()"; + } + }; + + StatementTraceNode apply_2 = new StatementTraceNode(callStm_2); + + concurrent_1.add(apply_1); + concurrent_1.add(apply_2); + + sequence_2.add(concurrent_1); + + RepeatTraceNode repeat_1 = new RepeatTraceNode(sequence_2, 1L, 2L); + + sequence_1.add(repeat_1); + + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator); + } +} + +########## diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/SingleStatement1.result b/core/codegen/src/test/resources/traces_no_reduction_specs/SingleStatement1.result new file mode 100644 index 0000000000..7f1ea1440e --- /dev/null +++ b/core/codegen/src/test/resources/traces_no_reduction_specs/SingleStatement1.result @@ -0,0 +1,41 @@ +import org.overture.codegen.runtime.*; +import org.overture.codegen.runtime.traces.*; + +import java.util.*; + + +public class Entry { + public Entry() { + } + + private void op() { + //Skip; + } + + public String toString() { + return "Entry{}"; + } + + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + SequenceTraceNode sequence_1 = new SequenceTraceNode(); + CallStatement callStm_1 = new CallStatement() { + public Object execute(final Object instance) { + ((Entry) instance).op(); + + return Utils.VOID_VALUE; + } + + public String toString() { + return "op()"; + } + }; + + StatementTraceNode apply_1 = new StatementTraceNode(callStm_1); + + sequence_1.add(apply_1); + + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator); + } +} + +########## From 32dff4d078c909d3cd79232e559ccf7bf3cfea5f Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Tue, 27 Jan 2015 14:26:42 +0100 Subject: [PATCH 029/323] Renaming testing related artefacts --- ...ReductionTest.java => TracesExpansionTest.java} | 10 +++++----- ...nTestCase.java => TracesExpansionTestCase.java} | 6 +++--- .../overture/codegen/tests/utils/CompileTests.java | 14 +++++++------- .../Alternative1 | 0 .../Alternative1.result | 0 .../AlternativeConcurrent1 | 0 .../AlternativeConcurrent1.result | 0 .../AlternativeRepeat1 | 0 .../AlternativeRepeat1.result | 0 .../Concurrent1 | 0 .../Concurrent1.result | 0 .../Concurrent2 | 0 .../Concurrent2.result | 0 .../ConcurrentAlternative1 | 0 .../ConcurrentAlternative1.result | 0 .../ConcurrentRepeat1 | 0 .../ConcurrentRepeat1.result | 0 .../LetBeSt1 | 0 .../LetBeSt1.result | 0 .../LetDef1 | 0 .../LetDef1.result | 0 .../Repeat1 | 0 .../Repeat1.result | 0 .../RepeatAlternative1 | 0 .../RepeatAlternative1.result | 0 .../RepeatConcurrent1 | 0 .../RepeatConcurrent1.result | 0 .../SingleStatement1 | 0 .../SingleStatement1.result | 0 29 files changed, 15 insertions(+), 15 deletions(-) rename core/codegen/src/test/java/org/overture/codegen/tests/{TracesNoReductionTest.java => TracesExpansionTest.java} (70%) rename core/codegen/src/test/java/org/overture/codegen/tests/{TracesNoReductionTestCase.java => TracesExpansionTestCase.java} (67%) rename core/codegen/src/test/resources/{traces_no_reduction_specs => traces_expansion}/Alternative1 (100%) rename core/codegen/src/test/resources/{traces_no_reduction_specs => traces_expansion}/Alternative1.result (100%) rename core/codegen/src/test/resources/{traces_no_reduction_specs => traces_expansion}/AlternativeConcurrent1 (100%) rename core/codegen/src/test/resources/{traces_no_reduction_specs => traces_expansion}/AlternativeConcurrent1.result (100%) rename core/codegen/src/test/resources/{traces_no_reduction_specs => traces_expansion}/AlternativeRepeat1 (100%) rename core/codegen/src/test/resources/{traces_no_reduction_specs => traces_expansion}/AlternativeRepeat1.result (100%) rename core/codegen/src/test/resources/{traces_no_reduction_specs => traces_expansion}/Concurrent1 (100%) rename core/codegen/src/test/resources/{traces_no_reduction_specs => traces_expansion}/Concurrent1.result (100%) rename core/codegen/src/test/resources/{traces_no_reduction_specs => traces_expansion}/Concurrent2 (100%) rename core/codegen/src/test/resources/{traces_no_reduction_specs => traces_expansion}/Concurrent2.result (100%) rename core/codegen/src/test/resources/{traces_no_reduction_specs => traces_expansion}/ConcurrentAlternative1 (100%) rename core/codegen/src/test/resources/{traces_no_reduction_specs => traces_expansion}/ConcurrentAlternative1.result (100%) rename core/codegen/src/test/resources/{traces_no_reduction_specs => traces_expansion}/ConcurrentRepeat1 (100%) rename core/codegen/src/test/resources/{traces_no_reduction_specs => traces_expansion}/ConcurrentRepeat1.result (100%) rename core/codegen/src/test/resources/{traces_no_reduction_specs => traces_expansion}/LetBeSt1 (100%) rename core/codegen/src/test/resources/{traces_no_reduction_specs => traces_expansion}/LetBeSt1.result (100%) rename core/codegen/src/test/resources/{traces_no_reduction_specs => traces_expansion}/LetDef1 (100%) rename core/codegen/src/test/resources/{traces_no_reduction_specs => traces_expansion}/LetDef1.result (100%) rename core/codegen/src/test/resources/{traces_no_reduction_specs => traces_expansion}/Repeat1 (100%) rename core/codegen/src/test/resources/{traces_no_reduction_specs => traces_expansion}/Repeat1.result (100%) rename core/codegen/src/test/resources/{traces_no_reduction_specs => traces_expansion}/RepeatAlternative1 (100%) rename core/codegen/src/test/resources/{traces_no_reduction_specs => traces_expansion}/RepeatAlternative1.result (100%) rename core/codegen/src/test/resources/{traces_no_reduction_specs => traces_expansion}/RepeatConcurrent1 (100%) rename core/codegen/src/test/resources/{traces_no_reduction_specs => traces_expansion}/RepeatConcurrent1.result (100%) rename core/codegen/src/test/resources/{traces_no_reduction_specs => traces_expansion}/SingleStatement1 (100%) rename core/codegen/src/test/resources/{traces_no_reduction_specs => traces_expansion}/SingleStatement1.result (100%) diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/TracesNoReductionTest.java b/core/codegen/src/test/java/org/overture/codegen/tests/TracesExpansionTest.java similarity index 70% rename from core/codegen/src/test/java/org/overture/codegen/tests/TracesNoReductionTest.java rename to core/codegen/src/test/java/org/overture/codegen/tests/TracesExpansionTest.java index 63834fe699..22412b9219 100644 --- a/core/codegen/src/test/java/org/overture/codegen/tests/TracesNoReductionTest.java +++ b/core/codegen/src/test/java/org/overture/codegen/tests/TracesExpansionTest.java @@ -11,21 +11,21 @@ import org.overture.test.framework.BaseTestSuite; import org.overture.test.framework.Properties; -public class TracesNoReductionTest extends BaseTestSuite +public class TracesExpansionTest extends BaseTestSuite { public static final String ROOT = "src" + File.separatorChar + "test" + File.separatorChar + "resources" + File.separatorChar - + "traces_no_reduction_specs"; + + "traces_expansion_specs"; public static Test suite() throws IllegalArgumentException, SecurityException, InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchMethodException, IOException { LexLocation.absoluteToStringLocation = false; - Properties.recordTestResults = TestFlags.TRACES_NO_REDUCTION_TESTS_ON; + Properties.recordTestResults = TestFlags.TRACES_EXPANSION_TESTS_ON; - String name = "Traces no reduction test case"; - TestSuite test = createTestCompleteFile(name, ROOT, TracesNoReductionTestCase.class, ""); + String name = "Traces expansion test case"; + TestSuite test = createTestCompleteFile(name, ROOT, TracesExpansionTestCase.class, ""); return test; } } diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/TracesNoReductionTestCase.java b/core/codegen/src/test/java/org/overture/codegen/tests/TracesExpansionTestCase.java similarity index 67% rename from core/codegen/src/test/java/org/overture/codegen/tests/TracesNoReductionTestCase.java rename to core/codegen/src/test/java/org/overture/codegen/tests/TracesExpansionTestCase.java index dd5fa59999..f80ef3f8fe 100644 --- a/core/codegen/src/test/java/org/overture/codegen/tests/TracesNoReductionTestCase.java +++ b/core/codegen/src/test/java/org/overture/codegen/tests/TracesExpansionTestCase.java @@ -4,14 +4,14 @@ import org.overture.codegen.ir.IRSettings; -public class TracesNoReductionTestCase extends SpecificationTestCase +public class TracesExpansionTestCase extends SpecificationTestCase { - public TracesNoReductionTestCase() + public TracesExpansionTestCase() { super(); } - public TracesNoReductionTestCase(File file) + public TracesExpansionTestCase(File file) { super(file); } diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/CompileTests.java b/core/codegen/src/test/java/org/overture/codegen/tests/utils/CompileTests.java index 06bdc4b0b3..590333e2ea 100644 --- a/core/codegen/src/test/java/org/overture/codegen/tests/utils/CompileTests.java +++ b/core/codegen/src/test/java/org/overture/codegen/tests/utils/CompileTests.java @@ -43,7 +43,7 @@ import org.overture.codegen.tests.PrePostTest; import org.overture.codegen.tests.RtTest; import org.overture.codegen.tests.SpecificationTest; -import org.overture.codegen.tests.TracesNoReductionTest; +import org.overture.codegen.tests.TracesExpansionTest; import org.overture.codegen.tests.UnionTypeTest; import org.overture.codegen.utils.GeneralCodeGenUtils; import org.overture.codegen.utils.GeneralUtils; @@ -83,7 +83,7 @@ public class CompileTests public static final boolean PRE_POST_TESTS = true; public static final boolean RUN_EXECUTING_CLASSIC_SPEC_TESTS = true; public static final boolean RUN_CONFIGURED_CLONE_TESTS = true; - public static final boolean RUN_TRACE_TESTS = true; + public static final boolean RUN_TRACES_EXPANSION_TESTS = true; private List testInputFiles; private List resultFiles; @@ -181,7 +181,7 @@ private void runTests() throws IOException runConfiguredCloningTests(); } - if(RUN_TRACE_TESTS) + if(RUN_TRACES_EXPANSION_TESTS) { runTraceTests(); } @@ -199,15 +199,15 @@ private void runTests() throws IOException private void runTraceTests() throws IOException { - System.out.println("Beginning Trace no reduction tests..\n"); + System.out.println("Beginning Trace expansion tests..\n"); - testInputFiles = TestUtils.getTestInputFiles(new File(TracesNoReductionTest.ROOT)); - resultFiles = TestUtils.getFiles(new File(TracesNoReductionTest.ROOT), RESULT_FILE_EXTENSION); + testInputFiles = TestUtils.getTestInputFiles(new File(TracesExpansionTest.ROOT)); + resultFiles = TestUtils.getFiles(new File(TracesExpansionTest.ROOT), RESULT_FILE_EXTENSION); runTests(testInputFiles, resultFiles, new TraceHandler(Release.VDM_10, Dialect.VDM_RT), false); System.out.println("\n********"); - System.out.println("Finished with Trace no reduction tests"); + System.out.println("Finished with Trace expansion tests"); System.out.println("********\n"); } diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/Alternative1 b/core/codegen/src/test/resources/traces_expansion/Alternative1 similarity index 100% rename from core/codegen/src/test/resources/traces_no_reduction_specs/Alternative1 rename to core/codegen/src/test/resources/traces_expansion/Alternative1 diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/Alternative1.result b/core/codegen/src/test/resources/traces_expansion/Alternative1.result similarity index 100% rename from core/codegen/src/test/resources/traces_no_reduction_specs/Alternative1.result rename to core/codegen/src/test/resources/traces_expansion/Alternative1.result diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/AlternativeConcurrent1 b/core/codegen/src/test/resources/traces_expansion/AlternativeConcurrent1 similarity index 100% rename from core/codegen/src/test/resources/traces_no_reduction_specs/AlternativeConcurrent1 rename to core/codegen/src/test/resources/traces_expansion/AlternativeConcurrent1 diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/AlternativeConcurrent1.result b/core/codegen/src/test/resources/traces_expansion/AlternativeConcurrent1.result similarity index 100% rename from core/codegen/src/test/resources/traces_no_reduction_specs/AlternativeConcurrent1.result rename to core/codegen/src/test/resources/traces_expansion/AlternativeConcurrent1.result diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/AlternativeRepeat1 b/core/codegen/src/test/resources/traces_expansion/AlternativeRepeat1 similarity index 100% rename from core/codegen/src/test/resources/traces_no_reduction_specs/AlternativeRepeat1 rename to core/codegen/src/test/resources/traces_expansion/AlternativeRepeat1 diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/AlternativeRepeat1.result b/core/codegen/src/test/resources/traces_expansion/AlternativeRepeat1.result similarity index 100% rename from core/codegen/src/test/resources/traces_no_reduction_specs/AlternativeRepeat1.result rename to core/codegen/src/test/resources/traces_expansion/AlternativeRepeat1.result diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/Concurrent1 b/core/codegen/src/test/resources/traces_expansion/Concurrent1 similarity index 100% rename from core/codegen/src/test/resources/traces_no_reduction_specs/Concurrent1 rename to core/codegen/src/test/resources/traces_expansion/Concurrent1 diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/Concurrent1.result b/core/codegen/src/test/resources/traces_expansion/Concurrent1.result similarity index 100% rename from core/codegen/src/test/resources/traces_no_reduction_specs/Concurrent1.result rename to core/codegen/src/test/resources/traces_expansion/Concurrent1.result diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/Concurrent2 b/core/codegen/src/test/resources/traces_expansion/Concurrent2 similarity index 100% rename from core/codegen/src/test/resources/traces_no_reduction_specs/Concurrent2 rename to core/codegen/src/test/resources/traces_expansion/Concurrent2 diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/Concurrent2.result b/core/codegen/src/test/resources/traces_expansion/Concurrent2.result similarity index 100% rename from core/codegen/src/test/resources/traces_no_reduction_specs/Concurrent2.result rename to core/codegen/src/test/resources/traces_expansion/Concurrent2.result diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/ConcurrentAlternative1 b/core/codegen/src/test/resources/traces_expansion/ConcurrentAlternative1 similarity index 100% rename from core/codegen/src/test/resources/traces_no_reduction_specs/ConcurrentAlternative1 rename to core/codegen/src/test/resources/traces_expansion/ConcurrentAlternative1 diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/ConcurrentAlternative1.result b/core/codegen/src/test/resources/traces_expansion/ConcurrentAlternative1.result similarity index 100% rename from core/codegen/src/test/resources/traces_no_reduction_specs/ConcurrentAlternative1.result rename to core/codegen/src/test/resources/traces_expansion/ConcurrentAlternative1.result diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/ConcurrentRepeat1 b/core/codegen/src/test/resources/traces_expansion/ConcurrentRepeat1 similarity index 100% rename from core/codegen/src/test/resources/traces_no_reduction_specs/ConcurrentRepeat1 rename to core/codegen/src/test/resources/traces_expansion/ConcurrentRepeat1 diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/ConcurrentRepeat1.result b/core/codegen/src/test/resources/traces_expansion/ConcurrentRepeat1.result similarity index 100% rename from core/codegen/src/test/resources/traces_no_reduction_specs/ConcurrentRepeat1.result rename to core/codegen/src/test/resources/traces_expansion/ConcurrentRepeat1.result diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/LetBeSt1 b/core/codegen/src/test/resources/traces_expansion/LetBeSt1 similarity index 100% rename from core/codegen/src/test/resources/traces_no_reduction_specs/LetBeSt1 rename to core/codegen/src/test/resources/traces_expansion/LetBeSt1 diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/LetBeSt1.result b/core/codegen/src/test/resources/traces_expansion/LetBeSt1.result similarity index 100% rename from core/codegen/src/test/resources/traces_no_reduction_specs/LetBeSt1.result rename to core/codegen/src/test/resources/traces_expansion/LetBeSt1.result diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/LetDef1 b/core/codegen/src/test/resources/traces_expansion/LetDef1 similarity index 100% rename from core/codegen/src/test/resources/traces_no_reduction_specs/LetDef1 rename to core/codegen/src/test/resources/traces_expansion/LetDef1 diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/LetDef1.result b/core/codegen/src/test/resources/traces_expansion/LetDef1.result similarity index 100% rename from core/codegen/src/test/resources/traces_no_reduction_specs/LetDef1.result rename to core/codegen/src/test/resources/traces_expansion/LetDef1.result diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/Repeat1 b/core/codegen/src/test/resources/traces_expansion/Repeat1 similarity index 100% rename from core/codegen/src/test/resources/traces_no_reduction_specs/Repeat1 rename to core/codegen/src/test/resources/traces_expansion/Repeat1 diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/Repeat1.result b/core/codegen/src/test/resources/traces_expansion/Repeat1.result similarity index 100% rename from core/codegen/src/test/resources/traces_no_reduction_specs/Repeat1.result rename to core/codegen/src/test/resources/traces_expansion/Repeat1.result diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/RepeatAlternative1 b/core/codegen/src/test/resources/traces_expansion/RepeatAlternative1 similarity index 100% rename from core/codegen/src/test/resources/traces_no_reduction_specs/RepeatAlternative1 rename to core/codegen/src/test/resources/traces_expansion/RepeatAlternative1 diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/RepeatAlternative1.result b/core/codegen/src/test/resources/traces_expansion/RepeatAlternative1.result similarity index 100% rename from core/codegen/src/test/resources/traces_no_reduction_specs/RepeatAlternative1.result rename to core/codegen/src/test/resources/traces_expansion/RepeatAlternative1.result diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/RepeatConcurrent1 b/core/codegen/src/test/resources/traces_expansion/RepeatConcurrent1 similarity index 100% rename from core/codegen/src/test/resources/traces_no_reduction_specs/RepeatConcurrent1 rename to core/codegen/src/test/resources/traces_expansion/RepeatConcurrent1 diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/RepeatConcurrent1.result b/core/codegen/src/test/resources/traces_expansion/RepeatConcurrent1.result similarity index 100% rename from core/codegen/src/test/resources/traces_no_reduction_specs/RepeatConcurrent1.result rename to core/codegen/src/test/resources/traces_expansion/RepeatConcurrent1.result diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/SingleStatement1 b/core/codegen/src/test/resources/traces_expansion/SingleStatement1 similarity index 100% rename from core/codegen/src/test/resources/traces_no_reduction_specs/SingleStatement1 rename to core/codegen/src/test/resources/traces_expansion/SingleStatement1 diff --git a/core/codegen/src/test/resources/traces_no_reduction_specs/SingleStatement1.result b/core/codegen/src/test/resources/traces_expansion/SingleStatement1.result similarity index 100% rename from core/codegen/src/test/resources/traces_no_reduction_specs/SingleStatement1.result rename to core/codegen/src/test/resources/traces_expansion/SingleStatement1.result From c8db3d1734758e95498368aa5264a5cdf1e85b28 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 28 Jan 2015 00:26:36 +0100 Subject: [PATCH 030/323] Moving some testing artefacts around --- .../{traces_expansion => traces_expansion_specs}/Alternative1 | 0 .../Alternative1.result | 0 .../AlternativeConcurrent1 | 0 .../AlternativeConcurrent1.result | 0 .../AlternativeRepeat1 | 0 .../AlternativeRepeat1.result | 0 .../{traces_expansion => traces_expansion_specs}/Concurrent1 | 0 .../Concurrent1.result | 0 .../{traces_expansion => traces_expansion_specs}/Concurrent2 | 0 .../Concurrent2.result | 0 .../ConcurrentAlternative1 | 0 .../ConcurrentAlternative1.result | 0 .../ConcurrentRepeat1 | 0 .../ConcurrentRepeat1.result | 0 .../{traces_expansion => traces_expansion_specs}/LetBeSt1 | 0 .../{traces_expansion => traces_expansion_specs}/LetBeSt1.result | 0 .../{traces_expansion => traces_expansion_specs}/LetDef1 | 0 .../{traces_expansion => traces_expansion_specs}/LetDef1.result | 0 .../{traces_expansion => traces_expansion_specs}/Repeat1 | 0 .../{traces_expansion => traces_expansion_specs}/Repeat1.result | 0 .../RepeatAlternative1 | 0 .../RepeatAlternative1.result | 0 .../RepeatConcurrent1 | 0 .../RepeatConcurrent1.result | 0 .../{traces_expansion => traces_expansion_specs}/SingleStatement1 | 0 .../SingleStatement1.result | 0 26 files changed, 0 insertions(+), 0 deletions(-) rename core/codegen/src/test/resources/{traces_expansion => traces_expansion_specs}/Alternative1 (100%) rename core/codegen/src/test/resources/{traces_expansion => traces_expansion_specs}/Alternative1.result (100%) rename core/codegen/src/test/resources/{traces_expansion => traces_expansion_specs}/AlternativeConcurrent1 (100%) rename core/codegen/src/test/resources/{traces_expansion => traces_expansion_specs}/AlternativeConcurrent1.result (100%) rename core/codegen/src/test/resources/{traces_expansion => traces_expansion_specs}/AlternativeRepeat1 (100%) rename core/codegen/src/test/resources/{traces_expansion => traces_expansion_specs}/AlternativeRepeat1.result (100%) rename core/codegen/src/test/resources/{traces_expansion => traces_expansion_specs}/Concurrent1 (100%) rename core/codegen/src/test/resources/{traces_expansion => traces_expansion_specs}/Concurrent1.result (100%) rename core/codegen/src/test/resources/{traces_expansion => traces_expansion_specs}/Concurrent2 (100%) rename core/codegen/src/test/resources/{traces_expansion => traces_expansion_specs}/Concurrent2.result (100%) rename core/codegen/src/test/resources/{traces_expansion => traces_expansion_specs}/ConcurrentAlternative1 (100%) rename core/codegen/src/test/resources/{traces_expansion => traces_expansion_specs}/ConcurrentAlternative1.result (100%) rename core/codegen/src/test/resources/{traces_expansion => traces_expansion_specs}/ConcurrentRepeat1 (100%) rename core/codegen/src/test/resources/{traces_expansion => traces_expansion_specs}/ConcurrentRepeat1.result (100%) rename core/codegen/src/test/resources/{traces_expansion => traces_expansion_specs}/LetBeSt1 (100%) rename core/codegen/src/test/resources/{traces_expansion => traces_expansion_specs}/LetBeSt1.result (100%) rename core/codegen/src/test/resources/{traces_expansion => traces_expansion_specs}/LetDef1 (100%) rename core/codegen/src/test/resources/{traces_expansion => traces_expansion_specs}/LetDef1.result (100%) rename core/codegen/src/test/resources/{traces_expansion => traces_expansion_specs}/Repeat1 (100%) rename core/codegen/src/test/resources/{traces_expansion => traces_expansion_specs}/Repeat1.result (100%) rename core/codegen/src/test/resources/{traces_expansion => traces_expansion_specs}/RepeatAlternative1 (100%) rename core/codegen/src/test/resources/{traces_expansion => traces_expansion_specs}/RepeatAlternative1.result (100%) rename core/codegen/src/test/resources/{traces_expansion => traces_expansion_specs}/RepeatConcurrent1 (100%) rename core/codegen/src/test/resources/{traces_expansion => traces_expansion_specs}/RepeatConcurrent1.result (100%) rename core/codegen/src/test/resources/{traces_expansion => traces_expansion_specs}/SingleStatement1 (100%) rename core/codegen/src/test/resources/{traces_expansion => traces_expansion_specs}/SingleStatement1.result (100%) diff --git a/core/codegen/src/test/resources/traces_expansion/Alternative1 b/core/codegen/src/test/resources/traces_expansion_specs/Alternative1 similarity index 100% rename from core/codegen/src/test/resources/traces_expansion/Alternative1 rename to core/codegen/src/test/resources/traces_expansion_specs/Alternative1 diff --git a/core/codegen/src/test/resources/traces_expansion/Alternative1.result b/core/codegen/src/test/resources/traces_expansion_specs/Alternative1.result similarity index 100% rename from core/codegen/src/test/resources/traces_expansion/Alternative1.result rename to core/codegen/src/test/resources/traces_expansion_specs/Alternative1.result diff --git a/core/codegen/src/test/resources/traces_expansion/AlternativeConcurrent1 b/core/codegen/src/test/resources/traces_expansion_specs/AlternativeConcurrent1 similarity index 100% rename from core/codegen/src/test/resources/traces_expansion/AlternativeConcurrent1 rename to core/codegen/src/test/resources/traces_expansion_specs/AlternativeConcurrent1 diff --git a/core/codegen/src/test/resources/traces_expansion/AlternativeConcurrent1.result b/core/codegen/src/test/resources/traces_expansion_specs/AlternativeConcurrent1.result similarity index 100% rename from core/codegen/src/test/resources/traces_expansion/AlternativeConcurrent1.result rename to core/codegen/src/test/resources/traces_expansion_specs/AlternativeConcurrent1.result diff --git a/core/codegen/src/test/resources/traces_expansion/AlternativeRepeat1 b/core/codegen/src/test/resources/traces_expansion_specs/AlternativeRepeat1 similarity index 100% rename from core/codegen/src/test/resources/traces_expansion/AlternativeRepeat1 rename to core/codegen/src/test/resources/traces_expansion_specs/AlternativeRepeat1 diff --git a/core/codegen/src/test/resources/traces_expansion/AlternativeRepeat1.result b/core/codegen/src/test/resources/traces_expansion_specs/AlternativeRepeat1.result similarity index 100% rename from core/codegen/src/test/resources/traces_expansion/AlternativeRepeat1.result rename to core/codegen/src/test/resources/traces_expansion_specs/AlternativeRepeat1.result diff --git a/core/codegen/src/test/resources/traces_expansion/Concurrent1 b/core/codegen/src/test/resources/traces_expansion_specs/Concurrent1 similarity index 100% rename from core/codegen/src/test/resources/traces_expansion/Concurrent1 rename to core/codegen/src/test/resources/traces_expansion_specs/Concurrent1 diff --git a/core/codegen/src/test/resources/traces_expansion/Concurrent1.result b/core/codegen/src/test/resources/traces_expansion_specs/Concurrent1.result similarity index 100% rename from core/codegen/src/test/resources/traces_expansion/Concurrent1.result rename to core/codegen/src/test/resources/traces_expansion_specs/Concurrent1.result diff --git a/core/codegen/src/test/resources/traces_expansion/Concurrent2 b/core/codegen/src/test/resources/traces_expansion_specs/Concurrent2 similarity index 100% rename from core/codegen/src/test/resources/traces_expansion/Concurrent2 rename to core/codegen/src/test/resources/traces_expansion_specs/Concurrent2 diff --git a/core/codegen/src/test/resources/traces_expansion/Concurrent2.result b/core/codegen/src/test/resources/traces_expansion_specs/Concurrent2.result similarity index 100% rename from core/codegen/src/test/resources/traces_expansion/Concurrent2.result rename to core/codegen/src/test/resources/traces_expansion_specs/Concurrent2.result diff --git a/core/codegen/src/test/resources/traces_expansion/ConcurrentAlternative1 b/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentAlternative1 similarity index 100% rename from core/codegen/src/test/resources/traces_expansion/ConcurrentAlternative1 rename to core/codegen/src/test/resources/traces_expansion_specs/ConcurrentAlternative1 diff --git a/core/codegen/src/test/resources/traces_expansion/ConcurrentAlternative1.result b/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentAlternative1.result similarity index 100% rename from core/codegen/src/test/resources/traces_expansion/ConcurrentAlternative1.result rename to core/codegen/src/test/resources/traces_expansion_specs/ConcurrentAlternative1.result diff --git a/core/codegen/src/test/resources/traces_expansion/ConcurrentRepeat1 b/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentRepeat1 similarity index 100% rename from core/codegen/src/test/resources/traces_expansion/ConcurrentRepeat1 rename to core/codegen/src/test/resources/traces_expansion_specs/ConcurrentRepeat1 diff --git a/core/codegen/src/test/resources/traces_expansion/ConcurrentRepeat1.result b/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentRepeat1.result similarity index 100% rename from core/codegen/src/test/resources/traces_expansion/ConcurrentRepeat1.result rename to core/codegen/src/test/resources/traces_expansion_specs/ConcurrentRepeat1.result diff --git a/core/codegen/src/test/resources/traces_expansion/LetBeSt1 b/core/codegen/src/test/resources/traces_expansion_specs/LetBeSt1 similarity index 100% rename from core/codegen/src/test/resources/traces_expansion/LetBeSt1 rename to core/codegen/src/test/resources/traces_expansion_specs/LetBeSt1 diff --git a/core/codegen/src/test/resources/traces_expansion/LetBeSt1.result b/core/codegen/src/test/resources/traces_expansion_specs/LetBeSt1.result similarity index 100% rename from core/codegen/src/test/resources/traces_expansion/LetBeSt1.result rename to core/codegen/src/test/resources/traces_expansion_specs/LetBeSt1.result diff --git a/core/codegen/src/test/resources/traces_expansion/LetDef1 b/core/codegen/src/test/resources/traces_expansion_specs/LetDef1 similarity index 100% rename from core/codegen/src/test/resources/traces_expansion/LetDef1 rename to core/codegen/src/test/resources/traces_expansion_specs/LetDef1 diff --git a/core/codegen/src/test/resources/traces_expansion/LetDef1.result b/core/codegen/src/test/resources/traces_expansion_specs/LetDef1.result similarity index 100% rename from core/codegen/src/test/resources/traces_expansion/LetDef1.result rename to core/codegen/src/test/resources/traces_expansion_specs/LetDef1.result diff --git a/core/codegen/src/test/resources/traces_expansion/Repeat1 b/core/codegen/src/test/resources/traces_expansion_specs/Repeat1 similarity index 100% rename from core/codegen/src/test/resources/traces_expansion/Repeat1 rename to core/codegen/src/test/resources/traces_expansion_specs/Repeat1 diff --git a/core/codegen/src/test/resources/traces_expansion/Repeat1.result b/core/codegen/src/test/resources/traces_expansion_specs/Repeat1.result similarity index 100% rename from core/codegen/src/test/resources/traces_expansion/Repeat1.result rename to core/codegen/src/test/resources/traces_expansion_specs/Repeat1.result diff --git a/core/codegen/src/test/resources/traces_expansion/RepeatAlternative1 b/core/codegen/src/test/resources/traces_expansion_specs/RepeatAlternative1 similarity index 100% rename from core/codegen/src/test/resources/traces_expansion/RepeatAlternative1 rename to core/codegen/src/test/resources/traces_expansion_specs/RepeatAlternative1 diff --git a/core/codegen/src/test/resources/traces_expansion/RepeatAlternative1.result b/core/codegen/src/test/resources/traces_expansion_specs/RepeatAlternative1.result similarity index 100% rename from core/codegen/src/test/resources/traces_expansion/RepeatAlternative1.result rename to core/codegen/src/test/resources/traces_expansion_specs/RepeatAlternative1.result diff --git a/core/codegen/src/test/resources/traces_expansion/RepeatConcurrent1 b/core/codegen/src/test/resources/traces_expansion_specs/RepeatConcurrent1 similarity index 100% rename from core/codegen/src/test/resources/traces_expansion/RepeatConcurrent1 rename to core/codegen/src/test/resources/traces_expansion_specs/RepeatConcurrent1 diff --git a/core/codegen/src/test/resources/traces_expansion/RepeatConcurrent1.result b/core/codegen/src/test/resources/traces_expansion_specs/RepeatConcurrent1.result similarity index 100% rename from core/codegen/src/test/resources/traces_expansion/RepeatConcurrent1.result rename to core/codegen/src/test/resources/traces_expansion_specs/RepeatConcurrent1.result diff --git a/core/codegen/src/test/resources/traces_expansion/SingleStatement1 b/core/codegen/src/test/resources/traces_expansion_specs/SingleStatement1 similarity index 100% rename from core/codegen/src/test/resources/traces_expansion/SingleStatement1 rename to core/codegen/src/test/resources/traces_expansion_specs/SingleStatement1 diff --git a/core/codegen/src/test/resources/traces_expansion/SingleStatement1.result b/core/codegen/src/test/resources/traces_expansion_specs/SingleStatement1.result similarity index 100% rename from core/codegen/src/test/resources/traces_expansion/SingleStatement1.result rename to core/codegen/src/test/resources/traces_expansion_specs/SingleStatement1.result From b2f1e3b90d4548f256c5e1043c719d40451725a5 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 28 Jan 2015 00:33:21 +0100 Subject: [PATCH 031/323] Minor updates to the trace test handler --- .../java/org/overture/codegen/tests/utils/TraceHandler.java | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/TraceHandler.java b/core/codegen/src/test/java/org/overture/codegen/tests/utils/TraceHandler.java index 6f9f6d66ed..00c2cff125 100644 --- a/core/codegen/src/test/java/org/overture/codegen/tests/utils/TraceHandler.java +++ b/core/codegen/src/test/java/org/overture/codegen/tests/utils/TraceHandler.java @@ -102,9 +102,7 @@ public JavaExecutionResult runJava(File folder) { JavaExecutionResult javaResult = super.runJava(folder); - TestAccumulator acc = (TestAccumulator) javaResult.getExecutionResult(); - - return new JavaExecutionResult(javaResult.getProcessOutput(), acc.toString()); + return new JavaExecutionResult(javaResult.getProcessOutput(), javaResult.getExecutionResult().toString()); } public File computeVdmTraceResult(File specFile) throws IOException, From 6e23415e3e0178b4ce98bc9cf865664fd23120d1 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 28 Jan 2015 13:28:32 +0100 Subject: [PATCH 032/323] Updates to the core/codegen test handler. The test execution system has been improved with respect to execution of traces. --- .../utils/ExecutableSpecTestHandler.java | 3 +-- .../tests/utils/ExecutableTestHandler.java | 3 +-- .../codegen/tests/utils/TraceHandler.java | 27 ++++++++++--------- 3 files changed, 16 insertions(+), 17 deletions(-) diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExecutableSpecTestHandler.java b/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExecutableSpecTestHandler.java index 9ae96c5d53..a3f1c6cf60 100644 --- a/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExecutableSpecTestHandler.java +++ b/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExecutableSpecTestHandler.java @@ -31,7 +31,6 @@ import org.overture.config.Release; import org.overture.config.Settings; import org.overture.interpreter.util.InterpreterUtil; -import org.overture.interpreter.values.Value; public class ExecutableSpecTestHandler extends EntryBasedTestHandler { @@ -124,7 +123,7 @@ public String getVdmEntry() } @Override - public Value interpretVdm(File intputFile) throws Exception + public Object interpretVdm(File intputFile) throws Exception { return InterpreterUtil.interpret(Settings.dialect, getVdmEntry(), intputFile); } diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExecutableTestHandler.java b/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExecutableTestHandler.java index 4245d86aae..390838538b 100644 --- a/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExecutableTestHandler.java +++ b/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExecutableTestHandler.java @@ -31,7 +31,6 @@ import org.overture.ast.lex.Dialect; import org.overture.config.Release; import org.overture.config.Settings; -import org.overture.interpreter.values.Value; public abstract class ExecutableTestHandler extends TestHandler { @@ -96,7 +95,7 @@ public ExecutableTestHandler(Release release, Dialect dialect) Settings.dialect = dialect; } - public abstract Value interpretVdm(File intputFile) throws Exception; + public abstract Object interpretVdm(File intputFile) throws Exception; public List getMainClassMethods() { diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/TraceHandler.java b/core/codegen/src/test/java/org/overture/codegen/tests/utils/TraceHandler.java index 00c2cff125..4d60ba0391 100644 --- a/core/codegen/src/test/java/org/overture/codegen/tests/utils/TraceHandler.java +++ b/core/codegen/src/test/java/org/overture/codegen/tests/utils/TraceHandler.java @@ -21,9 +21,6 @@ import org.overture.ct.ctruntime.utils.TraceReductionInfo; import org.overture.ct.ctruntime.utils.TraceResult; import org.overture.ct.ctruntime.utils.TraceResultReader; -import org.overture.ct.ctruntime.utils.TraceTest; -import org.overture.interpreter.values.SeqValue; -import org.overture.interpreter.values.Value; import org.xml.sax.SAXException; public class TraceHandler extends ExecutableSpecTestHandler @@ -72,7 +69,7 @@ public List getMainClassMethods() } @Override - public Value interpretVdm(File intputFile) throws Exception + public Object interpretVdm(File intputFile) throws Exception { File vdmTraceResultFile = computeVdmTraceResult(currentInputFile); @@ -87,14 +84,7 @@ public Value interpretVdm(File intputFile) throws Exception TraceResult t1 = testResult.get(0); - StringBuilder sb = new StringBuilder(); - - for (TraceTest t : t1.tests) - { - sb.append(t.toString()).append('\n'); - } - - return new SeqValue(sb.toString()); + return t1.tests; } @Override @@ -102,7 +92,18 @@ public JavaExecutionResult runJava(File folder) { JavaExecutionResult javaResult = super.runJava(folder); - return new JavaExecutionResult(javaResult.getProcessOutput(), javaResult.getExecutionResult().toString()); + Object executionResult = javaResult.getExecutionResult(); + + if(executionResult instanceof TestAccumulator) + { + TestAccumulator acc = (TestAccumulator) executionResult; + + return new JavaExecutionResult(javaResult.getProcessOutput(), acc.getAllTests()); + } + else + { + return new JavaExecutionResult(javaResult.getProcessOutput(), javaResult.getExecutionResult().toString()); + } } public File computeVdmTraceResult(File specFile) throws IOException, From e53fc3444398223c0c6283350e7bfe8f6c2976a5 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 28 Jan 2015 13:33:28 +0100 Subject: [PATCH 033/323] Added test to exercise code generation of tests with different verdicts --- .../org/overture/codegen/tests/TestFlags.java | 3 +- .../codegen/tests/TracesVerdictTest.java | 32 +++++++++++++++++++ .../codegen/tests/TracesVerdictTestCase.java | 29 +++++++++++++++++ 3 files changed, 63 insertions(+), 1 deletion(-) create mode 100644 core/codegen/src/test/java/org/overture/codegen/tests/TracesVerdictTest.java create mode 100644 core/codegen/src/test/java/org/overture/codegen/tests/TracesVerdictTestCase.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/TestFlags.java b/core/codegen/src/test/java/org/overture/codegen/tests/TestFlags.java index 13180a70cc..b981337bf5 100644 --- a/core/codegen/src/test/java/org/overture/codegen/tests/TestFlags.java +++ b/core/codegen/src/test/java/org/overture/codegen/tests/TestFlags.java @@ -37,5 +37,6 @@ public class TestFlags public static final boolean BIND_TESTS_ON = false; public static final boolean PRE_POST_TESTS_ON = false; public static final boolean RT_TESTS_ON = false; - public static final boolean TRACES_NO_REDUCTION_TESTS_ON = false; + public static final boolean TRACES_EXPANSION_TESTS_ON = false; + public static final boolean TRACES_VERDICT_TESTS_ON = false; } diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/TracesVerdictTest.java b/core/codegen/src/test/java/org/overture/codegen/tests/TracesVerdictTest.java new file mode 100644 index 0000000000..2ccb04c031 --- /dev/null +++ b/core/codegen/src/test/java/org/overture/codegen/tests/TracesVerdictTest.java @@ -0,0 +1,32 @@ +package org.overture.codegen.tests; + +import java.io.File; +import java.io.IOException; +import java.lang.reflect.InvocationTargetException; + +import junit.framework.Test; +import junit.framework.TestSuite; + +import org.overture.ast.lex.LexLocation; +import org.overture.test.framework.BaseTestSuite; +import org.overture.test.framework.Properties; + +public class TracesVerdictTest extends BaseTestSuite +{ + public static final String ROOT = "src" + File.separatorChar + "test" + + File.separatorChar + "resources" + File.separatorChar + + "traces_verdict_specs"; + + public static Test suite() throws IllegalArgumentException, + SecurityException, InstantiationException, IllegalAccessException, + InvocationTargetException, NoSuchMethodException, IOException + { + LexLocation.absoluteToStringLocation = false; + Properties.recordTestResults = TestFlags.TRACES_VERDICT_TESTS_ON; + + String name = "Traces verdict test case"; + TestSuite test = createTestCompleteFile(name, ROOT, TracesVerdictTestCase.class, ""); + return test; + } +} + diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/TracesVerdictTestCase.java b/core/codegen/src/test/java/org/overture/codegen/tests/TracesVerdictTestCase.java new file mode 100644 index 0000000000..d718a55b27 --- /dev/null +++ b/core/codegen/src/test/java/org/overture/codegen/tests/TracesVerdictTestCase.java @@ -0,0 +1,29 @@ +package org.overture.codegen.tests; + +import java.io.File; + +import org.overture.codegen.ir.IRSettings; + +public class TracesVerdictTestCase extends TracesExpansionTestCase +{ + public TracesVerdictTestCase() + { + super(); + } + + public TracesVerdictTestCase(File file) + { + super(file); + } + + @Override + public IRSettings getIrSettings() + { + IRSettings irSettings = super.getIrSettings(); + irSettings.setGenerateTraces(true); + irSettings.setGeneratePreCondChecks(true); + irSettings.setGeneratePreConds(true); + + return irSettings; + } +} From 49bb6aa535b95c5b521dad49294e7fc882a1a1f2 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 28 Jan 2015 13:43:20 +0100 Subject: [PATCH 034/323] Improved comparison of VDM/code generated trace tests --- .../codegen/tests/utils/ComparisonCG.java | 64 ++++++++++++++++++- .../codegen/tests/utils/CompileTests.java | 28 ++++++-- 2 files changed, 87 insertions(+), 5 deletions(-) diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/ComparisonCG.java b/core/codegen/src/test/java/org/overture/codegen/tests/utils/ComparisonCG.java index 93ff76bc04..45656a7132 100644 --- a/core/codegen/src/test/java/org/overture/codegen/tests/utils/ComparisonCG.java +++ b/core/codegen/src/test/java/org/overture/codegen/tests/utils/ComparisonCG.java @@ -34,6 +34,8 @@ import org.overture.codegen.runtime.VDMMap; import org.overture.codegen.runtime.VDMSeq; import org.overture.codegen.runtime.VDMSet; +import org.overture.ct.ctruntime.utils.TraceTest; +import org.overture.interpreter.traces.Verdict; import org.overture.interpreter.values.BooleanValue; import org.overture.interpreter.values.CharacterValue; import org.overture.interpreter.values.FieldMap; @@ -63,8 +65,68 @@ public ComparisonCG(File testInputFile) } } - public boolean compare(Object cgValue, Value vdmValue) + @SuppressWarnings("rawtypes") + public boolean compare(Object cgValue, Object vdmResult) { + if(!(vdmResult instanceof Value)) + { + if(vdmResult instanceof List && cgValue instanceof List) + { + List vdmList = (List) vdmResult; + List cgList = (List) cgValue; + + if(vdmList.size() != cgList.size()) + { + return false; + } + + for(int i = 0; i < vdmList.size(); i++) + { + Object vdmElem = vdmList.get(i); + Object cgElem = cgList.get(i); + + if(vdmElem instanceof TraceTest && + cgElem instanceof org.overture.codegen.runtime.traces.TraceTest) + { + TraceTest vdmTest = (TraceTest) vdmElem; + org.overture.codegen.runtime.traces.TraceTest cgTest = (org.overture.codegen.runtime.traces.TraceTest) cgElem; + + if(vdmTest.getVerdict().toString().equals(cgTest.getVerdict().toString())) + { + if(!(vdmTest.getNo().equals(cgTest.getNo()) && vdmTest.getTest().equals(cgTest.getTest()))) + { + return false; + } + + if(vdmTest.getVerdict() == Verdict.PASSED) + { + if(!vdmTest.getResult().equals(cgTest.getResult())) + { + return false; + } + } + } + else + { + return false; + } + } + else + { + return false; + } + } + return true; + } + else + { + return false; + } + } + + Value vdmValue = (Value) vdmResult; + + while (vdmValue instanceof UpdatableValue) { UpdatableValue upValue = (UpdatableValue) vdmValue; diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/CompileTests.java b/core/codegen/src/test/java/org/overture/codegen/tests/utils/CompileTests.java index 590333e2ea..45ce469e69 100644 --- a/core/codegen/src/test/java/org/overture/codegen/tests/utils/CompileTests.java +++ b/core/codegen/src/test/java/org/overture/codegen/tests/utils/CompileTests.java @@ -44,12 +44,12 @@ import org.overture.codegen.tests.RtTest; import org.overture.codegen.tests.SpecificationTest; import org.overture.codegen.tests.TracesExpansionTest; +import org.overture.codegen.tests.TracesVerdictTest; import org.overture.codegen.tests.UnionTypeTest; import org.overture.codegen.utils.GeneralCodeGenUtils; import org.overture.codegen.utils.GeneralUtils; import org.overture.config.Release; import org.overture.interpreter.runtime.ContextException; -import org.overture.interpreter.values.Value; public class CompileTests { @@ -84,6 +84,7 @@ public class CompileTests public static final boolean RUN_EXECUTING_CLASSIC_SPEC_TESTS = true; public static final boolean RUN_CONFIGURED_CLONE_TESTS = true; public static final boolean RUN_TRACES_EXPANSION_TESTS = true; + public static final boolean RUN_TRACES_VERDICT_TESTS = true; private List testInputFiles; private List resultFiles; @@ -183,7 +184,12 @@ private void runTests() throws IOException if(RUN_TRACES_EXPANSION_TESTS) { - runTraceTests(); + runTraceExpansionTests(); + } + + if(RUN_TRACES_VERDICT_TESTS) + { + runTraceVerdictTests(); } long endTimeMs = System.currentTimeMillis(); @@ -197,7 +203,21 @@ private void runTests() throws IOException + String.format("%02d:%02d", minutes, seconds) + "."); } - private void runTraceTests() throws IOException + private void runTraceVerdictTests() throws IOException + { + System.out.println("Beginning Trace verdict tests..\n"); + + testInputFiles = TestUtils.getTestInputFiles(new File(TracesVerdictTest.ROOT)); + resultFiles = TestUtils.getFiles(new File(TracesVerdictTest.ROOT), RESULT_FILE_EXTENSION); + + runTests(testInputFiles, resultFiles, new TraceHandler(Release.VDM_10, Dialect.VDM_RT), false); + + System.out.println("\n********"); + System.out.println("Finished with Trace verdict tests"); + System.out.println("********\n"); + } + + private void runTraceExpansionTests() throws IOException { System.out.println("Beginning Trace expansion tests..\n"); @@ -520,7 +540,7 @@ public void runTests(List testInputFiles, List resultFiles, { // Comparison of VDM and Java results ComparisonCG comp = new ComparisonCG(currentInputFile); - equal = comp.compare(javaResult.getExecutionResult(), (Value) vdmResult); + equal = comp.compare(javaResult.getExecutionResult(), vdmResult); } if (printInput) From 4892cdc3c0c848a1bab4cfc859da08a9470370f6 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 28 Jan 2015 20:50:22 +0100 Subject: [PATCH 035/323] Added test to exercise pre condition violation in traces --- .../traces_verdict_specs/PreCondViolation | 16 +++++ .../PreCondViolation.result | 65 +++++++++++++++++++ 2 files changed, 81 insertions(+) create mode 100644 core/codegen/src/test/resources/traces_verdict_specs/PreCondViolation create mode 100644 core/codegen/src/test/resources/traces_verdict_specs/PreCondViolation.result diff --git a/core/codegen/src/test/resources/traces_verdict_specs/PreCondViolation b/core/codegen/src/test/resources/traces_verdict_specs/PreCondViolation new file mode 100644 index 0000000000..977bef9250 --- /dev/null +++ b/core/codegen/src/test/resources/traces_verdict_specs/PreCondViolation @@ -0,0 +1,16 @@ +class Entry + +operations + +public op : (nat) ==> () +op (x) == skip +pre x <> 2 and x <> 4; + +traces + +T1: +let x in set {1,2,3,4,5} +in + op(x); + +end Entry \ No newline at end of file diff --git a/core/codegen/src/test/resources/traces_verdict_specs/PreCondViolation.result b/core/codegen/src/test/resources/traces_verdict_specs/PreCondViolation.result new file mode 100644 index 0000000000..b4c6c8bb80 --- /dev/null +++ b/core/codegen/src/test/resources/traces_verdict_specs/PreCondViolation.result @@ -0,0 +1,65 @@ +import org.overture.codegen.runtime.*; +import org.overture.codegen.runtime.traces.*; + +import java.util.*; + + +public class Entry { + public Entry() { + } + + public void op(final Number x) { + if (!(pre_op(x))) { + throw new RuntimeException("Precondition failure: pre_op"); + } + + //Skip; + } + + private Boolean pre_op(final Number x) { + Boolean andResult_1 = false; + + if (!(Utils.equals(x, 2L))) { + if (!(Utils.equals(x, 4L))) { + andResult_1 = true; + } + } + + return andResult_1; + } + + public String toString() { + return "Entry{}"; + } + + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + SequenceTraceNode sequence_1 = new SequenceTraceNode(); + AlternativeTraceNode alternatives_2 = new AlternativeTraceNode(); + VDMSet set_1 = SetUtil.set(1L, 2L, 3L, 4L, 5L); + + for (Iterator iterator_1 = set_1.iterator(); iterator_1.hasNext();) { + final Number x = ((Number) iterator_1.next()); + CallStatement callStm_1 = new CallStatement() { + public Object execute(final Object instance) { + ((Entry) instance).op(x); + + return Utils.VOID_VALUE; + } + + public String toString() { + return "op(" + Utils.toString(x) + ")"; + } + }; + + StatementTraceNode apply_1 = new StatementTraceNode(callStm_1); + + alternatives_2.add(apply_1); + } + + sequence_1.add(alternatives_2); + + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator); + } +} + +########## From 92747b4a039b1c934da44a236fa87e223c0312d0 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Fri, 30 Jan 2015 13:10:20 +0100 Subject: [PATCH 036/323] Generalised the execution result class --- .../codegen/tests/utils/ExecutionResult.java | 22 +++++++++++++++++++ .../tests/utils/JavaExecutionResult.java | 22 ------------------- 2 files changed, 22 insertions(+), 22 deletions(-) create mode 100644 core/codegen/src/test/java/org/overture/codegen/tests/utils/ExecutionResult.java delete mode 100644 core/codegen/src/test/java/org/overture/codegen/tests/utils/JavaExecutionResult.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExecutionResult.java b/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExecutionResult.java new file mode 100644 index 0000000000..a0f8ed0da0 --- /dev/null +++ b/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExecutionResult.java @@ -0,0 +1,22 @@ +package org.overture.codegen.tests.utils; + +public class ExecutionResult +{ + private String strRepresentation; + private Object executionResult; + + public ExecutionResult(String strRepresentation, Object executionResult) + { + this.strRepresentation = strRepresentation; + this.executionResult = executionResult; + } + + public String getStrRepresentation() + { + return strRepresentation; + } + public Object getExecutionResult() + { + return executionResult; + } +} diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/JavaExecutionResult.java b/core/codegen/src/test/java/org/overture/codegen/tests/utils/JavaExecutionResult.java deleted file mode 100644 index 647c9e9b5a..0000000000 --- a/core/codegen/src/test/java/org/overture/codegen/tests/utils/JavaExecutionResult.java +++ /dev/null @@ -1,22 +0,0 @@ -package org.overture.codegen.tests.utils; - -public class JavaExecutionResult -{ - private String processOutput; - private Object executionResult; - - public JavaExecutionResult(String processOutput, Object executionResult) - { - this.processOutput = processOutput; - this.executionResult = executionResult; - } - - public String getProcessOutput() - { - return processOutput; - } - public Object getExecutionResult() - { - return executionResult; - } -} From 7639055f5ab794ea20a994c9c1ef6e4b366746d0 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Fri, 30 Jan 2015 13:16:19 +0100 Subject: [PATCH 037/323] Updated the test execution system to use the ExecutionResult class to store the VDM result --- .../codegen/tests/utils/CompileTests.java | 20 ++++++++++++----- .../utils/ExecutableSpecTestHandler.java | 6 +++-- .../tests/utils/ExecutableTestHandler.java | 6 ++--- .../tests/utils/ExpressionTestHandler.java | 6 +++-- .../codegen/tests/utils/TraceHandler.java | 22 +++++++++++++------ 5 files changed, 41 insertions(+), 19 deletions(-) diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/CompileTests.java b/core/codegen/src/test/java/org/overture/codegen/tests/utils/CompileTests.java index 45ce469e69..78d5370e77 100644 --- a/core/codegen/src/test/java/org/overture/codegen/tests/utils/CompileTests.java +++ b/core/codegen/src/test/java/org/overture/codegen/tests/utils/CompileTests.java @@ -520,7 +520,7 @@ public void runTests(List testInputFiles, List resultFiles, return; } - JavaExecutionResult javaResult = executableTestHandler.runJava(parent); + ExecutionResult javaResult = executableTestHandler.runJava(parent); if(javaResult == null) { @@ -536,11 +536,17 @@ public void runTests(List testInputFiles, List resultFiles, equal = vdmValueStr.contains(cgValueStr); } - else + else if(vdmResult instanceof ExecutionResult) { // Comparison of VDM and Java results ComparisonCG comp = new ComparisonCG(currentInputFile); - equal = comp.compare(javaResult.getExecutionResult(), vdmResult); + equal = comp.compare(javaResult.getExecutionResult(), + ((ExecutionResult) vdmResult).getExecutionResult()); + } + else + { + System.err.println("Expected the VDM execution result to be of type ExecutionResult. Got: " + vdmResult); + return; } if (printInput) @@ -555,8 +561,12 @@ public void runTests(List testInputFiles, List resultFiles, System.out.println("CG Test: " + currentInputFile.getName()); } - System.out.println("VDM ~> " + toShortString(vdmResult)); - System.out.print("Java ~> " + toShortString(javaResult.getProcessOutput())); + String vdmStrRep = vdmResult instanceof ExecutionResult ? + toShortString(((ExecutionResult) vdmResult).getStrRepresentation()) : + toShortString(vdmResult); + + System.out.println("VDM ~> " + vdmStrRep); + System.out.print("Java ~> " + toShortString(javaResult.getStrRepresentation())); if (equal) { diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExecutableSpecTestHandler.java b/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExecutableSpecTestHandler.java index a3f1c6cf60..1b000cbdec 100644 --- a/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExecutableSpecTestHandler.java +++ b/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExecutableSpecTestHandler.java @@ -31,6 +31,7 @@ import org.overture.config.Release; import org.overture.config.Settings; import org.overture.interpreter.util.InterpreterUtil; +import org.overture.interpreter.values.Value; public class ExecutableSpecTestHandler extends EntryBasedTestHandler { @@ -123,8 +124,9 @@ public String getVdmEntry() } @Override - public Object interpretVdm(File intputFile) throws Exception + public ExecutionResult interpretVdm(File intputFile) throws Exception { - return InterpreterUtil.interpret(Settings.dialect, getVdmEntry(), intputFile); + Value val = InterpreterUtil.interpret(Settings.dialect, getVdmEntry(), intputFile); + return new ExecutionResult(val.toString(), val); } } diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExecutableTestHandler.java b/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExecutableTestHandler.java index 390838538b..4d4904f732 100644 --- a/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExecutableTestHandler.java +++ b/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExecutableTestHandler.java @@ -95,7 +95,7 @@ public ExecutableTestHandler(Release release, Dialect dialect) Settings.dialect = dialect; } - public abstract Object interpretVdm(File intputFile) throws Exception; + public abstract ExecutionResult interpretVdm(File intputFile) throws Exception; public List getMainClassMethods() { @@ -114,7 +114,7 @@ private File getMainClassFile(File parent) throws IOException return getFile(parent, MAIN_CLASS); } - public JavaExecutionResult runJava(File folder) + public ExecutionResult runJava(File folder) { FileInputStream fin = null; ObjectInputStream ois = null; @@ -128,7 +128,7 @@ public JavaExecutionResult runJava(File folder) ois = new ObjectInputStream(fin); Object cgValue = (Object) ois.readObject(); - return new JavaExecutionResult(processOutput, cgValue); + return new ExecutionResult(processOutput, cgValue); } catch (Exception e) { diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExpressionTestHandler.java b/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExpressionTestHandler.java index edf4d2ef8c..51a5ec7e0f 100644 --- a/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExpressionTestHandler.java +++ b/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExpressionTestHandler.java @@ -45,12 +45,14 @@ public void writeGeneratedCode(File parent, File resultFile) } @Override - public Value interpretVdm(File intputFile) throws Exception + public ExecutionResult interpretVdm(File intputFile) throws Exception { initVdmEnv(); String input = GeneralUtils.readFromFile(intputFile); - return InterpreterUtil.interpret(input); + Value val = InterpreterUtil.interpret(input); + + return new ExecutionResult(val.toString(), val); } } diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/TraceHandler.java b/core/codegen/src/test/java/org/overture/codegen/tests/utils/TraceHandler.java index 4d60ba0391..6f3ea340df 100644 --- a/core/codegen/src/test/java/org/overture/codegen/tests/utils/TraceHandler.java +++ b/core/codegen/src/test/java/org/overture/codegen/tests/utils/TraceHandler.java @@ -21,6 +21,7 @@ import org.overture.ct.ctruntime.utils.TraceReductionInfo; import org.overture.ct.ctruntime.utils.TraceResult; import org.overture.ct.ctruntime.utils.TraceResultReader; +import org.overture.ct.ctruntime.utils.TraceTest; import org.xml.sax.SAXException; public class TraceHandler extends ExecutableSpecTestHandler @@ -69,7 +70,7 @@ public List getMainClassMethods() } @Override - public Object interpretVdm(File intputFile) throws Exception + public ExecutionResult interpretVdm(File intputFile) throws Exception { File vdmTraceResultFile = computeVdmTraceResult(currentInputFile); @@ -83,14 +84,21 @@ public Object interpretVdm(File intputFile) throws Exception } TraceResult t1 = testResult.get(0); - - return t1.tests; + + StringBuilder sb = new StringBuilder(); + + for(TraceTest t : t1.tests) + { + sb.append(t).append('\n'); + } + + return new ExecutionResult(sb.toString(), t1.tests); } @Override - public JavaExecutionResult runJava(File folder) + public ExecutionResult runJava(File folder) { - JavaExecutionResult javaResult = super.runJava(folder); + ExecutionResult javaResult = super.runJava(folder); Object executionResult = javaResult.getExecutionResult(); @@ -98,11 +106,11 @@ public JavaExecutionResult runJava(File folder) { TestAccumulator acc = (TestAccumulator) executionResult; - return new JavaExecutionResult(javaResult.getProcessOutput(), acc.getAllTests()); + return new ExecutionResult(javaResult.getStrRepresentation(), acc.getAllTests()); } else { - return new JavaExecutionResult(javaResult.getProcessOutput(), javaResult.getExecutionResult().toString()); + return new ExecutionResult(javaResult.getStrRepresentation(), javaResult.getExecutionResult().toString()); } } From 37cca9ec10cc37a9939fdd44c11b150fb0931166 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Fri, 30 Jan 2015 13:20:09 +0100 Subject: [PATCH 038/323] Added a new test to exercise generation of traces with a test failure verdict --- .../resources/traces_verdict_specs/DivByZero | 15 ++++++ .../traces_verdict_specs/DivByZero.result | 47 +++++++++++++++++++ 2 files changed, 62 insertions(+) create mode 100644 core/codegen/src/test/resources/traces_verdict_specs/DivByZero create mode 100644 core/codegen/src/test/resources/traces_verdict_specs/DivByZero.result diff --git a/core/codegen/src/test/resources/traces_verdict_specs/DivByZero b/core/codegen/src/test/resources/traces_verdict_specs/DivByZero new file mode 100644 index 0000000000..0c3ffeb6b6 --- /dev/null +++ b/core/codegen/src/test/resources/traces_verdict_specs/DivByZero @@ -0,0 +1,15 @@ +class Entry + +functions + +private f : real -> real +f (x) == 1 / x; + +traces + +T1: +let x in set {-2,-1,0,1,2} +in + f(x); + +end Entry \ No newline at end of file diff --git a/core/codegen/src/test/resources/traces_verdict_specs/DivByZero.result b/core/codegen/src/test/resources/traces_verdict_specs/DivByZero.result new file mode 100644 index 0000000000..8b700854fa --- /dev/null +++ b/core/codegen/src/test/resources/traces_verdict_specs/DivByZero.result @@ -0,0 +1,47 @@ +import org.overture.codegen.runtime.*; +import org.overture.codegen.runtime.traces.*; + +import java.util.*; + + +public class Entry { + public Entry() { + } + + private static Number f(final Number x) { + return Utils.divide(1L, x.doubleValue()); + } + + public String toString() { + return "Entry{}"; + } + + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + SequenceTraceNode sequence_1 = new SequenceTraceNode(); + AlternativeTraceNode alternatives_2 = new AlternativeTraceNode(); + VDMSet set_1 = SetUtil.set(-2L, -1L, 0L, 1L, 2L); + + for (Iterator iterator_1 = set_1.iterator(); iterator_1.hasNext();) { + final Number x = ((Number) iterator_1.next()); + CallStatement callStm_1 = new CallStatement() { + public Object execute(final Object instance) { + return f(x); + } + + public String toString() { + return "f(" + Utils.toString(x) + ")"; + } + }; + + StatementTraceNode apply_1 = new StatementTraceNode(callStm_1); + + alternatives_2.add(apply_1); + } + + sequence_1.add(alternatives_2); + + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator); + } +} + +########## From 8d28a41d6ea3df0a62a725111a9601c0c4afa5f1 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Fri, 30 Jan 2015 15:43:50 +0100 Subject: [PATCH 039/323] Added a trace where some of the tests use invalid subscripts to do lookups in a sequence --- .../traces_verdict_specs/SeqIndexOutOfRange | 18 +++++++ .../SeqIndexOutOfRange.result | 49 +++++++++++++++++++ 2 files changed, 67 insertions(+) create mode 100644 core/codegen/src/test/resources/traces_verdict_specs/SeqIndexOutOfRange create mode 100644 core/codegen/src/test/resources/traces_verdict_specs/SeqIndexOutOfRange.result diff --git a/core/codegen/src/test/resources/traces_verdict_specs/SeqIndexOutOfRange b/core/codegen/src/test/resources/traces_verdict_specs/SeqIndexOutOfRange new file mode 100644 index 0000000000..c60be8c4b5 --- /dev/null +++ b/core/codegen/src/test/resources/traces_verdict_specs/SeqIndexOutOfRange @@ -0,0 +1,18 @@ +class Entry + +functions + +public f : nat -> nat +f (idx) == +let xs = [1, 2] +in + xs(idx); + +traces + +T1: + let a in set {0,1,2,3} + in + f(a); + +end Entry \ No newline at end of file diff --git a/core/codegen/src/test/resources/traces_verdict_specs/SeqIndexOutOfRange.result b/core/codegen/src/test/resources/traces_verdict_specs/SeqIndexOutOfRange.result new file mode 100644 index 0000000000..907f4bc093 --- /dev/null +++ b/core/codegen/src/test/resources/traces_verdict_specs/SeqIndexOutOfRange.result @@ -0,0 +1,49 @@ +import org.overture.codegen.runtime.*; +import org.overture.codegen.runtime.traces.*; + +import java.util.*; + + +public class Entry { + public Entry() { + } + + public static Number f(final Number idx) { + VDMSeq xs = SeqUtil.seq(1L, 2L); + + return ((Number) xs.get(Utils.index(idx))); + } + + public String toString() { + return "Entry{}"; + } + + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + SequenceTraceNode sequence_1 = new SequenceTraceNode(); + AlternativeTraceNode alternatives_2 = new AlternativeTraceNode(); + VDMSet set_1 = SetUtil.set(0L, 1L, 2L, 3L); + + for (Iterator iterator_1 = set_1.iterator(); iterator_1.hasNext();) { + final Number a = ((Number) iterator_1.next()); + CallStatement callStm_1 = new CallStatement() { + public Object execute(final Object instance) { + return f(a); + } + + public String toString() { + return "f(" + Utils.toString(a) + ")"; + } + }; + + StatementTraceNode apply_1 = new StatementTraceNode(callStm_1); + + alternatives_2.add(apply_1); + } + + sequence_1.add(alternatives_2); + + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator); + } +} + +########## From 1122bb1f9f6e67c646ebbf49eaf03e50ea2d4b3a Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Fri, 30 Jan 2015 20:00:40 +0100 Subject: [PATCH 040/323] Added trace where some of the tests do lookups in a map with a non-existing key --- .../traces_verdict_specs/MapNoSuchKey | 18 +++++++ .../traces_verdict_specs/MapNoSuchKey.result | 49 +++++++++++++++++++ 2 files changed, 67 insertions(+) create mode 100644 core/codegen/src/test/resources/traces_verdict_specs/MapNoSuchKey create mode 100644 core/codegen/src/test/resources/traces_verdict_specs/MapNoSuchKey.result diff --git a/core/codegen/src/test/resources/traces_verdict_specs/MapNoSuchKey b/core/codegen/src/test/resources/traces_verdict_specs/MapNoSuchKey new file mode 100644 index 0000000000..71de600f01 --- /dev/null +++ b/core/codegen/src/test/resources/traces_verdict_specs/MapNoSuchKey @@ -0,0 +1,18 @@ +class Entry + +functions + +public f : nat -> char +f (idx) == +let xs = {1 |-> 'a', 2 |-> 'b'} +in + xs(idx); + +traces + +T1: + let a in set {0,1,2,3} + in + f(a); + +end Entry \ No newline at end of file diff --git a/core/codegen/src/test/resources/traces_verdict_specs/MapNoSuchKey.result b/core/codegen/src/test/resources/traces_verdict_specs/MapNoSuchKey.result new file mode 100644 index 0000000000..efa911b21c --- /dev/null +++ b/core/codegen/src/test/resources/traces_verdict_specs/MapNoSuchKey.result @@ -0,0 +1,49 @@ +import org.overture.codegen.runtime.*; +import org.overture.codegen.runtime.traces.*; + +import java.util.*; + + +public class Entry { + public Entry() { + } + + public static Character f(final Number idx) { + VDMMap xs = MapUtil.map(new Maplet(1L, 'a'), new Maplet(2L, 'b')); + + return ((Character) MapUtil.get(xs, idx)); + } + + public String toString() { + return "Entry{}"; + } + + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + SequenceTraceNode sequence_1 = new SequenceTraceNode(); + AlternativeTraceNode alternatives_2 = new AlternativeTraceNode(); + VDMSet set_1 = SetUtil.set(0L, 1L, 2L, 3L); + + for (Iterator iterator_1 = set_1.iterator(); iterator_1.hasNext();) { + final Number a = ((Number) iterator_1.next()); + CallStatement callStm_1 = new CallStatement() { + public Object execute(final Object instance) { + return f(a); + } + + public String toString() { + return "f(" + Utils.toString(a) + ")"; + } + }; + + StatementTraceNode apply_1 = new StatementTraceNode(callStm_1); + + alternatives_2.add(apply_1); + } + + sequence_1.add(alternatives_2); + + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator); + } +} + +########## From c374c7c62e1060417d2e6a071a69370675f536ed Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Fri, 30 Jan 2015 20:12:27 +0100 Subject: [PATCH 041/323] Added a trace test where some of the expanded tests fail due to a let be st without an applicable bind --- .../traces_verdict_specs/LetBeStNoBinding | 22 +++++ .../LetBeStNoBinding.result | 94 +++++++++++++++++++ 2 files changed, 116 insertions(+) create mode 100644 core/codegen/src/test/resources/traces_verdict_specs/LetBeStNoBinding create mode 100644 core/codegen/src/test/resources/traces_verdict_specs/LetBeStNoBinding.result diff --git a/core/codegen/src/test/resources/traces_verdict_specs/LetBeStNoBinding b/core/codegen/src/test/resources/traces_verdict_specs/LetBeStNoBinding new file mode 100644 index 0000000000..d97c05a7bc --- /dev/null +++ b/core/codegen/src/test/resources/traces_verdict_specs/LetBeStNoBinding @@ -0,0 +1,22 @@ +class Entry + +functions + +public f : nat -> nat +f (e) == +let x in set {1,2,3} be st x = e +in + x; + +traces + +T1: + let a = 1 + in + let b = 10 + in + let c = 3 + in + (f(a) | f(b) | f(c)); + +end Entry \ No newline at end of file diff --git a/core/codegen/src/test/resources/traces_verdict_specs/LetBeStNoBinding.result b/core/codegen/src/test/resources/traces_verdict_specs/LetBeStNoBinding.result new file mode 100644 index 0000000000..4e60a92f0b --- /dev/null +++ b/core/codegen/src/test/resources/traces_verdict_specs/LetBeStNoBinding.result @@ -0,0 +1,94 @@ +import org.overture.codegen.runtime.*; +import org.overture.codegen.runtime.traces.*; + +import java.util.*; + + +public class Entry { + public Entry() { + } + + public static Number f(final Number e) { + Number letBeStExp_1 = null; + Number x = null; + Boolean success_1 = false; + VDMSet set_1 = SetUtil.set(1L, 2L, 3L); + + for (Iterator iterator_1 = set_1.iterator(); + iterator_1.hasNext() && !(success_1);) { + x = ((Number) iterator_1.next()); + success_1 = Utils.equals(x, e); + } + + if (!(success_1)) { + throw new RuntimeException("Let Be St found no applicable bindings"); + } + + letBeStExp_1 = x; + + return letBeStExp_1; + } + + public String toString() { + return "Entry{}"; + } + + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + SequenceTraceNode sequence_1 = new SequenceTraceNode(); + final Number a = 1L; + + final Number b = 10L; + + final Number c = 3L; + + SequenceTraceNode sequence_2 = new SequenceTraceNode(); + AlternativeTraceNode alternatives_2 = new AlternativeTraceNode(); + CallStatement callStm_1 = new CallStatement() { + public Object execute(final Object instance) { + return f(a); + } + + public String toString() { + return "f(" + Utils.toString(a) + ")"; + } + }; + + StatementTraceNode apply_1 = new StatementTraceNode(callStm_1); + + CallStatement callStm_2 = new CallStatement() { + public Object execute(final Object instance) { + return f(b); + } + + public String toString() { + return "f(" + Utils.toString(b) + ")"; + } + }; + + StatementTraceNode apply_2 = new StatementTraceNode(callStm_2); + + CallStatement callStm_3 = new CallStatement() { + public Object execute(final Object instance) { + return f(c); + } + + public String toString() { + return "f(" + Utils.toString(c) + ")"; + } + }; + + StatementTraceNode apply_3 = new StatementTraceNode(callStm_3); + + alternatives_2.add(apply_1); + alternatives_2.add(apply_2); + alternatives_2.add(apply_3); + + sequence_2.add(alternatives_2); + + sequence_1.add(sequence_2); + + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator); + } +} + +########## From f6222ad037db11d5fc139f6307a9d6f9f6ed7c9f Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Fri, 30 Jan 2015 20:26:21 +0100 Subject: [PATCH 042/323] Added a trace test where some of the expanded tests fail due to union type errors caught at runtime --- .../traces_verdict_specs/UnionTypeFailure | 20 +++++ .../UnionTypeFailure.result | 77 +++++++++++++++++++ 2 files changed, 97 insertions(+) create mode 100644 core/codegen/src/test/resources/traces_verdict_specs/UnionTypeFailure create mode 100644 core/codegen/src/test/resources/traces_verdict_specs/UnionTypeFailure.result diff --git a/core/codegen/src/test/resources/traces_verdict_specs/UnionTypeFailure b/core/codegen/src/test/resources/traces_verdict_specs/UnionTypeFailure new file mode 100644 index 0000000000..1cc609454b --- /dev/null +++ b/core/codegen/src/test/resources/traces_verdict_specs/UnionTypeFailure @@ -0,0 +1,20 @@ +class Entry + +functions + +public f : nat | char -> nat +f (e) == + 1 + e; + +traces + +T1: + let a = 1 + in + let b = 'x' + in + let c = 3 + in + (f(a) | f(b) | f(c)); + +end Entry \ No newline at end of file diff --git a/core/codegen/src/test/resources/traces_verdict_specs/UnionTypeFailure.result b/core/codegen/src/test/resources/traces_verdict_specs/UnionTypeFailure.result new file mode 100644 index 0000000000..d07136b9e0 --- /dev/null +++ b/core/codegen/src/test/resources/traces_verdict_specs/UnionTypeFailure.result @@ -0,0 +1,77 @@ +import org.overture.codegen.runtime.*; +import org.overture.codegen.runtime.traces.*; + +import java.util.*; + + +public class Entry { + public Entry() { + } + + public static Number f(final Object e) { + return 1L + ((Number) e).longValue(); + } + + public String toString() { + return "Entry{}"; + } + + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + SequenceTraceNode sequence_1 = new SequenceTraceNode(); + final Number a = 1L; + + final Character b = 'x'; + + final Number c = 3L; + + SequenceTraceNode sequence_2 = new SequenceTraceNode(); + AlternativeTraceNode alternatives_2 = new AlternativeTraceNode(); + CallStatement callStm_1 = new CallStatement() { + public Object execute(final Object instance) { + return f(a); + } + + public String toString() { + return "f(" + Utils.toString(a) + ")"; + } + }; + + StatementTraceNode apply_1 = new StatementTraceNode(callStm_1); + + CallStatement callStm_2 = new CallStatement() { + public Object execute(final Object instance) { + return f(b); + } + + public String toString() { + return "f(" + Utils.toString(b) + ")"; + } + }; + + StatementTraceNode apply_2 = new StatementTraceNode(callStm_2); + + CallStatement callStm_3 = new CallStatement() { + public Object execute(final Object instance) { + return f(c); + } + + public String toString() { + return "f(" + Utils.toString(c) + ")"; + } + }; + + StatementTraceNode apply_3 = new StatementTraceNode(callStm_3); + + alternatives_2.add(apply_1); + alternatives_2.add(apply_2); + alternatives_2.add(apply_3); + + sequence_2.add(alternatives_2); + + sequence_1.add(sequence_2); + + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator); + } +} + +########## From d6b7b531cba0d4d49ebb7537bf1aefd8a369b98a Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sat, 31 Jan 2015 14:36:42 +0100 Subject: [PATCH 043/323] Added two trace tests that exercise test filtering --- .../resources/traces_verdict_specs/Filter | 14 +++++ .../traces_verdict_specs/Filter.result | 51 +++++++++++++++ .../traces_verdict_specs/NilRefError | 30 +++++++++ .../traces_verdict_specs/NilRefError.result | 63 +++++++++++++++++++ 4 files changed, 158 insertions(+) create mode 100644 core/codegen/src/test/resources/traces_verdict_specs/Filter create mode 100644 core/codegen/src/test/resources/traces_verdict_specs/Filter.result create mode 100644 core/codegen/src/test/resources/traces_verdict_specs/NilRefError create mode 100644 core/codegen/src/test/resources/traces_verdict_specs/NilRefError.result diff --git a/core/codegen/src/test/resources/traces_verdict_specs/Filter b/core/codegen/src/test/resources/traces_verdict_specs/Filter new file mode 100644 index 0000000000..6a9565fa1c --- /dev/null +++ b/core/codegen/src/test/resources/traces_verdict_specs/Filter @@ -0,0 +1,14 @@ +class Entry + +operations + +public op : () ==> () +op () == skip +pre false; + +traces + +T1: + op(){1,3}; + +end Entry \ No newline at end of file diff --git a/core/codegen/src/test/resources/traces_verdict_specs/Filter.result b/core/codegen/src/test/resources/traces_verdict_specs/Filter.result new file mode 100644 index 0000000000..b4cda4e6a9 --- /dev/null +++ b/core/codegen/src/test/resources/traces_verdict_specs/Filter.result @@ -0,0 +1,51 @@ +import org.overture.codegen.runtime.*; +import org.overture.codegen.runtime.traces.*; + +import java.util.*; + + +public class Entry { + public Entry() { + } + + public void op() { + if (!(pre_op())) { + throw new RuntimeException("Precondition failure: pre_op"); + } + + //Skip; + } + + private Boolean pre_op() { + return false; + } + + public String toString() { + return "Entry{}"; + } + + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + SequenceTraceNode sequence_1 = new SequenceTraceNode(); + CallStatement callStm_1 = new CallStatement() { + public Object execute(final Object instance) { + ((Entry) instance).op(); + + return Utils.VOID_VALUE; + } + + public String toString() { + return "op()"; + } + }; + + StatementTraceNode apply_1 = new StatementTraceNode(callStm_1); + + RepeatTraceNode repeat_1 = new RepeatTraceNode(apply_1, 1L, 3L); + + sequence_1.add(repeat_1); + + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator); + } +} + +########## diff --git a/core/codegen/src/test/resources/traces_verdict_specs/NilRefError b/core/codegen/src/test/resources/traces_verdict_specs/NilRefError new file mode 100644 index 0000000000..361b1a8193 --- /dev/null +++ b/core/codegen/src/test/resources/traces_verdict_specs/NilRefError @@ -0,0 +1,30 @@ +class Entry + +instance variables + +x : nat := 0; + +operations + +public op : () ==> nat +op () == +( + x := x + 1; + + if x = 3 then + ( + let e : [Entry] = nil + in + return e.x; + ); + + return x; +) +pre x < 1; + +traces + +T1: + op(){1,3}; + +end Entry \ No newline at end of file diff --git a/core/codegen/src/test/resources/traces_verdict_specs/NilRefError.result b/core/codegen/src/test/resources/traces_verdict_specs/NilRefError.result new file mode 100644 index 0000000000..a6c0ca3fc4 --- /dev/null +++ b/core/codegen/src/test/resources/traces_verdict_specs/NilRefError.result @@ -0,0 +1,63 @@ +import org.overture.codegen.runtime.*; +import org.overture.codegen.runtime.traces.*; + +import java.util.*; + + +public class Entry { + private Number x = 0L; + + public Entry() { + } + + public Number op() { + if (!(pre_op())) { + throw new RuntimeException("Precondition failure: pre_op"); + } + + x = x.longValue() + 1L; + + if (Utils.equals(x, 3L)) { + { + Entry e = null; + + return e.x; + } + } + + return x; + } + + private Boolean pre_op() { + return x.longValue() < 1L; + } + + public String toString() { + return "Entry{" + "x := " + Utils.toString(x) + "}"; + } + + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + SequenceTraceNode sequence_1 = new SequenceTraceNode(); + CallStatement callStm_1 = new CallStatement() { + public Object execute(final Object instance) { + Number result_1 = ((Entry) instance).op(); + + return result_1; + } + + public String toString() { + return "op()"; + } + }; + + StatementTraceNode apply_1 = new StatementTraceNode(callStm_1); + + RepeatTraceNode repeat_1 = new RepeatTraceNode(apply_1, 1L, 3L); + + sequence_1.add(repeat_1); + + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator); + } +} + +########## From 431b29d46bcda140ca4793ddb0c99b4604802e62 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 4 Feb 2015 11:09:03 +0100 Subject: [PATCH 044/323] Updated existing trace test results in core/codegen A new strategy is used to handle local variables --- .../Alternative1.result | 6 ++++-- .../AlternativeConcurrent1.result | 6 ++++-- .../AlternativeRepeat1.result | 6 ++++-- .../traces_expansion_specs/Concurrent1.result | 6 ++++-- .../traces_expansion_specs/Concurrent2.result | 14 +++++++++---- .../ConcurrentAlternative1.result | 6 ++++-- .../ConcurrentRepeat1.result | 6 ++++-- .../traces_expansion_specs/LetBeSt1.result | 12 ++++++++--- .../traces_expansion_specs/LetDef1.result | 12 ++++++++--- .../traces_expansion_specs/Repeat1.result | 6 ++++-- .../RepeatAlternative1.result | 6 ++++-- .../RepeatConcurrent1.result | 6 ++++-- .../SingleStatement1.result | 6 ++++-- .../traces_verdict_specs/DivByZero.result | 12 ++++++++--- .../traces_verdict_specs/Filter.result | 6 ++++-- .../LetBeStNoBinding.result | 21 ++++++++++++++----- .../traces_verdict_specs/MapNoSuchKey.result | 12 ++++++++--- .../traces_verdict_specs/NilRefError.result | 6 ++++-- .../PreCondViolation.result | 12 ++++++++--- .../SeqIndexOutOfRange.result | 12 ++++++++--- .../UnionTypeFailure.result | 21 ++++++++++++++----- 21 files changed, 144 insertions(+), 56 deletions(-) diff --git a/core/codegen/src/test/resources/traces_expansion_specs/Alternative1.result b/core/codegen/src/test/resources/traces_expansion_specs/Alternative1.result index 6a0e914d88..45c8d313f7 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/Alternative1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/Alternative1.result @@ -4,7 +4,7 @@ import org.overture.codegen.runtime.traces.*; import java.util.*; -public class Entry { +public class Entry implements java.io.Serializable { public Entry() { } @@ -21,6 +21,8 @@ public class Entry { } public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + final Store store = new Store(); + final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); AlternativeTraceNode alternatives_1 = new AlternativeTraceNode(); CallStatement callStm_1 = new CallStatement() { @@ -54,7 +56,7 @@ public class Entry { sequence_1.add(alternatives_1); - TraceNode.executeTests(sequence_1, Entry.class, testAccumulator); + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } } diff --git a/core/codegen/src/test/resources/traces_expansion_specs/AlternativeConcurrent1.result b/core/codegen/src/test/resources/traces_expansion_specs/AlternativeConcurrent1.result index 94a7435f9b..af9f3df7c3 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/AlternativeConcurrent1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/AlternativeConcurrent1.result @@ -4,7 +4,7 @@ import org.overture.codegen.runtime.traces.*; import java.util.*; -public class Entry { +public class Entry implements java.io.Serializable { public Entry() { } @@ -29,6 +29,8 @@ public class Entry { } public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + final Store store = new Store(); + final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); AlternativeTraceNode alternatives_1 = new AlternativeTraceNode(); ConcurrentTraceNode concurrent_1 = new ConcurrentTraceNode(); @@ -96,7 +98,7 @@ public class Entry { sequence_1.add(alternatives_1); - TraceNode.executeTests(sequence_1, Entry.class, testAccumulator); + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } } diff --git a/core/codegen/src/test/resources/traces_expansion_specs/AlternativeRepeat1.result b/core/codegen/src/test/resources/traces_expansion_specs/AlternativeRepeat1.result index b956afc23e..712ff87b75 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/AlternativeRepeat1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/AlternativeRepeat1.result @@ -4,7 +4,7 @@ import org.overture.codegen.runtime.traces.*; import java.util.*; -public class Entry { +public class Entry implements java.io.Serializable { public Entry() { } @@ -21,6 +21,8 @@ public class Entry { } public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + final Store store = new Store(); + final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); SequenceTraceNode sequence_2 = new SequenceTraceNode(); AlternativeTraceNode alternatives_2 = new AlternativeTraceNode(); @@ -61,7 +63,7 @@ public class Entry { sequence_1.add(sequence_2); - TraceNode.executeTests(sequence_1, Entry.class, testAccumulator); + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } } diff --git a/core/codegen/src/test/resources/traces_expansion_specs/Concurrent1.result b/core/codegen/src/test/resources/traces_expansion_specs/Concurrent1.result index 2cf505ef3a..f24ac1c86d 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/Concurrent1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/Concurrent1.result @@ -4,7 +4,7 @@ import org.overture.codegen.runtime.traces.*; import java.util.*; -public class Entry { +public class Entry implements java.io.Serializable { public Entry() { } @@ -25,6 +25,8 @@ public class Entry { } public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + final Store store = new Store(); + final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); ConcurrentTraceNode concurrent_1 = new ConcurrentTraceNode(); CallStatement callStm_1 = new CallStatement() { @@ -75,7 +77,7 @@ public class Entry { sequence_1.add(concurrent_1); - TraceNode.executeTests(sequence_1, Entry.class, testAccumulator); + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } } diff --git a/core/codegen/src/test/resources/traces_expansion_specs/Concurrent2.result b/core/codegen/src/test/resources/traces_expansion_specs/Concurrent2.result index d9a434fd64..31d7712b1c 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/Concurrent2.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/Concurrent2.result @@ -4,7 +4,7 @@ import org.overture.codegen.runtime.traces.*; import java.util.*; -public class Entry { +public class Entry implements java.io.Serializable { public Entry() { } @@ -21,16 +21,22 @@ public class Entry { } public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + final Store store = new Store(); + final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); AlternativeTraceNode alternatives_2 = new AlternativeTraceNode(); VDMSet set_1 = SetUtil.set(1L, 2L, 3L); for (Iterator iterator_1 = set_1.iterator(); iterator_1.hasNext();) { final Number x = ((Number) iterator_1.next()); + final Number ID_1 = gen.inc(); + + store.register(ID_1, x); + ConcurrentTraceNode concurrent_1 = new ConcurrentTraceNode(); CallStatement callStm_1 = new CallStatement() { public Object execute(final Object instance) { - return fun1(x); + return fun1(((Number) store.getValue(ID_1))); } public String toString() { @@ -42,7 +48,7 @@ public class Entry { CallStatement callStm_2 = new CallStatement() { public Object execute(final Object instance) { - return fun2(x); + return fun2(((Number) store.getValue(ID_1))); } public String toString() { @@ -60,7 +66,7 @@ public class Entry { sequence_1.add(alternatives_2); - TraceNode.executeTests(sequence_1, Entry.class, testAccumulator); + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } } diff --git a/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentAlternative1.result b/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentAlternative1.result index 6db75b980e..f35914dc56 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentAlternative1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentAlternative1.result @@ -4,7 +4,7 @@ import org.overture.codegen.runtime.traces.*; import java.util.*; -public class Entry { +public class Entry implements java.io.Serializable { public Entry() { } @@ -29,6 +29,8 @@ public class Entry { } public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + final Store store = new Store(); + final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); ConcurrentTraceNode concurrent_1 = new ConcurrentTraceNode(); SequenceTraceNode sequence_2 = new SequenceTraceNode(); @@ -102,7 +104,7 @@ public class Entry { sequence_1.add(concurrent_1); - TraceNode.executeTests(sequence_1, Entry.class, testAccumulator); + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } } diff --git a/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentRepeat1.result b/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentRepeat1.result index 943760c66e..07237f0cf3 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentRepeat1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentRepeat1.result @@ -4,7 +4,7 @@ import org.overture.codegen.runtime.traces.*; import java.util.*; -public class Entry { +public class Entry implements java.io.Serializable { public Entry() { } @@ -21,6 +21,8 @@ public class Entry { } public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + final Store store = new Store(); + final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); ConcurrentTraceNode concurrent_1 = new ConcurrentTraceNode(); CallStatement callStm_1 = new CallStatement() { @@ -58,7 +60,7 @@ public class Entry { sequence_1.add(concurrent_1); - TraceNode.executeTests(sequence_1, Entry.class, testAccumulator); + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } } diff --git a/core/codegen/src/test/resources/traces_expansion_specs/LetBeSt1.result b/core/codegen/src/test/resources/traces_expansion_specs/LetBeSt1.result index 273d518ea2..201a1f1488 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/LetBeSt1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/LetBeSt1.result @@ -4,7 +4,7 @@ import org.overture.codegen.runtime.traces.*; import java.util.*; -public class Entry { +public class Entry implements java.io.Serializable { public Entry() { } @@ -17,6 +17,8 @@ public class Entry { } public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + final Store store = new Store(); + final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); AlternativeTraceNode alternatives_2 = new AlternativeTraceNode(); VDMSet set_1 = SetUtil.set(1L, 2L, 3L); @@ -28,9 +30,13 @@ public class Entry { continue; } + final Number ID_1 = gen.inc(); + + store.register(ID_1, a); + CallStatement callStm_1 = new CallStatement() { public Object execute(final Object instance) { - return fun(a); + return fun(((Number) store.getValue(ID_1))); } public String toString() { @@ -45,7 +51,7 @@ public class Entry { sequence_1.add(alternatives_2); - TraceNode.executeTests(sequence_1, Entry.class, testAccumulator); + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } } diff --git a/core/codegen/src/test/resources/traces_expansion_specs/LetDef1.result b/core/codegen/src/test/resources/traces_expansion_specs/LetDef1.result index a11fc21204..6a543489d3 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/LetDef1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/LetDef1.result @@ -4,7 +4,7 @@ import org.overture.codegen.runtime.traces.*; import java.util.*; -public class Entry { +public class Entry implements java.io.Serializable { public Entry() { } @@ -17,15 +17,21 @@ public class Entry { } public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + final Store store = new Store(); + final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); AlternativeTraceNode alternatives_2 = new AlternativeTraceNode(); VDMSet set_1 = SetUtil.set(1L, 2L, 3L); for (Iterator iterator_1 = set_1.iterator(); iterator_1.hasNext();) { final Number a = ((Number) iterator_1.next()); + final Number ID_1 = gen.inc(); + + store.register(ID_1, a); + CallStatement callStm_1 = new CallStatement() { public Object execute(final Object instance) { - return fun(a); + return fun(((Number) store.getValue(ID_1))); } public String toString() { @@ -40,7 +46,7 @@ public class Entry { sequence_1.add(alternatives_2); - TraceNode.executeTests(sequence_1, Entry.class, testAccumulator); + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } } diff --git a/core/codegen/src/test/resources/traces_expansion_specs/Repeat1.result b/core/codegen/src/test/resources/traces_expansion_specs/Repeat1.result index cdd1db137c..881a6d6d05 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/Repeat1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/Repeat1.result @@ -4,7 +4,7 @@ import org.overture.codegen.runtime.traces.*; import java.util.*; -public class Entry { +public class Entry implements java.io.Serializable { public Entry() { } @@ -17,6 +17,8 @@ public class Entry { } public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + final Store store = new Store(); + final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); SequenceTraceNode sequence_2 = new SequenceTraceNode(); CallStatement callStm_1 = new CallStatement() { @@ -39,7 +41,7 @@ public class Entry { sequence_1.add(repeat_1); - TraceNode.executeTests(sequence_1, Entry.class, testAccumulator); + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } } diff --git a/core/codegen/src/test/resources/traces_expansion_specs/RepeatAlternative1.result b/core/codegen/src/test/resources/traces_expansion_specs/RepeatAlternative1.result index 6104c76f87..267600f7bd 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/RepeatAlternative1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/RepeatAlternative1.result @@ -4,7 +4,7 @@ import org.overture.codegen.runtime.traces.*; import java.util.*; -public class Entry { +public class Entry implements java.io.Serializable { public Entry() { } @@ -21,6 +21,8 @@ public class Entry { } public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + final Store store = new Store(); + final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); SequenceTraceNode sequence_2 = new SequenceTraceNode(); AlternativeTraceNode alternatives_2 = new AlternativeTraceNode(); @@ -59,7 +61,7 @@ public class Entry { sequence_1.add(repeat_1); - TraceNode.executeTests(sequence_1, Entry.class, testAccumulator); + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } } diff --git a/core/codegen/src/test/resources/traces_expansion_specs/RepeatConcurrent1.result b/core/codegen/src/test/resources/traces_expansion_specs/RepeatConcurrent1.result index fa64cd4fbd..b5493bd891 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/RepeatConcurrent1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/RepeatConcurrent1.result @@ -4,7 +4,7 @@ import org.overture.codegen.runtime.traces.*; import java.util.*; -public class Entry { +public class Entry implements java.io.Serializable { public Entry() { } @@ -21,6 +21,8 @@ public class Entry { } public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + final Store store = new Store(); + final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); SequenceTraceNode sequence_2 = new SequenceTraceNode(); ConcurrentTraceNode concurrent_1 = new ConcurrentTraceNode(); @@ -61,7 +63,7 @@ public class Entry { sequence_1.add(repeat_1); - TraceNode.executeTests(sequence_1, Entry.class, testAccumulator); + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } } diff --git a/core/codegen/src/test/resources/traces_expansion_specs/SingleStatement1.result b/core/codegen/src/test/resources/traces_expansion_specs/SingleStatement1.result index 7f1ea1440e..11ac1932f8 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/SingleStatement1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/SingleStatement1.result @@ -4,7 +4,7 @@ import org.overture.codegen.runtime.traces.*; import java.util.*; -public class Entry { +public class Entry implements java.io.Serializable { public Entry() { } @@ -17,6 +17,8 @@ public class Entry { } public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + final Store store = new Store(); + final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); CallStatement callStm_1 = new CallStatement() { public Object execute(final Object instance) { @@ -34,7 +36,7 @@ public class Entry { sequence_1.add(apply_1); - TraceNode.executeTests(sequence_1, Entry.class, testAccumulator); + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } } diff --git a/core/codegen/src/test/resources/traces_verdict_specs/DivByZero.result b/core/codegen/src/test/resources/traces_verdict_specs/DivByZero.result index 8b700854fa..587ac86dad 100644 --- a/core/codegen/src/test/resources/traces_verdict_specs/DivByZero.result +++ b/core/codegen/src/test/resources/traces_verdict_specs/DivByZero.result @@ -4,7 +4,7 @@ import org.overture.codegen.runtime.traces.*; import java.util.*; -public class Entry { +public class Entry implements java.io.Serializable { public Entry() { } @@ -17,15 +17,21 @@ public class Entry { } public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + final Store store = new Store(); + final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); AlternativeTraceNode alternatives_2 = new AlternativeTraceNode(); VDMSet set_1 = SetUtil.set(-2L, -1L, 0L, 1L, 2L); for (Iterator iterator_1 = set_1.iterator(); iterator_1.hasNext();) { final Number x = ((Number) iterator_1.next()); + final Number ID_1 = gen.inc(); + + store.register(ID_1, x); + CallStatement callStm_1 = new CallStatement() { public Object execute(final Object instance) { - return f(x); + return f(((Number) store.getValue(ID_1))); } public String toString() { @@ -40,7 +46,7 @@ public class Entry { sequence_1.add(alternatives_2); - TraceNode.executeTests(sequence_1, Entry.class, testAccumulator); + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } } diff --git a/core/codegen/src/test/resources/traces_verdict_specs/Filter.result b/core/codegen/src/test/resources/traces_verdict_specs/Filter.result index b4cda4e6a9..f1d6b4af60 100644 --- a/core/codegen/src/test/resources/traces_verdict_specs/Filter.result +++ b/core/codegen/src/test/resources/traces_verdict_specs/Filter.result @@ -4,7 +4,7 @@ import org.overture.codegen.runtime.traces.*; import java.util.*; -public class Entry { +public class Entry implements java.io.Serializable { public Entry() { } @@ -25,6 +25,8 @@ public class Entry { } public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + final Store store = new Store(); + final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); CallStatement callStm_1 = new CallStatement() { public Object execute(final Object instance) { @@ -44,7 +46,7 @@ public class Entry { sequence_1.add(repeat_1); - TraceNode.executeTests(sequence_1, Entry.class, testAccumulator); + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } } diff --git a/core/codegen/src/test/resources/traces_verdict_specs/LetBeStNoBinding.result b/core/codegen/src/test/resources/traces_verdict_specs/LetBeStNoBinding.result index 4e60a92f0b..0234b4b0ac 100644 --- a/core/codegen/src/test/resources/traces_verdict_specs/LetBeStNoBinding.result +++ b/core/codegen/src/test/resources/traces_verdict_specs/LetBeStNoBinding.result @@ -4,7 +4,7 @@ import org.overture.codegen.runtime.traces.*; import java.util.*; -public class Entry { +public class Entry implements java.io.Serializable { public Entry() { } @@ -34,18 +34,29 @@ public class Entry { } public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + final Store store = new Store(); + final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); final Number a = 1L; + final Number ID_1 = gen.inc(); + + store.register(ID_1, a); final Number b = 10L; + final Number ID_2 = gen.inc(); + + store.register(ID_2, b); final Number c = 3L; + final Number ID_3 = gen.inc(); + + store.register(ID_3, c); SequenceTraceNode sequence_2 = new SequenceTraceNode(); AlternativeTraceNode alternatives_2 = new AlternativeTraceNode(); CallStatement callStm_1 = new CallStatement() { public Object execute(final Object instance) { - return f(a); + return f(((Number) store.getValue(ID_1))); } public String toString() { @@ -57,7 +68,7 @@ public class Entry { CallStatement callStm_2 = new CallStatement() { public Object execute(final Object instance) { - return f(b); + return f(((Number) store.getValue(ID_2))); } public String toString() { @@ -69,7 +80,7 @@ public class Entry { CallStatement callStm_3 = new CallStatement() { public Object execute(final Object instance) { - return f(c); + return f(((Number) store.getValue(ID_3))); } public String toString() { @@ -87,7 +98,7 @@ public class Entry { sequence_1.add(sequence_2); - TraceNode.executeTests(sequence_1, Entry.class, testAccumulator); + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } } diff --git a/core/codegen/src/test/resources/traces_verdict_specs/MapNoSuchKey.result b/core/codegen/src/test/resources/traces_verdict_specs/MapNoSuchKey.result index efa911b21c..9da1437a22 100644 --- a/core/codegen/src/test/resources/traces_verdict_specs/MapNoSuchKey.result +++ b/core/codegen/src/test/resources/traces_verdict_specs/MapNoSuchKey.result @@ -4,7 +4,7 @@ import org.overture.codegen.runtime.traces.*; import java.util.*; -public class Entry { +public class Entry implements java.io.Serializable { public Entry() { } @@ -19,15 +19,21 @@ public class Entry { } public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + final Store store = new Store(); + final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); AlternativeTraceNode alternatives_2 = new AlternativeTraceNode(); VDMSet set_1 = SetUtil.set(0L, 1L, 2L, 3L); for (Iterator iterator_1 = set_1.iterator(); iterator_1.hasNext();) { final Number a = ((Number) iterator_1.next()); + final Number ID_1 = gen.inc(); + + store.register(ID_1, a); + CallStatement callStm_1 = new CallStatement() { public Object execute(final Object instance) { - return f(a); + return f(((Number) store.getValue(ID_1))); } public String toString() { @@ -42,7 +48,7 @@ public class Entry { sequence_1.add(alternatives_2); - TraceNode.executeTests(sequence_1, Entry.class, testAccumulator); + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } } diff --git a/core/codegen/src/test/resources/traces_verdict_specs/NilRefError.result b/core/codegen/src/test/resources/traces_verdict_specs/NilRefError.result index a6c0ca3fc4..6e2f08f613 100644 --- a/core/codegen/src/test/resources/traces_verdict_specs/NilRefError.result +++ b/core/codegen/src/test/resources/traces_verdict_specs/NilRefError.result @@ -4,7 +4,7 @@ import org.overture.codegen.runtime.traces.*; import java.util.*; -public class Entry { +public class Entry implements java.io.Serializable { private Number x = 0L; public Entry() { @@ -37,6 +37,8 @@ public class Entry { } public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + final Store store = new Store(); + final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); CallStatement callStm_1 = new CallStatement() { public Object execute(final Object instance) { @@ -56,7 +58,7 @@ public class Entry { sequence_1.add(repeat_1); - TraceNode.executeTests(sequence_1, Entry.class, testAccumulator); + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } } diff --git a/core/codegen/src/test/resources/traces_verdict_specs/PreCondViolation.result b/core/codegen/src/test/resources/traces_verdict_specs/PreCondViolation.result index b4c6c8bb80..bdbad18c64 100644 --- a/core/codegen/src/test/resources/traces_verdict_specs/PreCondViolation.result +++ b/core/codegen/src/test/resources/traces_verdict_specs/PreCondViolation.result @@ -4,7 +4,7 @@ import org.overture.codegen.runtime.traces.*; import java.util.*; -public class Entry { +public class Entry implements java.io.Serializable { public Entry() { } @@ -33,15 +33,21 @@ public class Entry { } public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + final Store store = new Store(); + final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); AlternativeTraceNode alternatives_2 = new AlternativeTraceNode(); VDMSet set_1 = SetUtil.set(1L, 2L, 3L, 4L, 5L); for (Iterator iterator_1 = set_1.iterator(); iterator_1.hasNext();) { final Number x = ((Number) iterator_1.next()); + final Number ID_1 = gen.inc(); + + store.register(ID_1, x); + CallStatement callStm_1 = new CallStatement() { public Object execute(final Object instance) { - ((Entry) instance).op(x); + ((Entry) instance).op(((Number) store.getValue(ID_1))); return Utils.VOID_VALUE; } @@ -58,7 +64,7 @@ public class Entry { sequence_1.add(alternatives_2); - TraceNode.executeTests(sequence_1, Entry.class, testAccumulator); + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } } diff --git a/core/codegen/src/test/resources/traces_verdict_specs/SeqIndexOutOfRange.result b/core/codegen/src/test/resources/traces_verdict_specs/SeqIndexOutOfRange.result index 907f4bc093..8f7b1145c7 100644 --- a/core/codegen/src/test/resources/traces_verdict_specs/SeqIndexOutOfRange.result +++ b/core/codegen/src/test/resources/traces_verdict_specs/SeqIndexOutOfRange.result @@ -4,7 +4,7 @@ import org.overture.codegen.runtime.traces.*; import java.util.*; -public class Entry { +public class Entry implements java.io.Serializable { public Entry() { } @@ -19,15 +19,21 @@ public class Entry { } public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + final Store store = new Store(); + final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); AlternativeTraceNode alternatives_2 = new AlternativeTraceNode(); VDMSet set_1 = SetUtil.set(0L, 1L, 2L, 3L); for (Iterator iterator_1 = set_1.iterator(); iterator_1.hasNext();) { final Number a = ((Number) iterator_1.next()); + final Number ID_1 = gen.inc(); + + store.register(ID_1, a); + CallStatement callStm_1 = new CallStatement() { public Object execute(final Object instance) { - return f(a); + return f(((Number) store.getValue(ID_1))); } public String toString() { @@ -42,7 +48,7 @@ public class Entry { sequence_1.add(alternatives_2); - TraceNode.executeTests(sequence_1, Entry.class, testAccumulator); + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } } diff --git a/core/codegen/src/test/resources/traces_verdict_specs/UnionTypeFailure.result b/core/codegen/src/test/resources/traces_verdict_specs/UnionTypeFailure.result index d07136b9e0..c56ce60764 100644 --- a/core/codegen/src/test/resources/traces_verdict_specs/UnionTypeFailure.result +++ b/core/codegen/src/test/resources/traces_verdict_specs/UnionTypeFailure.result @@ -4,7 +4,7 @@ import org.overture.codegen.runtime.traces.*; import java.util.*; -public class Entry { +public class Entry implements java.io.Serializable { public Entry() { } @@ -17,18 +17,29 @@ public class Entry { } public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + final Store store = new Store(); + final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); final Number a = 1L; + final Number ID_1 = gen.inc(); + + store.register(ID_1, a); final Character b = 'x'; + final Number ID_2 = gen.inc(); + + store.register(ID_2, b); final Number c = 3L; + final Number ID_3 = gen.inc(); + + store.register(ID_3, c); SequenceTraceNode sequence_2 = new SequenceTraceNode(); AlternativeTraceNode alternatives_2 = new AlternativeTraceNode(); CallStatement callStm_1 = new CallStatement() { public Object execute(final Object instance) { - return f(a); + return f(((Number) store.getValue(ID_1))); } public String toString() { @@ -40,7 +51,7 @@ public class Entry { CallStatement callStm_2 = new CallStatement() { public Object execute(final Object instance) { - return f(b); + return f(((Character) store.getValue(ID_2))); } public String toString() { @@ -52,7 +63,7 @@ public class Entry { CallStatement callStm_3 = new CallStatement() { public Object execute(final Object instance) { - return f(c); + return f(((Number) store.getValue(ID_3))); } public String toString() { @@ -70,7 +81,7 @@ public class Entry { sequence_1.add(sequence_2); - TraceNode.executeTests(sequence_1, Entry.class, testAccumulator); + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } } From f3598486080c45dd3aae6ce5a0f74973098834ce Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 4 Feb 2015 11:10:04 +0100 Subject: [PATCH 045/323] Added trace test to exercise code generation of traces with object binds --- .../traces_expansion_specs/ObjectBind | 23 ++++++++ .../traces_expansion_specs/ObjectBind.result | 54 +++++++++++++++++++ 2 files changed, 77 insertions(+) create mode 100644 core/codegen/src/test/resources/traces_expansion_specs/ObjectBind create mode 100644 core/codegen/src/test/resources/traces_expansion_specs/ObjectBind.result diff --git a/core/codegen/src/test/resources/traces_expansion_specs/ObjectBind b/core/codegen/src/test/resources/traces_expansion_specs/ObjectBind new file mode 100644 index 0000000000..f62d16b638 --- /dev/null +++ b/core/codegen/src/test/resources/traces_expansion_specs/ObjectBind @@ -0,0 +1,23 @@ +class Entry + +instance variables + +x : nat := 0; + +operations + +public op : () ==> nat +op () == +( + x := x + 1; + return x; +) + +traces + +T1: +let a = new Entry() +in + a.op(){1,3}; + +end Entry \ No newline at end of file diff --git a/core/codegen/src/test/resources/traces_expansion_specs/ObjectBind.result b/core/codegen/src/test/resources/traces_expansion_specs/ObjectBind.result new file mode 100644 index 0000000000..b05fbea3cc --- /dev/null +++ b/core/codegen/src/test/resources/traces_expansion_specs/ObjectBind.result @@ -0,0 +1,54 @@ +import org.overture.codegen.runtime.*; +import org.overture.codegen.runtime.traces.*; + +import java.util.*; + + +public class Entry implements java.io.Serializable { + private Number x = 0L; + + public Entry() { + } + + public Number op() { + x = x.longValue() + 1L; + + return x; + } + + public String toString() { + return "Entry{" + "x := " + Utils.toString(x) + "}"; + } + + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + final Store store = new Store(); + final IdGenerator gen = new IdGenerator(); + SequenceTraceNode sequence_1 = new SequenceTraceNode(); + final Entry a = new Entry(); + final Number ID_1 = gen.inc(); + + store.register(ID_1, a); + + CallStatement callStm_1 = new CallStatement() { + public Object execute(final Object instance) { + Number result_1 = ((Entry) store.getValue(ID_1)).op(); + + return result_1; + } + + public String toString() { + return "a.op()"; + } + }; + + StatementTraceNode apply_1 = new StatementTraceNode(callStm_1); + + RepeatTraceNode repeat_1 = new RepeatTraceNode(apply_1, 1L, 3L); + + sequence_1.add(repeat_1); + + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); + } +} + +########## From e168917b1681b66e8645ae4c242b8dafa42b9a88 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 4 Feb 2015 11:10:53 +0100 Subject: [PATCH 046/323] Added a trace test where the same test appears twice --- .../traces_verdict_specs/SameTestTwice | 29 ++++++ .../traces_verdict_specs/SameTestTwice.result | 89 +++++++++++++++++++ 2 files changed, 118 insertions(+) create mode 100644 core/codegen/src/test/resources/traces_verdict_specs/SameTestTwice create mode 100644 core/codegen/src/test/resources/traces_verdict_specs/SameTestTwice.result diff --git a/core/codegen/src/test/resources/traces_verdict_specs/SameTestTwice b/core/codegen/src/test/resources/traces_verdict_specs/SameTestTwice new file mode 100644 index 0000000000..a695179a0b --- /dev/null +++ b/core/codegen/src/test/resources/traces_verdict_specs/SameTestTwice @@ -0,0 +1,29 @@ +class Entry + +instance variables + +x : nat; + +operations + +public Entry : nat ==> Entry +Entry (px) == x := px; + +public op : () ==> nat +op () == +( + dcl e : [Entry] := nil; + if x = 4 then + e.op(); -- Null reference error + x := x + 1; + return x; +) + +traces + +T1: +let a = new Entry(3) +in + (a.op(){1,2} | a.op()); + +end Entry \ No newline at end of file diff --git a/core/codegen/src/test/resources/traces_verdict_specs/SameTestTwice.result b/core/codegen/src/test/resources/traces_verdict_specs/SameTestTwice.result new file mode 100644 index 0000000000..15586a0d53 --- /dev/null +++ b/core/codegen/src/test/resources/traces_verdict_specs/SameTestTwice.result @@ -0,0 +1,89 @@ +import org.overture.codegen.runtime.*; +import org.overture.codegen.runtime.traces.*; + +import java.util.*; + + +public class Entry implements java.io.Serializable { + private Number x; + + public Entry(final Number px) { + cg_init_Entry_1(px); + } + + public Entry() { + } + + public void cg_init_Entry_1(final Number px) { + x = px; + } + + public Number op() { + Entry e = null; + + if (Utils.equals(x, 4L)) { + return e.op(); + } + + x = x.longValue() + 1L; + + return x; + } + + public String toString() { + return "Entry{" + "x := " + Utils.toString(x) + "}"; + } + + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + final Store store = new Store(); + final IdGenerator gen = new IdGenerator(); + SequenceTraceNode sequence_1 = new SequenceTraceNode(); + final Entry a = new Entry(3L); + final Number ID_1 = gen.inc(); + + store.register(ID_1, a); + + SequenceTraceNode sequence_2 = new SequenceTraceNode(); + AlternativeTraceNode alternatives_2 = new AlternativeTraceNode(); + CallStatement callStm_1 = new CallStatement() { + public Object execute(final Object instance) { + Number result_1 = ((Entry) store.getValue(ID_1)).op(); + + return result_1; + } + + public String toString() { + return "a.op()"; + } + }; + + StatementTraceNode apply_1 = new StatementTraceNode(callStm_1); + + RepeatTraceNode repeat_1 = new RepeatTraceNode(apply_1, 1L, 2L); + + CallStatement callStm_2 = new CallStatement() { + public Object execute(final Object instance) { + Number result_2 = ((Entry) store.getValue(ID_1)).op(); + + return result_2; + } + + public String toString() { + return "a.op()"; + } + }; + + StatementTraceNode apply_2 = new StatementTraceNode(callStm_2); + + alternatives_2.add(repeat_1); + alternatives_2.add(apply_2); + + sequence_2.add(alternatives_2); + + sequence_1.add(sequence_2); + + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); + } +} + +########## From 1fdf0cbd1ffa94991698d42c209511e375ac6d56 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 4 Feb 2015 11:28:54 +0100 Subject: [PATCH 047/323] Added trace names related to the trace store and id generator --- .../overture/codegen/traces/TraceNames.java | 39 +++++++++++++++++++ 1 file changed, 39 insertions(+) diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/TraceNames.java b/core/codegen/src/main/java/org/overture/codegen/traces/TraceNames.java index 2b66594b42..a400339f19 100644 --- a/core/codegen/src/main/java/org/overture/codegen/traces/TraceNames.java +++ b/core/codegen/src/main/java/org/overture/codegen/traces/TraceNames.java @@ -126,6 +126,45 @@ public String addMethodName() return "add"; } + // Storage related + + public String storeClassName() + { + return "Store"; + } + + public String storeVarName() + { + return "store"; + } + + public String storeRegisterMethodName() + { + return "register"; + } + + // ID Generator related + + public String idGeneratorClassName() + { + return "IdGenerator"; + } + + public String idGeneratorVarName() + { + return "gen"; + } + + public String idConstNamePrefix() + { + return "ID_"; + } + + public String idGeneratorIncrementMethodName() + { + return "inc"; + } + // Utility stuff public String voidValueEnclosingClassName() From 438baef02667cead00dd60cdb579118362ddded7 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 4 Feb 2015 11:30:44 +0100 Subject: [PATCH 048/323] Introduced the notion of a 'trace store' and ID generator into the traces transformation --- .../org/overture/codegen/traces/TracesTransformation.java | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/TracesTransformation.java b/core/codegen/src/main/java/org/overture/codegen/traces/TracesTransformation.java index f3c38a71e0..1cd9c85f4d 100644 --- a/core/codegen/src/main/java/org/overture/codegen/traces/TracesTransformation.java +++ b/core/codegen/src/main/java/org/overture/codegen/traces/TracesTransformation.java @@ -140,6 +140,9 @@ private SStmCG buildTestExecutionStms(AIdentifierVarExpCG nodeVar, executeTestsCall.getArgs().add(typeArg); executeTestsCall.getArgs().add(transAssistant.consIdentifierVar(tracePrefixes.traceMethodParamName(), transAssistant.consClassType(tracePrefixes.testAccumulatorClassName()))); + executeTestsCall.getArgs().add(transAssistant.consIdentifierVar(tracePrefixes.storeVarName(), + transAssistant.consClassType(tracePrefixes.storeClassName()))); + return executeTestsCall; } @@ -154,12 +157,14 @@ private SStmCG consTraceMethodBody(ANamedTraceDeclCG node) TraceNodeData nodeData = stmBuilder.buildFromDeclTerms(node.getTerms()); ABlockStmCG stms = new ABlockStmCG(); + stms.getLocalDefs().add(transAssistant.consClassVarDeclDefaultCtor(tracePrefixes.storeClassName(), tracePrefixes.storeVarName())); + stms.getLocalDefs().add(transAssistant.consClassVarDeclDefaultCtor(tracePrefixes.idGeneratorClassName(), tracePrefixes.idGeneratorVarName())); stms.getStatements().add(nodeData.getStms()); stms.getStatements().add(buildTestExecutionStms(nodeData.getNodeVar(), getClassName(node))); return stms; } - + private String getTraceEnclosingClass(ANamedTraceDeclCG trace) { if (trace != null) From 235cdc09a2ed198c869b70573c3580222d50e1cf Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 4 Feb 2015 11:34:03 +0100 Subject: [PATCH 049/323] Updated formatting of interfaces implemented by a class. When traces are code generated all classes need to be serializable. --- .../overture/codegen/vdm2java/JavaFormat.java | 25 ++++++++++++++++--- 1 file changed, 21 insertions(+), 4 deletions(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaFormat.java b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaFormat.java index 0d88e0aaad..251154136f 100644 --- a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaFormat.java +++ b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaFormat.java @@ -640,18 +640,35 @@ public String formatInterfaces(AClassDeclCG classDecl) { LinkedList interfaces = classDecl.getInterfaces(); - if(interfaces == null || interfaces.isEmpty()) + if(interfaces == null) { return ""; } String implementsClause = "implements"; + String sep = " "; - implementsClause += " " + interfaces.get(0).getName(); + if(interfaces.isEmpty()) + { + if(importTraceSupport(classDecl)) + { + return implementsClause + sep + java.io.Serializable.class.getName(); + } + else + { + return ""; + } + } + + for(int i = 0; i < interfaces.size(); i++) + { + implementsClause += sep + interfaces.get(i).getName(); + sep = ", "; + } - for(int i = 1; i < interfaces.size(); i++) + if(importTraceSupport(classDecl)) { - implementsClause += ", " + interfaces.get(i).getName(); + implementsClause += sep + java.io.Serializable.class.getName(); } return implementsClause; From 1ea40b43ae558a3bc21e3a7a8c1e18881300caa2 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 4 Feb 2015 11:38:48 +0100 Subject: [PATCH 050/323] Updated the transformation assistant with more utility functionality --- .../trans/assistants/TransAssistantCG.java | 94 ++++++++++++------- 1 file changed, 62 insertions(+), 32 deletions(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/assistants/TransAssistantCG.java b/core/codegen/src/main/java/org/overture/codegen/trans/assistants/TransAssistantCG.java index 195d8d6984..fd9dc854b0 100644 --- a/core/codegen/src/main/java/org/overture/codegen/trans/assistants/TransAssistantCG.java +++ b/core/codegen/src/main/java/org/overture/codegen/trans/assistants/TransAssistantCG.java @@ -285,12 +285,12 @@ public AVarDeclCG consDecl(String varName, SExpCG exp) { return consDecl(varName, exp.getType().clone(), exp); } - + public ANullExpCG consNullExp() { ANullExpCG nullExp = new ANullExpCG(); nullExp.setType(new AUnknownTypeCG()); - + return nullExp; } @@ -319,7 +319,7 @@ public AClassTypeCG consClassType(String classTypeName) } public SExpCG consInstanceCall(STypeCG instanceType, String instanceName, - STypeCG returnType, String memberName, SExpCG arg) + STypeCG returnType, String memberName, SExpCG... args) { AIdentifierVarExpCG instance = new AIdentifierVarExpCG(); instance.setType(instanceType.clone()); @@ -337,7 +337,7 @@ public SExpCG consInstanceCall(STypeCG instanceType, String instanceName, instanceCall.setType(returnType.clone()); - if (arg != null) + for (SExpCG arg : args) { methodType.getParams().add(arg.getType().clone()); instanceCall.getArgs().add(arg); @@ -349,9 +349,10 @@ public SExpCG consInstanceCall(STypeCG instanceType, String instanceName, return instanceCall; } - + + // TODO: This actually forces the return type to be 'void'. Maybe generalise? public ACallObjectExpStmCG consInstanceCallStm(STypeCG instanceType, - String instanceName, String memberName, SExpCG arg) + String instanceName, String memberName, SExpCG... args) { AIdentifierVarExpCG instance = new AIdentifierVarExpCG(); instance.setName(instanceName); @@ -361,8 +362,8 @@ public ACallObjectExpStmCG consInstanceCallStm(STypeCG instanceType, call.setType(new AVoidTypeCG()); call.setFieldName(memberName); call.setObj(instance); - - if(arg != null) + + for (SExpCG arg : args) { call.getArgs().add(arg); } @@ -405,27 +406,27 @@ public ALocalPatternAssignmentStmCG consNextElementAssignment( return assignment; } - + public ANewExpCG consDefaultConsCall(String className) { return consDefaultConsCall(consClassType(className)); } - + public ANewExpCG consDefaultConsCall(AClassTypeCG classType) { ANewExpCG initAltNode = new ANewExpCG(); initAltNode.setType(classType.clone()); initAltNode.setName(consTypeNameForClass(classType.getName())); - + return initAltNode; } - + public ATypeNameCG consTypeNameForClass(String classTypeName) { ATypeNameCG typeName = new ATypeNameCG(); typeName.setDefiningClass(null); typeName.setName(classTypeName); - + return typeName; } @@ -434,7 +435,7 @@ public ACastUnaryExpCG consNextElementCall(String iteratorType, { ACastUnaryExpCG cast = new ACastUnaryExpCG(); cast.setType(elementType.clone()); - cast.setExp(consInstanceCall(consClassType(iteratorType), iteratorName, elementType.clone(), nextElementMethod, null)); + cast.setExp(consInstanceCall(consClassType(iteratorType), iteratorName, elementType.clone(), nextElementMethod)); return cast; } @@ -481,7 +482,7 @@ public AIdentifierVarExpCG consSetVar(String setName, SExpCG set) setVar.setType(setType); setVar.setName(setName); setVar.setIsLocal(true); - + return setVar; } @@ -615,7 +616,7 @@ public ACastUnaryExpCG consNextElementCall(String iteratorTypeName, STypeCG elementType = getSeqTypeCloned(seqComp).getSeqOf(); - SExpCG nextCall = consInstanceCall(consClassType(iteratorTypeName), instance, elementType.clone(), member, null); + SExpCG nextCall = consInstanceCall(consClassType(iteratorTypeName), instance, elementType.clone(), member); ACastUnaryExpCG cast = new ACastUnaryExpCG(); cast.setType(elementType.clone()); cast.setExp(nextCall); @@ -639,7 +640,7 @@ public void cleanUpBinding(ASetMultipleBindCG binding) binding.setSet(null); binding.getPatterns().clear(); } - + public AIdentifierVarExpCG consIdentifierVar(String name, STypeCG type) { AIdentifierVarExpCG var = new AIdentifierVarExpCG(); @@ -647,10 +648,10 @@ public AIdentifierVarExpCG consIdentifierVar(String name, STypeCG type) var.setIsLocal(true); var.setType(type); var.setName(name); - + return var; } - + public AApplyExpCG consConditionalCall(AMethodDeclCG node, AMethodDeclCG predMethod) { @@ -659,42 +660,71 @@ public AApplyExpCG consConditionalCall(AMethodDeclCG node, condVar.setName(predMethod.getName()); condVar.setIsLambda(false); condVar.setIsLocal(true); - + AApplyExpCG condCall = new AApplyExpCG(); condCall.setType(new ABoolBasicTypeCG()); condCall.setRoot(condVar); - + LinkedList params = node.getFormalParams(); - - for(AFormalParamLocalParamCG p : params) + + for (AFormalParamLocalParamCG p : params) { SPatternCG paramPattern = p.getPattern(); - - if(!(paramPattern instanceof AIdentifierPatternCG)) + + if (!(paramPattern instanceof AIdentifierPatternCG)) { - Logger.getLog().printErrorln("Expected parameter pattern to be an identifier pattern at this point. Got: " + paramPattern); + Logger.getLog().printErrorln("Expected parameter pattern to be an identifier pattern at this point. Got: " + + paramPattern); return null; } - + AIdentifierPatternCG paramId = (AIdentifierPatternCG) paramPattern; - + AIdentifierVarExpCG paramArg = new AIdentifierVarExpCG(); paramArg.setType(p.getType().clone()); paramArg.setIsLocal(true); paramArg.setIsLambda(false); paramArg.setName(paramId.getName()); - + condCall.getArgs().add(paramArg); } - + return condCall; } - + public AIdentifierPatternCG consIdPattern(String name) { AIdentifierPatternCG idPattern = new AIdentifierPatternCG(); idPattern.setName(name); - + return idPattern; } + + public AVarDeclCG consClassVarDeclDefaultCtor(String className, + String varName) + { + AClassTypeCG classType = consClassType(className); + ANewExpCG init = consDefaultConsCall(className); + + AVarDeclCG classDecl = consDecl(varName, classType, init); + classDecl.setFinal(true); + + return classDecl; + } + + public ABlockStmCG wrap(AVarDeclCG decl) + { + ABlockStmCG block = new ABlockStmCG(); + block.getLocalDefs().add(decl); + + return block; + } + + public ABlockStmCG wrap(SStmCG stm) + { + ABlockStmCG block = new ABlockStmCG(); + block.getStatements().add(stm); + + return block; + } } From d8f26974d65c6c98dc3b8581ab53b9b81aad8e11 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 4 Feb 2015 11:48:06 +0100 Subject: [PATCH 051/323] Updates to the core/codegen test execution system. No need to inject the Serializable interface for a classes that already implements this interface. --- .../utils/ExecutableSpecTestHandler.java | 49 ++++++++++--------- 1 file changed, 26 insertions(+), 23 deletions(-) diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExecutableSpecTestHandler.java b/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExecutableSpecTestHandler.java index 1b000cbdec..c4e0a18ba2 100644 --- a/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExecutableSpecTestHandler.java +++ b/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExecutableSpecTestHandler.java @@ -59,18 +59,16 @@ public void writeGeneratedCode(File parent, File resultFile) for (StringBuffer classCgStr : content) { String className = TestUtils.getJavaModuleName(classCgStr); - - + File out = null; - if(classCgStr.toString().contains("package quotes;")) + if (classCgStr.toString().contains("package quotes;")) { out = new File(parent, "quotes"); - } - else + } else { out = parent; } - + File tempFile = consTempFile(className, out, classCgStr); injectSerializableInterface(classCgStr, className); @@ -82,32 +80,37 @@ public void writeGeneratedCode(File parent, File resultFile) private void injectSerializableInterface(StringBuffer classCgStr, String className) { - //TODO: Improve way that the EvaluatePP interface is handled if (!className.equals(IRConstants.QUOTES_INTERFACE_NAME) - && !className.startsWith(CodeGenBase.INTERFACE_NAME_PREFIX) && !classCgStr.toString().contains(" implements EvaluatePP")) + && !className.startsWith(CodeGenBase.INTERFACE_NAME_PREFIX)) { - int classNameIdx = classCgStr.indexOf(className); + // TODO: Improve way that the EvaluatePP/Serializable interface is handled + String classStr = classCgStr.toString(); + if (!classStr.contains(" implements EvaluatePP") + && !classStr.contains(" implements java.io.Serializable")) + { + int classNameIdx = classCgStr.indexOf(className); - int prv = classCgStr.indexOf("private"); - int pub = classCgStr.indexOf("public"); - int abstr = classCgStr.indexOf("abstract"); + int prv = classCgStr.indexOf("private"); + int pub = classCgStr.indexOf("public"); + int abstr = classCgStr.indexOf("abstract"); - int min = prv >= 0 && prv < pub ? prv : pub; - min = abstr >= 0 && abstr < min ? abstr : min; + int min = prv >= 0 && prv < pub ? prv : pub; + min = abstr >= 0 && abstr < min ? abstr : min; - if (min < 0) - { - min = classNameIdx; - } + if (min < 0) + { + min = classNameIdx; + } - int firstLeftBraceIdx = classCgStr.indexOf("{", classNameIdx); + int firstLeftBraceIdx = classCgStr.indexOf("{", classNameIdx); - String toReplace = classCgStr.substring(min, firstLeftBraceIdx); + String toReplace = classCgStr.substring(min, firstLeftBraceIdx); - String replacement = "import java.io.*;\n\n" + toReplace - + " implements Serializable"; + String replacement = "import java.io.*;\n\n" + toReplace + + " implements Serializable"; - classCgStr.replace(min, firstLeftBraceIdx, replacement); + classCgStr.replace(min, firstLeftBraceIdx, replacement); + } } } From 09e26348d30d82ce8bd40e53c4893852b3edd2b9 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 4 Feb 2015 12:59:01 +0100 Subject: [PATCH 052/323] Reordering of transformations causes changes to the trace related result files It is really only ordering of generated methods - nothing important. --- .../resources/traces_expansion_specs/Alternative1.result | 8 ++++---- .../traces_expansion_specs/AlternativeConcurrent1.result | 8 ++++---- .../traces_expansion_specs/AlternativeRepeat1.result | 8 ++++---- .../resources/traces_expansion_specs/Concurrent1.result | 8 ++++---- .../resources/traces_expansion_specs/Concurrent2.result | 8 ++++---- .../traces_expansion_specs/ConcurrentAlternative1.result | 8 ++++---- .../traces_expansion_specs/ConcurrentRepeat1.result | 8 ++++---- .../test/resources/traces_expansion_specs/LetBeSt1.result | 8 ++++---- .../test/resources/traces_expansion_specs/LetDef1.result | 8 ++++---- .../resources/traces_expansion_specs/ObjectBind.result | 8 ++++---- .../test/resources/traces_expansion_specs/Repeat1.result | 8 ++++---- .../traces_expansion_specs/RepeatAlternative1.result | 8 ++++---- .../traces_expansion_specs/RepeatConcurrent1.result | 8 ++++---- .../traces_expansion_specs/SingleStatement1.result | 8 ++++---- .../test/resources/traces_verdict_specs/DivByZero.result | 8 ++++---- .../src/test/resources/traces_verdict_specs/Filter.result | 8 ++++---- .../traces_verdict_specs/LetBeStNoBinding.result | 8 ++++---- .../resources/traces_verdict_specs/MapNoSuchKey.result | 8 ++++---- .../resources/traces_verdict_specs/NilRefError.result | 8 ++++---- .../traces_verdict_specs/PreCondViolation.result | 8 ++++---- .../resources/traces_verdict_specs/SameTestTwice.result | 8 ++++---- .../traces_verdict_specs/SeqIndexOutOfRange.result | 8 ++++---- .../traces_verdict_specs/UnionTypeFailure.result | 8 ++++---- 23 files changed, 92 insertions(+), 92 deletions(-) diff --git a/core/codegen/src/test/resources/traces_expansion_specs/Alternative1.result b/core/codegen/src/test/resources/traces_expansion_specs/Alternative1.result index 45c8d313f7..9c3cc477b9 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/Alternative1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/Alternative1.result @@ -16,10 +16,6 @@ public class Entry implements java.io.Serializable { return 23L; } - public String toString() { - return "Entry{}"; - } - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); @@ -58,6 +54,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_expansion_specs/AlternativeConcurrent1.result b/core/codegen/src/test/resources/traces_expansion_specs/AlternativeConcurrent1.result index af9f3df7c3..1dff1e20e6 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/AlternativeConcurrent1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/AlternativeConcurrent1.result @@ -24,10 +24,6 @@ public class Entry implements java.io.Serializable { return 1L; } - public String toString() { - return "Entry{}"; - } - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); @@ -100,6 +96,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_expansion_specs/AlternativeRepeat1.result b/core/codegen/src/test/resources/traces_expansion_specs/AlternativeRepeat1.result index 712ff87b75..0bd4693e2a 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/AlternativeRepeat1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/AlternativeRepeat1.result @@ -16,10 +16,6 @@ public class Entry implements java.io.Serializable { return 1L; } - public String toString() { - return "Entry{}"; - } - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); @@ -65,6 +61,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_expansion_specs/Concurrent1.result b/core/codegen/src/test/resources/traces_expansion_specs/Concurrent1.result index f24ac1c86d..bf7b090347 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/Concurrent1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/Concurrent1.result @@ -20,10 +20,6 @@ public class Entry implements java.io.Serializable { //Skip; } - public String toString() { - return "Entry{}"; - } - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); @@ -79,6 +75,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_expansion_specs/Concurrent2.result b/core/codegen/src/test/resources/traces_expansion_specs/Concurrent2.result index 31d7712b1c..543a1d496d 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/Concurrent2.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/Concurrent2.result @@ -16,10 +16,6 @@ public class Entry implements java.io.Serializable { return b; } - public String toString() { - return "Entry{}"; - } - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); @@ -68,6 +64,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentAlternative1.result b/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentAlternative1.result index f35914dc56..a96153012c 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentAlternative1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentAlternative1.result @@ -24,10 +24,6 @@ public class Entry implements java.io.Serializable { return 2L; } - public String toString() { - return "Entry{}"; - } - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); @@ -106,6 +102,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentRepeat1.result b/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentRepeat1.result index 07237f0cf3..0197b06f81 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentRepeat1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentRepeat1.result @@ -16,10 +16,6 @@ public class Entry implements java.io.Serializable { return 1L; } - public String toString() { - return "Entry{}"; - } - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); @@ -62,6 +58,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_expansion_specs/LetBeSt1.result b/core/codegen/src/test/resources/traces_expansion_specs/LetBeSt1.result index 201a1f1488..84eb5292d6 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/LetBeSt1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/LetBeSt1.result @@ -12,10 +12,6 @@ public class Entry implements java.io.Serializable { return a; } - public String toString() { - return "Entry{}"; - } - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); @@ -53,6 +49,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_expansion_specs/LetDef1.result b/core/codegen/src/test/resources/traces_expansion_specs/LetDef1.result index 6a543489d3..00d3fb92d8 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/LetDef1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/LetDef1.result @@ -12,10 +12,6 @@ public class Entry implements java.io.Serializable { return a; } - public String toString() { - return "Entry{}"; - } - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); @@ -48,6 +44,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_expansion_specs/ObjectBind.result b/core/codegen/src/test/resources/traces_expansion_specs/ObjectBind.result index b05fbea3cc..a36d00b3fb 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/ObjectBind.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/ObjectBind.result @@ -16,10 +16,6 @@ public class Entry implements java.io.Serializable { return x; } - public String toString() { - return "Entry{" + "x := " + Utils.toString(x) + "}"; - } - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); @@ -49,6 +45,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{" + "x := " + Utils.toString(x) + "}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_expansion_specs/Repeat1.result b/core/codegen/src/test/resources/traces_expansion_specs/Repeat1.result index 881a6d6d05..fc8c80cf9d 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/Repeat1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/Repeat1.result @@ -12,10 +12,6 @@ public class Entry implements java.io.Serializable { //Skip; } - public String toString() { - return "Entry{}"; - } - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); @@ -43,6 +39,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_expansion_specs/RepeatAlternative1.result b/core/codegen/src/test/resources/traces_expansion_specs/RepeatAlternative1.result index 267600f7bd..52871d15a2 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/RepeatAlternative1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/RepeatAlternative1.result @@ -16,10 +16,6 @@ public class Entry implements java.io.Serializable { return 23L; } - public String toString() { - return "Entry{}"; - } - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); @@ -63,6 +59,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_expansion_specs/RepeatConcurrent1.result b/core/codegen/src/test/resources/traces_expansion_specs/RepeatConcurrent1.result index b5493bd891..e1a850a23a 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/RepeatConcurrent1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/RepeatConcurrent1.result @@ -16,10 +16,6 @@ public class Entry implements java.io.Serializable { //Skip; } - public String toString() { - return "Entry{}"; - } - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); @@ -65,6 +61,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_expansion_specs/SingleStatement1.result b/core/codegen/src/test/resources/traces_expansion_specs/SingleStatement1.result index 11ac1932f8..15180a90db 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/SingleStatement1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/SingleStatement1.result @@ -12,10 +12,6 @@ public class Entry implements java.io.Serializable { //Skip; } - public String toString() { - return "Entry{}"; - } - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); @@ -38,6 +34,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_verdict_specs/DivByZero.result b/core/codegen/src/test/resources/traces_verdict_specs/DivByZero.result index 587ac86dad..eb65076765 100644 --- a/core/codegen/src/test/resources/traces_verdict_specs/DivByZero.result +++ b/core/codegen/src/test/resources/traces_verdict_specs/DivByZero.result @@ -12,10 +12,6 @@ public class Entry implements java.io.Serializable { return Utils.divide(1L, x.doubleValue()); } - public String toString() { - return "Entry{}"; - } - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); @@ -48,6 +44,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_verdict_specs/Filter.result b/core/codegen/src/test/resources/traces_verdict_specs/Filter.result index f1d6b4af60..f69f9c98c6 100644 --- a/core/codegen/src/test/resources/traces_verdict_specs/Filter.result +++ b/core/codegen/src/test/resources/traces_verdict_specs/Filter.result @@ -20,10 +20,6 @@ public class Entry implements java.io.Serializable { return false; } - public String toString() { - return "Entry{}"; - } - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); @@ -48,6 +44,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_verdict_specs/LetBeStNoBinding.result b/core/codegen/src/test/resources/traces_verdict_specs/LetBeStNoBinding.result index 0234b4b0ac..75e5034321 100644 --- a/core/codegen/src/test/resources/traces_verdict_specs/LetBeStNoBinding.result +++ b/core/codegen/src/test/resources/traces_verdict_specs/LetBeStNoBinding.result @@ -29,10 +29,6 @@ public class Entry implements java.io.Serializable { return letBeStExp_1; } - public String toString() { - return "Entry{}"; - } - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); @@ -100,6 +96,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_verdict_specs/MapNoSuchKey.result b/core/codegen/src/test/resources/traces_verdict_specs/MapNoSuchKey.result index 9da1437a22..6fe7e8d590 100644 --- a/core/codegen/src/test/resources/traces_verdict_specs/MapNoSuchKey.result +++ b/core/codegen/src/test/resources/traces_verdict_specs/MapNoSuchKey.result @@ -14,10 +14,6 @@ public class Entry implements java.io.Serializable { return ((Character) MapUtil.get(xs, idx)); } - public String toString() { - return "Entry{}"; - } - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); @@ -50,6 +46,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_verdict_specs/NilRefError.result b/core/codegen/src/test/resources/traces_verdict_specs/NilRefError.result index 6e2f08f613..48296a3262 100644 --- a/core/codegen/src/test/resources/traces_verdict_specs/NilRefError.result +++ b/core/codegen/src/test/resources/traces_verdict_specs/NilRefError.result @@ -32,10 +32,6 @@ public class Entry implements java.io.Serializable { return x.longValue() < 1L; } - public String toString() { - return "Entry{" + "x := " + Utils.toString(x) + "}"; - } - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); @@ -60,6 +56,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{" + "x := " + Utils.toString(x) + "}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_verdict_specs/PreCondViolation.result b/core/codegen/src/test/resources/traces_verdict_specs/PreCondViolation.result index bdbad18c64..2657d13d3f 100644 --- a/core/codegen/src/test/resources/traces_verdict_specs/PreCondViolation.result +++ b/core/codegen/src/test/resources/traces_verdict_specs/PreCondViolation.result @@ -28,10 +28,6 @@ public class Entry implements java.io.Serializable { return andResult_1; } - public String toString() { - return "Entry{}"; - } - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); @@ -66,6 +62,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_verdict_specs/SameTestTwice.result b/core/codegen/src/test/resources/traces_verdict_specs/SameTestTwice.result index 15586a0d53..78728b9384 100644 --- a/core/codegen/src/test/resources/traces_verdict_specs/SameTestTwice.result +++ b/core/codegen/src/test/resources/traces_verdict_specs/SameTestTwice.result @@ -30,10 +30,6 @@ public class Entry implements java.io.Serializable { return x; } - public String toString() { - return "Entry{" + "x := " + Utils.toString(x) + "}"; - } - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); @@ -84,6 +80,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{" + "x := " + Utils.toString(x) + "}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_verdict_specs/SeqIndexOutOfRange.result b/core/codegen/src/test/resources/traces_verdict_specs/SeqIndexOutOfRange.result index 8f7b1145c7..790216ae54 100644 --- a/core/codegen/src/test/resources/traces_verdict_specs/SeqIndexOutOfRange.result +++ b/core/codegen/src/test/resources/traces_verdict_specs/SeqIndexOutOfRange.result @@ -14,10 +14,6 @@ public class Entry implements java.io.Serializable { return ((Number) xs.get(Utils.index(idx))); } - public String toString() { - return "Entry{}"; - } - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); @@ -50,6 +46,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_verdict_specs/UnionTypeFailure.result b/core/codegen/src/test/resources/traces_verdict_specs/UnionTypeFailure.result index c56ce60764..71f5469700 100644 --- a/core/codegen/src/test/resources/traces_verdict_specs/UnionTypeFailure.result +++ b/core/codegen/src/test/resources/traces_verdict_specs/UnionTypeFailure.result @@ -12,10 +12,6 @@ public class Entry implements java.io.Serializable { return 1L + ((Number) e).longValue(); } - public String toString() { - return "Entry{}"; - } - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); @@ -83,6 +79,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{}"; + } } ########## From 4da391f4316b2f1fc8291ab90abbd508c75573d0 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 4 Feb 2015 13:02:52 +0100 Subject: [PATCH 053/323] Fix: The local declarations of a "trace let" were not set correctly --- .../org/overture/codegen/traces/TraceDeclVisitorCG.java | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/TraceDeclVisitorCG.java b/core/codegen/src/main/java/org/overture/codegen/traces/TraceDeclVisitorCG.java index 5d21d80257..01b7d36720 100644 --- a/core/codegen/src/main/java/org/overture/codegen/traces/TraceDeclVisitorCG.java +++ b/core/codegen/src/main/java/org/overture/codegen/traces/TraceDeclVisitorCG.java @@ -1,7 +1,6 @@ package org.overture.codegen.traces; import org.overture.ast.analysis.AnalysisException; -import org.overture.ast.definitions.PDefinition; import org.overture.ast.definitions.traces.AInstanceTraceDefinition; import org.overture.ast.definitions.traces.ALetBeStBindingTraceDefinition; import org.overture.ast.definitions.traces.ALetDefBindingTraceDefinition; @@ -11,7 +10,6 @@ import org.overture.ast.expressions.PExp; import org.overture.ast.patterns.ASetMultipleBind; import org.overture.ast.patterns.PMultipleBind; -import org.overture.codegen.cgast.SDeclCG; import org.overture.codegen.cgast.SExpCG; import org.overture.codegen.cgast.SMultipleBindCG; import org.overture.codegen.cgast.STraceCoreDeclCG; @@ -79,11 +77,7 @@ public STraceDeclCG caseALetDefBindingTraceDefinition( ALetDefBindingTraceDeclCG letDef = new ALetDefBindingTraceDeclCG(); - for(PDefinition def : node.getLocalDefs()) - { - SDeclCG declCg = def.apply(question.getDeclVisitor(),question); - letDef.getLocalDecls().add(declCg); - } + question.getDeclAssistant().setLocalDefs(node.getLocalDefs(), letDef.getLocalDefs(), question); STraceDeclCG bodyCg = body.apply(question.getTraceDeclVisitor(), question); letDef.setBody(bodyCg); From 1c7e90b07bf484c3f924d35758a7a619406fc5ab Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 4 Feb 2015 13:05:00 +0100 Subject: [PATCH 054/323] Cleanup: Removing warnings --- .../overture/codegen/trans/iterator/JavaLanguageIterator.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/iterator/JavaLanguageIterator.java b/core/codegen/src/main/java/org/overture/codegen/trans/iterator/JavaLanguageIterator.java index 16b9b26f2f..d70c3cbc32 100644 --- a/core/codegen/src/main/java/org/overture/codegen/trans/iterator/JavaLanguageIterator.java +++ b/core/codegen/src/main/java/org/overture/codegen/trans/iterator/JavaLanguageIterator.java @@ -70,7 +70,7 @@ public AVarDeclCG getForLoopInit(AIdentifierVarExpCG setVar, String setName = setVar.getName(); AClassTypeCG iteratorType = transformationAssistant.consClassType(ITERATOR_TYPE); STypeCG setType = setVar.getType().clone(); - SExpCG getIteratorCall = transformationAssistant.consInstanceCall(setType, setName, iteratorType.clone(), GET_ITERATOR, null); + SExpCG getIteratorCall = transformationAssistant.consInstanceCall(setType, setName, iteratorType.clone(), GET_ITERATOR); AVarDeclCG iteratorDecl = new AVarDeclCG(); iteratorDecl.setFinal(false); @@ -92,7 +92,7 @@ public SExpCG getForLoopCond(AIdentifierVarExpCG setVar, { AClassTypeCG iteratorType = transformationAssistant.consClassType(ITERATOR_TYPE); - return transformationAssistant.consInstanceCall(iteratorType, iteratorName, new ABoolBasicTypeCG(), HAS_NEXT_ELEMENT_ITERATOR, null); + return transformationAssistant.consInstanceCall(iteratorType, iteratorName, new ABoolBasicTypeCG(), HAS_NEXT_ELEMENT_ITERATOR); } @Override From bf58af9428dbeb8dfaf514f8d4bb95150299d7f8 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 4 Feb 2015 13:06:50 +0100 Subject: [PATCH 055/323] Changed the "trace let" to use var declarations --- core/codegen/src/main/resources/cg.astv2 | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/codegen/src/main/resources/cg.astv2 b/core/codegen/src/main/resources/cg.astv2 index 753d522f83..79e0218c7b 100644 --- a/core/codegen/src/main/resources/cg.astv2 +++ b/core/codegen/src/main/resources/cg.astv2 @@ -530,7 +530,7 @@ externalType {-> package='org.overture.codegen.cgast.utils'} [stExp]:CG.#exp [body]:CG.#traceDecl | {letDefBinding} - [localDecls]:CG.#decl* + [localDefs]:CG.#decl.var*//[localDecls]:CG.#decl* [body]:CG.traceDecl | {repeat} [core]:CG.#traceCoreDecl [from]:java_Long [to]:java_Long ; From 629e95bd156b3ca16e67a3ceca6931759cd09216 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 4 Feb 2015 14:11:42 +0100 Subject: [PATCH 056/323] Updated the trace transformation to detect use of patterns that are not identifier patterns Currently this is not supported. --- .../traces/TraceSupportedAnalysis.java | 60 +++++++++++++++++-- .../codegen/traces/TracesTransformation.java | 14 ++--- 2 files changed, 63 insertions(+), 11 deletions(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/TraceSupportedAnalysis.java b/core/codegen/src/main/java/org/overture/codegen/traces/TraceSupportedAnalysis.java index 62e0defaa4..00ca67208e 100644 --- a/core/codegen/src/main/java/org/overture/codegen/traces/TraceSupportedAnalysis.java +++ b/core/codegen/src/main/java/org/overture/codegen/traces/TraceSupportedAnalysis.java @@ -1,7 +1,11 @@ package org.overture.codegen.traces; +import org.overture.codegen.cgast.INode; +import org.overture.codegen.cgast.SPatternCG; import org.overture.codegen.cgast.analysis.AnalysisException; import org.overture.codegen.cgast.analysis.DepthFirstAnalysisAdaptor; +import org.overture.codegen.cgast.declarations.ANamedTraceDeclCG; +import org.overture.codegen.cgast.patterns.AIdentifierPatternCG; import org.overture.codegen.cgast.statements.ASuperCallStmCG; /** @@ -25,22 +29,70 @@ * generator when it does appear in traces. Therefore, this analysis * will detect this case. * + * Finally, code generation of traces only support the identifier + * pattern among the different types of patterns. This analysis also + * checks that the only type of pattern occurring in a trace is the identifier + * pattern. + * * @author pvj * */ public class TraceSupportedAnalysis extends DepthFirstAnalysisAdaptor { - private boolean usesSuperCall = false; + private ANamedTraceDeclCG trace; + private boolean isUnsupported = false; + private String reason; + + public TraceSupportedAnalysis(ANamedTraceDeclCG trace) + { + this.trace = trace; + } @Override public void caseASuperCallStmCG(ASuperCallStmCG node) throws AnalysisException { - usesSuperCall = true; + if(!isWithinTrace(node)) + { + return; + } + + reason = "The super call statement is not supported in traces, and as a consequence the trace is not generated."; + isUnsupported = true; + } + + @Override + public void defaultInSPatternCG(SPatternCG node) throws AnalysisException + { + if(!isWithinTrace(node)) + { + return; + } + + if(!(node instanceof AIdentifierPatternCG)) + { + reason = "Only identifier patterns are supported in traces, and as a consequence the trace is not generated."; + isUnsupported = true; + } + } + + public void run() throws AnalysisException + { + trace.apply(this); + } + + public String getReason() + { + return reason; + } + + private boolean isWithinTrace(INode node) + { + return node.getAncestor(ANamedTraceDeclCG.class) == trace; } - public boolean usesSuperCall() + public boolean isUnsupported() { - return usesSuperCall; + return isUnsupported; } } diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/TracesTransformation.java b/core/codegen/src/main/java/org/overture/codegen/traces/TracesTransformation.java index 1cd9c85f4d..f58bdb8aed 100644 --- a/core/codegen/src/main/java/org/overture/codegen/traces/TracesTransformation.java +++ b/core/codegen/src/main/java/org/overture/codegen/traces/TracesTransformation.java @@ -58,10 +58,10 @@ public void caseANamedTraceDeclCG(ANamedTraceDeclCG node) return; } - if (!traceIsSupported(node)) + TraceSupportedAnalysis supportedAnalysis = new TraceSupportedAnalysis(node); + if (!traceIsSupported(supportedAnalysis)) { - irInfo.addTransformationWarning(node, "The super call statement is not supported " - + "in traces, and as a consequence the trace is not generated."); + irInfo.addTransformationWarning(node, supportedAnalysis.getReason()); return; } @@ -77,12 +77,12 @@ public void caseANamedTraceDeclCG(ANamedTraceDeclCG node) } } - private boolean traceIsSupported(ANamedTraceDeclCG node) + private boolean traceIsSupported(TraceSupportedAnalysis supportedAnalysis) { - TraceSupportedAnalysis supportedAnalysis = new TraceSupportedAnalysis(); + try { - node.apply(supportedAnalysis); + supportedAnalysis.run(); } catch (AnalysisException e) { Logger.getLog().printErrorln("Could not determine if a trace could be code generated"); @@ -90,7 +90,7 @@ private boolean traceIsSupported(ANamedTraceDeclCG node) return false; } - return !supportedAnalysis.usesSuperCall(); + return !supportedAnalysis.isUnsupported(); } private AMethodDeclCG consTraceMethod(ANamedTraceDeclCG node) From a331962655bbc235c186ee5f310d47b6f93e1ad6 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 4 Feb 2015 14:26:15 +0100 Subject: [PATCH 057/323] Updated the traces statement builder to use store registration and ID generation for variable value lookups --- .../codegen/traces/TraceLetBeStStrategy.java | 21 ++- .../overture/codegen/traces/TraceNames.java | 5 + .../codegen/traces/TraceStmsBuilder.java | 128 ++++++++++++------ 3 files changed, 111 insertions(+), 43 deletions(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/TraceLetBeStStrategy.java b/core/codegen/src/main/java/org/overture/codegen/traces/TraceLetBeStStrategy.java index 53a2ba8e14..88b0586c8a 100644 --- a/core/codegen/src/main/java/org/overture/codegen/traces/TraceLetBeStStrategy.java +++ b/core/codegen/src/main/java/org/overture/codegen/traces/TraceLetBeStStrategy.java @@ -17,6 +17,7 @@ import org.overture.codegen.cgast.statements.ALocalPatternAssignmentStmCG; import org.overture.codegen.cgast.types.SSetTypeCG; import org.overture.codegen.ir.ITempVarGen; +import org.overture.codegen.logging.Logger; import org.overture.codegen.trans.TempVarPrefixes; import org.overture.codegen.trans.assistants.TransAssistantCG; import org.overture.codegen.trans.iterator.ILanguageIterator; @@ -28,15 +29,17 @@ public class TraceLetBeStStrategy extends LetBeStStrategy protected AVarDeclCG altTests; protected AIdentifierPatternCG id; protected TraceNames tracePrefixes; - + protected StoreRegistrationAssistant storeAssistant; + public TraceLetBeStStrategy(TransAssistantCG transformationAssistant, SExpCG suchThat, SSetTypeCG setType, ILanguageIterator langIterator, ITempVarGen tempGen, - TempVarPrefixes varPrefixes, TraceNames tracePrefixes, + TempVarPrefixes varPrefixes, StoreRegistrationAssistant storeAssistant,TraceNames tracePrefixes, AIdentifierPatternCG id, AVarDeclCG altTests, TraceNodeData nodeData) { super(transformationAssistant, suchThat, setType, langIterator, tempGen, varPrefixes); + this.storeAssistant = storeAssistant; this.tracePrefixes = tracePrefixes; this.id = id; this.altTests = altTests; @@ -107,6 +110,20 @@ public List getForLoopStms(AIdentifierVarExpCG setVar, block.getStatements().add(ifStm); } + AVarDeclCG nextElementDecl = decls.get(count - 1); + if(nextElementDecl.getPattern() instanceof AIdentifierPatternCG) + { + AIdentifierPatternCG idToReg = (AIdentifierPatternCG) nextElementDecl.getPattern(); + storeAssistant.appendStoreRegStms(block, setType.getSetOf().clone(), idToReg.getName()); + } + else + { + Logger.getLog().printErrorln("This should not happen. Only identifier patterns " + + "are currently supported in traces (see the TraceSupportedAnalysis class)."); + return null; + } + + block.getStatements().add(nodeData.getStms()); STypeCG instanceType = altTests.getType().clone(); diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/TraceNames.java b/core/codegen/src/main/java/org/overture/codegen/traces/TraceNames.java index a400339f19..427db61fe9 100644 --- a/core/codegen/src/main/java/org/overture/codegen/traces/TraceNames.java +++ b/core/codegen/src/main/java/org/overture/codegen/traces/TraceNames.java @@ -143,6 +143,11 @@ public String storeRegisterMethodName() return "register"; } + public String storeGetValueMethodName() + { + return "getValue"; + } + // ID Generator related public String idGeneratorClassName() diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/TraceStmsBuilder.java b/core/codegen/src/main/java/org/overture/codegen/traces/TraceStmsBuilder.java index d4a31235f4..3fd01057cc 100644 --- a/core/codegen/src/main/java/org/overture/codegen/traces/TraceStmsBuilder.java +++ b/core/codegen/src/main/java/org/overture/codegen/traces/TraceStmsBuilder.java @@ -2,9 +2,11 @@ import java.util.LinkedList; import java.util.List; +import java.util.Map; +import java.util.Set; +import org.apache.commons.collections4.map.HashedMap; import org.overture.codegen.cgast.INode; -import org.overture.codegen.cgast.SDeclCG; import org.overture.codegen.cgast.SExpCG; import org.overture.codegen.cgast.SObjectDesignatorCG; import org.overture.codegen.cgast.SPatternCG; @@ -13,8 +15,8 @@ import org.overture.codegen.cgast.STypeCG; import org.overture.codegen.cgast.analysis.AnalysisException; import org.overture.codegen.cgast.analysis.AnswerAdaptor; +import org.overture.codegen.cgast.analysis.DepthFirstAnalysisAdaptor; import org.overture.codegen.cgast.declarations.AClassDeclCG; -import org.overture.codegen.cgast.declarations.AFieldDeclCG; import org.overture.codegen.cgast.declarations.AFormalParamLocalParamCG; import org.overture.codegen.cgast.declarations.AMethodDeclCG; import org.overture.codegen.cgast.declarations.AVarDeclCG; @@ -48,6 +50,7 @@ import org.overture.codegen.cgast.types.AClassTypeCG; import org.overture.codegen.cgast.types.AExternalTypeCG; import org.overture.codegen.cgast.types.AMethodTypeCG; +import org.overture.codegen.cgast.types.ANatNumericBasicTypeCG; import org.overture.codegen.cgast.types.AObjectTypeCG; import org.overture.codegen.cgast.types.AVoidTypeCG; import org.overture.codegen.cgast.types.SSetTypeCG; @@ -72,6 +75,10 @@ public class TraceStmsBuilder extends AnswerAdaptor private TraceNames tracePrefixes; private String traceEnclosingClass; + private StoreRegistrationAssistant storeAssistant; + + private Map idConstNameMap; + public TraceStmsBuilder(IRInfo info, List classes, TransAssistantCG transAssistant, TempVarPrefixes varPrefixes, TraceNames tracePrefixes, ILanguageIterator langIterator, @@ -87,6 +94,10 @@ public TraceStmsBuilder(IRInfo info, List classes, this.tracePrefixes = tracePrefixes; this.traceEnclosingClass = traceEnclosingClass; + + this.idConstNameMap = new HashedMap(); + + this.storeAssistant = new StoreRegistrationAssistant(info, tracePrefixes, idConstNameMap, transAssistant); } @Override @@ -192,6 +203,19 @@ public TraceNodeData caseAConcurrentExpTraceCoreDeclCG( public TraceNodeData caseALetBeStBindingTraceDeclCG( ALetBeStBindingTraceDeclCG node) throws AnalysisException { + + ASetMultipleBindCG bind = node.getBind(); + LinkedList patterns = bind.getPatterns(); + + for(SPatternCG p : patterns) + { + if(p instanceof AIdentifierPatternCG) + { + String idConstName = info.getTempVarNameGen().nextVarName(tracePrefixes.idConstNamePrefix()); + idConstNameMap.put(((AIdentifierPatternCG) p).getName(), idConstName); + } + } + String name = info.getTempVarNameGen().nextVarName(tracePrefixes.altTraceNodeNamePrefix()); AClassTypeCG classType = transAssistant.consClassType(tracePrefixes.altTraceNodeNodeClassName()); @@ -200,48 +224,47 @@ public TraceNodeData caseALetBeStBindingTraceDeclCG( AVarDeclCG altTests = transAssistant.consDecl(name, classType, transAssistant.consDefaultConsCall(classType)); - ASetMultipleBindCG bind = node.getBind(); STraceDeclCG body = node.getBody(); SExpCG exp = node.getStExp(); TraceNodeData bodyTraceData = body.apply(this); SSetTypeCG setType = transAssistant.getSetTypeCloned(bind.getSet()); - TraceLetBeStStrategy strategy = new TraceLetBeStStrategy(transAssistant, exp, setType, langIterator, info.getTempVarNameGen(), varPrefixes, tracePrefixes, id, altTests, bodyTraceData); + TraceLetBeStStrategy strategy = new TraceLetBeStStrategy(transAssistant, exp, setType, langIterator, + info.getTempVarNameGen(), varPrefixes, storeAssistant, tracePrefixes, id, altTests, bodyTraceData); if (transAssistant.hasEmptySet(bind)) { transAssistant.cleanUpBinding(bind); - return new TraceNodeData(null, wrap(new ASkipStmCG())); + return new TraceNodeData(null, transAssistant.wrap(new ASkipStmCG())); } - LinkedList patterns = bind.getPatterns(); ABlockStmCG outerBlock = transAssistant.consIterationBlock(patterns, bind.getSet(), info.getTempVarNameGen(), strategy); - return new TraceNodeData(transAssistant.consIdentifierVar(name, classType.clone()), wrap(outerBlock)); + return new TraceNodeData(transAssistant.consIdentifierVar(name, classType.clone()), transAssistant.wrap(outerBlock)); } - + @Override public TraceNodeData caseALetDefBindingTraceDeclCG( ALetDefBindingTraceDeclCG node) throws AnalysisException { ABlockStmCG declBlock = new ABlockStmCG(); - for (SDeclCG dec : node.getLocalDecls()) + for (AVarDeclCG dec : node.getLocalDefs()) { - if (dec instanceof AFieldDeclCG) + dec.setFinal(true); + declBlock.getLocalDefs().add(dec); + + if (dec.getPattern() instanceof AIdentifierPatternCG) { - AFieldDeclCG field = (AFieldDeclCG) dec; - - AVarDeclCG varDecl = transAssistant.consDecl(field.getName(), field.getType().clone(), field.getInitial().clone()); - varDecl.setFinal(true); - declBlock.getLocalDefs().add(varDecl); - } else + storeAssistant.appendStoreRegStms(declBlock, dec.getType().clone(), ((AIdentifierPatternCG) dec.getPattern()).getName()); + } + else { - Logger.getLog().printErrorln("Expected field declarations when processing the let def binding in a trace definition. Got: " - + node); + Logger.getLog().printErrorln("This should not happen. Only identifier patterns " + + "are currently supported in traces (see the TraceSupportedAnalysis class)."); + return null; } - } TraceNodeData bodyNodeData = node.getBody().apply(this); @@ -328,12 +351,51 @@ private AMethodDeclCG consExecuteMethod(SStmCG stm) execMethod.setAbstract(false); execMethod.setAccess(IRConstants.PUBLIC); execMethod.setAsync(false); - execMethod.setBody(makeInstanceCall(stm)); execMethod.setIsConstructor(false); execMethod.setMethodType(methodType); execMethod.setName(tracePrefixes.callStmMethodNamePrefix()); execMethod.setStatic(false); + SStmCG body = makeInstanceCall(stm); + try + { + final Set localVarNames = this.idConstNameMap.keySet(); + + body.apply(new DepthFirstAnalysisAdaptor() + { + // No need to consider explicit variables because they cannot be local + + @Override + public void caseAIdentifierVarExpCG(AIdentifierVarExpCG node) + throws AnalysisException + { + if(localVarNames.contains(node.getName())) + { + AClassTypeCG storeType = transAssistant.consClassType(tracePrefixes.storeClassName()); + + AIdentifierVarExpCG idArg = transAssistant.consIdentifierVar(idConstNameMap.get(node.getName()), + new ANatNumericBasicTypeCG()); + + SExpCG call = transAssistant.consInstanceCall(storeType, tracePrefixes.storeVarName(), + node.getType(), tracePrefixes.storeGetValueMethodName(), idArg); + + ACastUnaryExpCG cast = new ACastUnaryExpCG(); + cast.setType(node.getType().clone()); + cast.setExp(call); + + + transAssistant.replaceNodeWith(node, cast); + } + } + }); + + } catch (AnalysisException e) + { + Logger.getLog().printErrorln("Problem replacing variable expressions with storage lookups in TraceStmBuilder"); + return null; + } + execMethod.setBody(body); + AFormalParamLocalParamCG instanceParam = new AFormalParamLocalParamCG(); instanceParam.setType(new AObjectTypeCG()); instanceParam.setPattern(transAssistant.consIdPattern(tracePrefixes.callStmMethodParamName())); @@ -377,9 +439,9 @@ private SStmCG makeInstanceCall(SStmCG stm) if (stm instanceof ACallObjectStmCG) { // Assume the class enclosing the trace to be S - // self.op(42) becomes ((S)instance).op(42) - // a.op(42) remains a.op(42) if a is local - // a.op(42) becomes ((S)instance).a.op(42) if a is an instance variable + // self.op(42) becomes ((S)instance).op(42L) + // a.op(42) remains a.op(42L) if a is local + // a.op(42) becomes ((S)instance).a.op(42L) if a is an instance variable ACallObjectStmCG callObj = (ACallObjectStmCG) stm; ensureLocalObjDesignator(callObj.getDesignator()); @@ -400,7 +462,7 @@ private SStmCG makeInstanceCall(SStmCG stm) } else if (stm instanceof APlainCallStmCG) { // Assume the class enclosing the trace to be S - // Example: op(42) becomes ((S)instance).op(42) + // Example: op(42) becomes ((S)instance).op(42L) try { return handlePlainCallStm((APlainCallStmCG) stm); @@ -577,23 +639,7 @@ private ABlockStmCG consDecl(String classTypeName, String varName, newExp.getArgs().add(arg); } - return wrap(transAssistant.consDecl(varName, classType.clone(), newExp)); - } - - public ABlockStmCG wrap(AVarDeclCG decl) - { - ABlockStmCG block = new ABlockStmCG(); - block.getLocalDefs().add(decl); - - return block; - } - - public ABlockStmCG wrap(SStmCG stm) - { - ABlockStmCG block = new ABlockStmCG(); - block.getStatements().add(stm); - - return block; + return transAssistant.wrap(transAssistant.consDecl(varName, classType.clone(), newExp)); } @Override From a952214eef165ba4cb63a544a26cac7c220e3fc2 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 4 Feb 2015 14:35:36 +0100 Subject: [PATCH 058/323] Updates to trace related test results due to reordering of transformations --- .../resources/traces_expansion_specs/Alternative1.result | 8 ++++---- .../traces_expansion_specs/AlternativeConcurrent1.result | 8 ++++---- .../traces_expansion_specs/AlternativeRepeat1.result | 8 ++++---- .../resources/traces_expansion_specs/Concurrent1.result | 8 ++++---- .../resources/traces_expansion_specs/Concurrent2.result | 8 ++++---- .../traces_expansion_specs/ConcurrentAlternative1.result | 8 ++++---- .../traces_expansion_specs/ConcurrentRepeat1.result | 8 ++++---- .../test/resources/traces_expansion_specs/LetBeSt1.result | 8 ++++---- .../test/resources/traces_expansion_specs/LetDef1.result | 8 ++++---- .../resources/traces_expansion_specs/ObjectBind.result | 8 ++++---- .../test/resources/traces_expansion_specs/Repeat1.result | 8 ++++---- .../traces_expansion_specs/RepeatAlternative1.result | 8 ++++---- .../traces_expansion_specs/RepeatConcurrent1.result | 8 ++++---- .../traces_expansion_specs/SingleStatement1.result | 8 ++++---- .../test/resources/traces_verdict_specs/DivByZero.result | 8 ++++---- .../src/test/resources/traces_verdict_specs/Filter.result | 8 ++++---- .../traces_verdict_specs/LetBeStNoBinding.result | 8 ++++---- .../resources/traces_verdict_specs/MapNoSuchKey.result | 8 ++++---- .../resources/traces_verdict_specs/NilRefError.result | 8 ++++---- .../traces_verdict_specs/PreCondViolation.result | 8 ++++---- .../resources/traces_verdict_specs/SameTestTwice.result | 8 ++++---- .../traces_verdict_specs/SeqIndexOutOfRange.result | 8 ++++---- .../traces_verdict_specs/UnionTypeFailure.result | 8 ++++---- 23 files changed, 92 insertions(+), 92 deletions(-) diff --git a/core/codegen/src/test/resources/traces_expansion_specs/Alternative1.result b/core/codegen/src/test/resources/traces_expansion_specs/Alternative1.result index 9c3cc477b9..45c8d313f7 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/Alternative1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/Alternative1.result @@ -16,6 +16,10 @@ public class Entry implements java.io.Serializable { return 23L; } + public String toString() { + return "Entry{}"; + } + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); @@ -54,10 +58,6 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } - - public String toString() { - return "Entry{}"; - } } ########## diff --git a/core/codegen/src/test/resources/traces_expansion_specs/AlternativeConcurrent1.result b/core/codegen/src/test/resources/traces_expansion_specs/AlternativeConcurrent1.result index 1dff1e20e6..af9f3df7c3 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/AlternativeConcurrent1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/AlternativeConcurrent1.result @@ -24,6 +24,10 @@ public class Entry implements java.io.Serializable { return 1L; } + public String toString() { + return "Entry{}"; + } + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); @@ -96,10 +100,6 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } - - public String toString() { - return "Entry{}"; - } } ########## diff --git a/core/codegen/src/test/resources/traces_expansion_specs/AlternativeRepeat1.result b/core/codegen/src/test/resources/traces_expansion_specs/AlternativeRepeat1.result index 0bd4693e2a..712ff87b75 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/AlternativeRepeat1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/AlternativeRepeat1.result @@ -16,6 +16,10 @@ public class Entry implements java.io.Serializable { return 1L; } + public String toString() { + return "Entry{}"; + } + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); @@ -61,10 +65,6 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } - - public String toString() { - return "Entry{}"; - } } ########## diff --git a/core/codegen/src/test/resources/traces_expansion_specs/Concurrent1.result b/core/codegen/src/test/resources/traces_expansion_specs/Concurrent1.result index bf7b090347..f24ac1c86d 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/Concurrent1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/Concurrent1.result @@ -20,6 +20,10 @@ public class Entry implements java.io.Serializable { //Skip; } + public String toString() { + return "Entry{}"; + } + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); @@ -75,10 +79,6 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } - - public String toString() { - return "Entry{}"; - } } ########## diff --git a/core/codegen/src/test/resources/traces_expansion_specs/Concurrent2.result b/core/codegen/src/test/resources/traces_expansion_specs/Concurrent2.result index 543a1d496d..31d7712b1c 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/Concurrent2.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/Concurrent2.result @@ -16,6 +16,10 @@ public class Entry implements java.io.Serializable { return b; } + public String toString() { + return "Entry{}"; + } + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); @@ -64,10 +68,6 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } - - public String toString() { - return "Entry{}"; - } } ########## diff --git a/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentAlternative1.result b/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentAlternative1.result index a96153012c..f35914dc56 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentAlternative1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentAlternative1.result @@ -24,6 +24,10 @@ public class Entry implements java.io.Serializable { return 2L; } + public String toString() { + return "Entry{}"; + } + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); @@ -102,10 +106,6 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } - - public String toString() { - return "Entry{}"; - } } ########## diff --git a/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentRepeat1.result b/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentRepeat1.result index 0197b06f81..07237f0cf3 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentRepeat1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentRepeat1.result @@ -16,6 +16,10 @@ public class Entry implements java.io.Serializable { return 1L; } + public String toString() { + return "Entry{}"; + } + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); @@ -58,10 +62,6 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } - - public String toString() { - return "Entry{}"; - } } ########## diff --git a/core/codegen/src/test/resources/traces_expansion_specs/LetBeSt1.result b/core/codegen/src/test/resources/traces_expansion_specs/LetBeSt1.result index 84eb5292d6..201a1f1488 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/LetBeSt1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/LetBeSt1.result @@ -12,6 +12,10 @@ public class Entry implements java.io.Serializable { return a; } + public String toString() { + return "Entry{}"; + } + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); @@ -49,10 +53,6 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } - - public String toString() { - return "Entry{}"; - } } ########## diff --git a/core/codegen/src/test/resources/traces_expansion_specs/LetDef1.result b/core/codegen/src/test/resources/traces_expansion_specs/LetDef1.result index 00d3fb92d8..6a543489d3 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/LetDef1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/LetDef1.result @@ -12,6 +12,10 @@ public class Entry implements java.io.Serializable { return a; } + public String toString() { + return "Entry{}"; + } + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); @@ -44,10 +48,6 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } - - public String toString() { - return "Entry{}"; - } } ########## diff --git a/core/codegen/src/test/resources/traces_expansion_specs/ObjectBind.result b/core/codegen/src/test/resources/traces_expansion_specs/ObjectBind.result index a36d00b3fb..b05fbea3cc 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/ObjectBind.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/ObjectBind.result @@ -16,6 +16,10 @@ public class Entry implements java.io.Serializable { return x; } + public String toString() { + return "Entry{" + "x := " + Utils.toString(x) + "}"; + } + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); @@ -45,10 +49,6 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } - - public String toString() { - return "Entry{" + "x := " + Utils.toString(x) + "}"; - } } ########## diff --git a/core/codegen/src/test/resources/traces_expansion_specs/Repeat1.result b/core/codegen/src/test/resources/traces_expansion_specs/Repeat1.result index fc8c80cf9d..881a6d6d05 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/Repeat1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/Repeat1.result @@ -12,6 +12,10 @@ public class Entry implements java.io.Serializable { //Skip; } + public String toString() { + return "Entry{}"; + } + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); @@ -39,10 +43,6 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } - - public String toString() { - return "Entry{}"; - } } ########## diff --git a/core/codegen/src/test/resources/traces_expansion_specs/RepeatAlternative1.result b/core/codegen/src/test/resources/traces_expansion_specs/RepeatAlternative1.result index 52871d15a2..267600f7bd 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/RepeatAlternative1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/RepeatAlternative1.result @@ -16,6 +16,10 @@ public class Entry implements java.io.Serializable { return 23L; } + public String toString() { + return "Entry{}"; + } + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); @@ -59,10 +63,6 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } - - public String toString() { - return "Entry{}"; - } } ########## diff --git a/core/codegen/src/test/resources/traces_expansion_specs/RepeatConcurrent1.result b/core/codegen/src/test/resources/traces_expansion_specs/RepeatConcurrent1.result index e1a850a23a..b5493bd891 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/RepeatConcurrent1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/RepeatConcurrent1.result @@ -16,6 +16,10 @@ public class Entry implements java.io.Serializable { //Skip; } + public String toString() { + return "Entry{}"; + } + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); @@ -61,10 +65,6 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } - - public String toString() { - return "Entry{}"; - } } ########## diff --git a/core/codegen/src/test/resources/traces_expansion_specs/SingleStatement1.result b/core/codegen/src/test/resources/traces_expansion_specs/SingleStatement1.result index 15180a90db..11ac1932f8 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/SingleStatement1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/SingleStatement1.result @@ -12,6 +12,10 @@ public class Entry implements java.io.Serializable { //Skip; } + public String toString() { + return "Entry{}"; + } + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); @@ -34,10 +38,6 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } - - public String toString() { - return "Entry{}"; - } } ########## diff --git a/core/codegen/src/test/resources/traces_verdict_specs/DivByZero.result b/core/codegen/src/test/resources/traces_verdict_specs/DivByZero.result index eb65076765..587ac86dad 100644 --- a/core/codegen/src/test/resources/traces_verdict_specs/DivByZero.result +++ b/core/codegen/src/test/resources/traces_verdict_specs/DivByZero.result @@ -12,6 +12,10 @@ public class Entry implements java.io.Serializable { return Utils.divide(1L, x.doubleValue()); } + public String toString() { + return "Entry{}"; + } + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); @@ -44,10 +48,6 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } - - public String toString() { - return "Entry{}"; - } } ########## diff --git a/core/codegen/src/test/resources/traces_verdict_specs/Filter.result b/core/codegen/src/test/resources/traces_verdict_specs/Filter.result index f69f9c98c6..f1d6b4af60 100644 --- a/core/codegen/src/test/resources/traces_verdict_specs/Filter.result +++ b/core/codegen/src/test/resources/traces_verdict_specs/Filter.result @@ -20,6 +20,10 @@ public class Entry implements java.io.Serializable { return false; } + public String toString() { + return "Entry{}"; + } + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); @@ -44,10 +48,6 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } - - public String toString() { - return "Entry{}"; - } } ########## diff --git a/core/codegen/src/test/resources/traces_verdict_specs/LetBeStNoBinding.result b/core/codegen/src/test/resources/traces_verdict_specs/LetBeStNoBinding.result index 75e5034321..0234b4b0ac 100644 --- a/core/codegen/src/test/resources/traces_verdict_specs/LetBeStNoBinding.result +++ b/core/codegen/src/test/resources/traces_verdict_specs/LetBeStNoBinding.result @@ -29,6 +29,10 @@ public class Entry implements java.io.Serializable { return letBeStExp_1; } + public String toString() { + return "Entry{}"; + } + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); @@ -96,10 +100,6 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } - - public String toString() { - return "Entry{}"; - } } ########## diff --git a/core/codegen/src/test/resources/traces_verdict_specs/MapNoSuchKey.result b/core/codegen/src/test/resources/traces_verdict_specs/MapNoSuchKey.result index 6fe7e8d590..9da1437a22 100644 --- a/core/codegen/src/test/resources/traces_verdict_specs/MapNoSuchKey.result +++ b/core/codegen/src/test/resources/traces_verdict_specs/MapNoSuchKey.result @@ -14,6 +14,10 @@ public class Entry implements java.io.Serializable { return ((Character) MapUtil.get(xs, idx)); } + public String toString() { + return "Entry{}"; + } + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); @@ -46,10 +50,6 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } - - public String toString() { - return "Entry{}"; - } } ########## diff --git a/core/codegen/src/test/resources/traces_verdict_specs/NilRefError.result b/core/codegen/src/test/resources/traces_verdict_specs/NilRefError.result index 48296a3262..6e2f08f613 100644 --- a/core/codegen/src/test/resources/traces_verdict_specs/NilRefError.result +++ b/core/codegen/src/test/resources/traces_verdict_specs/NilRefError.result @@ -32,6 +32,10 @@ public class Entry implements java.io.Serializable { return x.longValue() < 1L; } + public String toString() { + return "Entry{" + "x := " + Utils.toString(x) + "}"; + } + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); @@ -56,10 +60,6 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } - - public String toString() { - return "Entry{" + "x := " + Utils.toString(x) + "}"; - } } ########## diff --git a/core/codegen/src/test/resources/traces_verdict_specs/PreCondViolation.result b/core/codegen/src/test/resources/traces_verdict_specs/PreCondViolation.result index 2657d13d3f..bdbad18c64 100644 --- a/core/codegen/src/test/resources/traces_verdict_specs/PreCondViolation.result +++ b/core/codegen/src/test/resources/traces_verdict_specs/PreCondViolation.result @@ -28,6 +28,10 @@ public class Entry implements java.io.Serializable { return andResult_1; } + public String toString() { + return "Entry{}"; + } + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); @@ -62,10 +66,6 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } - - public String toString() { - return "Entry{}"; - } } ########## diff --git a/core/codegen/src/test/resources/traces_verdict_specs/SameTestTwice.result b/core/codegen/src/test/resources/traces_verdict_specs/SameTestTwice.result index 78728b9384..15586a0d53 100644 --- a/core/codegen/src/test/resources/traces_verdict_specs/SameTestTwice.result +++ b/core/codegen/src/test/resources/traces_verdict_specs/SameTestTwice.result @@ -30,6 +30,10 @@ public class Entry implements java.io.Serializable { return x; } + public String toString() { + return "Entry{" + "x := " + Utils.toString(x) + "}"; + } + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); @@ -80,10 +84,6 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } - - public String toString() { - return "Entry{" + "x := " + Utils.toString(x) + "}"; - } } ########## diff --git a/core/codegen/src/test/resources/traces_verdict_specs/SeqIndexOutOfRange.result b/core/codegen/src/test/resources/traces_verdict_specs/SeqIndexOutOfRange.result index 790216ae54..8f7b1145c7 100644 --- a/core/codegen/src/test/resources/traces_verdict_specs/SeqIndexOutOfRange.result +++ b/core/codegen/src/test/resources/traces_verdict_specs/SeqIndexOutOfRange.result @@ -14,6 +14,10 @@ public class Entry implements java.io.Serializable { return ((Number) xs.get(Utils.index(idx))); } + public String toString() { + return "Entry{}"; + } + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); @@ -46,10 +50,6 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } - - public String toString() { - return "Entry{}"; - } } ########## diff --git a/core/codegen/src/test/resources/traces_verdict_specs/UnionTypeFailure.result b/core/codegen/src/test/resources/traces_verdict_specs/UnionTypeFailure.result index 71f5469700..c56ce60764 100644 --- a/core/codegen/src/test/resources/traces_verdict_specs/UnionTypeFailure.result +++ b/core/codegen/src/test/resources/traces_verdict_specs/UnionTypeFailure.result @@ -12,6 +12,10 @@ public class Entry implements java.io.Serializable { return 1L + ((Number) e).longValue(); } + public String toString() { + return "Entry{}"; + } + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); @@ -79,10 +83,6 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } - - public String toString() { - return "Entry{}"; - } } ########## From d7bf83961587d8d7862c2150f389a6ef6716704f Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 4 Feb 2015 15:00:15 +0100 Subject: [PATCH 059/323] Added trace test exercising code generation of "let be st" in traces --- .../traces_expansion_specs/LetBeStNested | 28 ++++++ .../LetBeStNested.result | 97 +++++++++++++++++++ 2 files changed, 125 insertions(+) create mode 100644 core/codegen/src/test/resources/traces_expansion_specs/LetBeStNested create mode 100644 core/codegen/src/test/resources/traces_expansion_specs/LetBeStNested.result diff --git a/core/codegen/src/test/resources/traces_expansion_specs/LetBeStNested b/core/codegen/src/test/resources/traces_expansion_specs/LetBeStNested new file mode 100644 index 0000000000..7fecd93ceb --- /dev/null +++ b/core/codegen/src/test/resources/traces_expansion_specs/LetBeStNested @@ -0,0 +1,28 @@ +class Entry + +instance variables + +x : nat; + +operations + +public Entry : nat ==> Entry +Entry (px) == x := px; + +public op : () ==> nat +op () == +( + x := x + 1; + return x; +) + +traces + +T1: +let a in set {new Entry(3), new Entry(4)} +in + let b in set {new Entry(5), new Entry(6)} + in + (a.op();b.op()); + +end Entry \ No newline at end of file diff --git a/core/codegen/src/test/resources/traces_expansion_specs/LetBeStNested.result b/core/codegen/src/test/resources/traces_expansion_specs/LetBeStNested.result new file mode 100644 index 0000000000..a7ae11fb39 --- /dev/null +++ b/core/codegen/src/test/resources/traces_expansion_specs/LetBeStNested.result @@ -0,0 +1,97 @@ +import org.overture.codegen.runtime.*; +import org.overture.codegen.runtime.traces.*; + +import java.util.*; + + +public class Entry implements java.io.Serializable { + private Number x; + + public Entry(final Number px) { + cg_init_Entry_1(px); + } + + public Entry() { + } + + public void cg_init_Entry_1(final Number px) { + x = px; + } + + public Number op() { + x = x.longValue() + 1L; + + return x; + } + + public String toString() { + return "Entry{" + "x := " + Utils.toString(x) + "}"; + } + + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + final Store store = new Store(); + final IdGenerator gen = new IdGenerator(); + SequenceTraceNode sequence_1 = new SequenceTraceNode(); + AlternativeTraceNode alternatives_2 = new AlternativeTraceNode(); + VDMSet set_2 = SetUtil.set(new Entry(3L), new Entry(4L)); + + for (Iterator iterator_2 = set_2.iterator(); iterator_2.hasNext();) { + final Entry a = ((Entry) iterator_2.next()); + final Number ID_1 = gen.inc(); + + store.register(ID_1, a); + + AlternativeTraceNode alternatives_3 = new AlternativeTraceNode(); + VDMSet set_1 = SetUtil.set(new Entry(5L), new Entry(6L)); + + for (Iterator iterator_1 = set_1.iterator(); iterator_1.hasNext();) { + final Entry b = ((Entry) iterator_1.next()); + final Number ID_2 = gen.inc(); + + store.register(ID_2, b); + + SequenceTraceNode sequence_2 = new SequenceTraceNode(); + CallStatement callStm_1 = new CallStatement() { + public Object execute(final Object instance) { + Number result_1 = ((Entry) store.getValue(ID_1)).op(); + + return result_1; + } + + public String toString() { + return "a.op()"; + } + }; + + StatementTraceNode apply_1 = new StatementTraceNode(callStm_1); + + CallStatement callStm_2 = new CallStatement() { + public Object execute(final Object instance) { + Number result_2 = ((Entry) store.getValue(ID_2)).op(); + + return result_2; + } + + public String toString() { + return "b.op()"; + } + }; + + StatementTraceNode apply_2 = new StatementTraceNode(callStm_2); + + sequence_2.add(apply_1); + sequence_2.add(apply_2); + + alternatives_3.add(sequence_2); + } + + alternatives_2.add(alternatives_3); + } + + sequence_1.add(alternatives_2); + + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); + } +} + +########## From c7fd1f8a2db0670f1816dd0d986329bb5f96518d Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 4 Feb 2015 15:12:36 +0100 Subject: [PATCH 060/323] Added trace tests with consecutive "let defs" --- .../traces_expansion_specs/LetDefConsecutive | 29 +++++++ .../LetDefConsecutive.result | 80 ++++++++++++++++++ .../LetDefConsecutiveRepeat | 29 +++++++ .../LetDefConsecutiveRepeat.result | 84 +++++++++++++++++++ 4 files changed, 222 insertions(+) create mode 100644 core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutive create mode 100644 core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutive.result create mode 100644 core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutiveRepeat create mode 100644 core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutiveRepeat.result diff --git a/core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutive b/core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutive new file mode 100644 index 0000000000..a2609c9cae --- /dev/null +++ b/core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutive @@ -0,0 +1,29 @@ +class Entry + +instance variables + +x : nat := 1; + +operations + +public Entry : nat ==> Entry +Entry (px) == x := px; + +public op : () ==> nat +op () == +( + x := x + 1; + return x; +) + +traces + +T1: +let e1 = new Entry(2) +in + e1.op(); +let e2 = new Entry(3) +in + e2.op(); + +end Entry \ No newline at end of file diff --git a/core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutive.result b/core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutive.result new file mode 100644 index 0000000000..40ab9f52cb --- /dev/null +++ b/core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutive.result @@ -0,0 +1,80 @@ +import org.overture.codegen.runtime.*; +import org.overture.codegen.runtime.traces.*; + +import java.util.*; + + +public class Entry implements java.io.Serializable { + private Number x = 1L; + + public Entry(final Number px) { + cg_init_Entry_1(px); + } + + public Entry() { + } + + public void cg_init_Entry_1(final Number px) { + x = px; + } + + public Number op() { + x = x.longValue() + 1L; + + return x; + } + + public String toString() { + return "Entry{" + "x := " + Utils.toString(x) + "}"; + } + + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + final Store store = new Store(); + final IdGenerator gen = new IdGenerator(); + SequenceTraceNode sequence_1 = new SequenceTraceNode(); + final Entry e1 = new Entry(2L); + final Number ID_1 = gen.inc(); + + store.register(ID_1, e1); + + CallStatement callStm_1 = new CallStatement() { + public Object execute(final Object instance) { + Number result_1 = ((Entry) store.getValue(ID_1)).op(); + + return result_1; + } + + public String toString() { + return "e1.op()"; + } + }; + + StatementTraceNode apply_1 = new StatementTraceNode(callStm_1); + + final Entry e2 = new Entry(3L); + final Number ID_2 = gen.inc(); + + store.register(ID_2, e2); + + CallStatement callStm_2 = new CallStatement() { + public Object execute(final Object instance) { + Number result_2 = ((Entry) store.getValue(ID_2)).op(); + + return result_2; + } + + public String toString() { + return "e2.op()"; + } + }; + + StatementTraceNode apply_2 = new StatementTraceNode(callStm_2); + + sequence_1.add(apply_1); + sequence_1.add(apply_2); + + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); + } +} + +########## diff --git a/core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutiveRepeat b/core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutiveRepeat new file mode 100644 index 0000000000..ab39dc67a4 --- /dev/null +++ b/core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutiveRepeat @@ -0,0 +1,29 @@ +class Entry + +instance variables + +x : nat := 1; + +operations + +public Entry : nat ==> Entry +Entry (px) == x := px; + +public op : () ==> nat +op () == +( + x := x + 1; + return x; +) + +traces + +T1: +let e1 = new Entry(2) +in + e1.op(){1,2}; +let e2 = new Entry(3) +in + e2.op(){1,2}; + +end Entry \ No newline at end of file diff --git a/core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutiveRepeat.result b/core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutiveRepeat.result new file mode 100644 index 0000000000..2639c76776 --- /dev/null +++ b/core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutiveRepeat.result @@ -0,0 +1,84 @@ +import org.overture.codegen.runtime.*; +import org.overture.codegen.runtime.traces.*; + +import java.util.*; + + +public class Entry implements java.io.Serializable { + private Number x = 1L; + + public Entry(final Number px) { + cg_init_Entry_1(px); + } + + public Entry() { + } + + public void cg_init_Entry_1(final Number px) { + x = px; + } + + public Number op() { + x = x.longValue() + 1L; + + return x; + } + + public String toString() { + return "Entry{" + "x := " + Utils.toString(x) + "}"; + } + + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + final Store store = new Store(); + final IdGenerator gen = new IdGenerator(); + SequenceTraceNode sequence_1 = new SequenceTraceNode(); + final Entry e1 = new Entry(2L); + final Number ID_1 = gen.inc(); + + store.register(ID_1, e1); + + CallStatement callStm_1 = new CallStatement() { + public Object execute(final Object instance) { + Number result_1 = ((Entry) store.getValue(ID_1)).op(); + + return result_1; + } + + public String toString() { + return "e1.op()"; + } + }; + + StatementTraceNode apply_1 = new StatementTraceNode(callStm_1); + + RepeatTraceNode repeat_1 = new RepeatTraceNode(apply_1, 1L, 2L); + + final Entry e2 = new Entry(3L); + final Number ID_2 = gen.inc(); + + store.register(ID_2, e2); + + CallStatement callStm_2 = new CallStatement() { + public Object execute(final Object instance) { + Number result_2 = ((Entry) store.getValue(ID_2)).op(); + + return result_2; + } + + public String toString() { + return "e2.op()"; + } + }; + + StatementTraceNode apply_2 = new StatementTraceNode(callStm_2); + + RepeatTraceNode repeat_2 = new RepeatTraceNode(apply_2, 1L, 2L); + + sequence_1.add(repeat_1); + sequence_1.add(repeat_2); + + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); + } +} + +########## From 5bc6bc7a4cd3ae931f0b315b1fa2a9a69b0deb04 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 4 Feb 2015 15:31:17 +0100 Subject: [PATCH 061/323] Added trace test with combined use of concurrent and "let be st" trace nodes --- .../ConcurrentWithLetBeSt | 33 +++++++ .../ConcurrentWithLetBeSt.result | 97 +++++++++++++++++++ 2 files changed, 130 insertions(+) create mode 100644 core/codegen/src/test/resources/traces_expansion_specs/ConcurrentWithLetBeSt create mode 100644 core/codegen/src/test/resources/traces_expansion_specs/ConcurrentWithLetBeSt.result diff --git a/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentWithLetBeSt b/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentWithLetBeSt new file mode 100644 index 0000000000..ce857782a6 --- /dev/null +++ b/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentWithLetBeSt @@ -0,0 +1,33 @@ +class Entry + +instance variables + +x : nat := 1; + +operations + +public Entry : nat ==> Entry +Entry (px) == x := px; + +public op : () ==> nat +op () == +( + x := x + 1; + return x; +) + +traces + +T1: +|| +( +let e1 in set {new Entry(3), new Entry(4)} +in + e1.op(), + +let e2 in set {new Entry(5), new Entry(6)} +in + e2.op() +); + +end Entry \ No newline at end of file diff --git a/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentWithLetBeSt.result b/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentWithLetBeSt.result new file mode 100644 index 0000000000..8dba794169 --- /dev/null +++ b/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentWithLetBeSt.result @@ -0,0 +1,97 @@ +import org.overture.codegen.runtime.*; +import org.overture.codegen.runtime.traces.*; + +import java.util.*; + + +public class Entry implements java.io.Serializable { + private Number x = 1L; + + public Entry(final Number px) { + cg_init_Entry_1(px); + } + + public Entry() { + } + + public void cg_init_Entry_1(final Number px) { + x = px; + } + + public Number op() { + x = x.longValue() + 1L; + + return x; + } + + public String toString() { + return "Entry{" + "x := " + Utils.toString(x) + "}"; + } + + public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + final Store store = new Store(); + final IdGenerator gen = new IdGenerator(); + SequenceTraceNode sequence_1 = new SequenceTraceNode(); + ConcurrentTraceNode concurrent_1 = new ConcurrentTraceNode(); + AlternativeTraceNode alternatives_2 = new AlternativeTraceNode(); + VDMSet set_1 = SetUtil.set(new Entry(3L), new Entry(4L)); + + for (Iterator iterator_1 = set_1.iterator(); iterator_1.hasNext();) { + final Entry e1 = ((Entry) iterator_1.next()); + final Number ID_1 = gen.inc(); + + store.register(ID_1, e1); + + CallStatement callStm_1 = new CallStatement() { + public Object execute(final Object instance) { + Number result_1 = ((Entry) store.getValue(ID_1)).op(); + + return result_1; + } + + public String toString() { + return "e1.op()"; + } + }; + + StatementTraceNode apply_1 = new StatementTraceNode(callStm_1); + + alternatives_2.add(apply_1); + } + + AlternativeTraceNode alternatives_3 = new AlternativeTraceNode(); + VDMSet set_2 = SetUtil.set(new Entry(5L), new Entry(6L)); + + for (Iterator iterator_2 = set_2.iterator(); iterator_2.hasNext();) { + final Entry e2 = ((Entry) iterator_2.next()); + final Number ID_2 = gen.inc(); + + store.register(ID_2, e2); + + CallStatement callStm_2 = new CallStatement() { + public Object execute(final Object instance) { + Number result_2 = ((Entry) store.getValue(ID_2)).op(); + + return result_2; + } + + public String toString() { + return "e2.op()"; + } + }; + + StatementTraceNode apply_2 = new StatementTraceNode(callStm_2); + + alternatives_3.add(apply_2); + } + + concurrent_1.add(alternatives_2); + concurrent_1.add(alternatives_3); + + sequence_1.add(concurrent_1); + + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); + } +} + +########## From 4c0dc0b3c9aa5ffcbbcfdb5d05327de2fd980874 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 4 Feb 2015 18:53:36 +0100 Subject: [PATCH 062/323] Changed the order of transformations --- .../java/org/overture/codegen/vdm2java/JavaTransSeries.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaTransSeries.java b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaTransSeries.java index 968e521f9f..be226511d0 100644 --- a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaTransSeries.java +++ b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaTransSeries.java @@ -76,10 +76,10 @@ public DepthFirstAnalysisAdaptor[] consAnalyses(List classes, DepthFirstAnalysisAdaptor[] analyses = new DepthFirstAnalysisAdaptor[] { funcTransformation, prePostTransformation, ifExpTransformation, - funcValueTransformation, transVisitor, patternTransformation, + funcValueTransformation, transVisitor, tracesTransformation,patternTransformation, preCheckTransformation, postCheckTransformation, isExpTransformation, unionTypeTransformation, - javaToStringTransformation, concurrencytransform, tracesTransformation, + javaToStringTransformation, concurrencytransform, mutexTransform, mainclassTransform, seqConversionTransformation, instanceVarPPEval }; return analyses; From 39ad4c362625276cc34e9e4397200850645e5370 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 4 Feb 2015 18:56:39 +0100 Subject: [PATCH 063/323] Updates to trace related result files Having the trace method being generated as a non-static method reflects the way tests are "initialised" in VDM. --- .../traces_expansion_specs/Alternative1.result | 10 +++++----- .../AlternativeConcurrent1.result | 10 +++++----- .../traces_expansion_specs/AlternativeRepeat1.result | 10 +++++----- .../traces_expansion_specs/Concurrent1.result | 10 +++++----- .../traces_expansion_specs/Concurrent2.result | 10 +++++----- .../ConcurrentAlternative1.result | 10 +++++----- .../traces_expansion_specs/ConcurrentRepeat1.result | 10 +++++----- .../ConcurrentWithLetBeSt.result | 10 +++++----- .../resources/traces_expansion_specs/LetBeSt1.result | 10 +++++----- .../traces_expansion_specs/LetBeStNested.result | 10 +++++----- .../resources/traces_expansion_specs/LetDef1.result | 10 +++++----- .../traces_expansion_specs/LetDefConsecutive.result | 10 +++++----- .../LetDefConsecutiveRepeat.result | 10 +++++----- .../resources/traces_expansion_specs/ObjectBind.result | 10 +++++----- .../resources/traces_expansion_specs/Repeat1.result | 10 +++++----- .../traces_expansion_specs/RepeatAlternative1.result | 10 +++++----- .../traces_expansion_specs/RepeatConcurrent1.result | 10 +++++----- .../traces_expansion_specs/SingleStatement1.result | 10 +++++----- .../resources/traces_verdict_specs/DivByZero.result | 10 +++++----- .../test/resources/traces_verdict_specs/Filter.result | 10 +++++----- .../traces_verdict_specs/LetBeStNoBinding.result | 10 +++++----- .../resources/traces_verdict_specs/MapNoSuchKey.result | 10 +++++----- .../resources/traces_verdict_specs/NilRefError.result | 10 +++++----- .../traces_verdict_specs/PreCondViolation.result | 10 +++++----- .../traces_verdict_specs/SameTestTwice.result | 10 +++++----- .../traces_verdict_specs/SeqIndexOutOfRange.result | 10 +++++----- .../traces_verdict_specs/UnionTypeFailure.result | 10 +++++----- 27 files changed, 135 insertions(+), 135 deletions(-) diff --git a/core/codegen/src/test/resources/traces_expansion_specs/Alternative1.result b/core/codegen/src/test/resources/traces_expansion_specs/Alternative1.result index 45c8d313f7..5dfa911b73 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/Alternative1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/Alternative1.result @@ -16,11 +16,7 @@ public class Entry implements java.io.Serializable { return 23L; } - public String toString() { - return "Entry{}"; - } - - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + public void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); @@ -58,6 +54,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_expansion_specs/AlternativeConcurrent1.result b/core/codegen/src/test/resources/traces_expansion_specs/AlternativeConcurrent1.result index af9f3df7c3..d8777e7db8 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/AlternativeConcurrent1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/AlternativeConcurrent1.result @@ -24,11 +24,7 @@ public class Entry implements java.io.Serializable { return 1L; } - public String toString() { - return "Entry{}"; - } - - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + public void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); @@ -100,6 +96,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_expansion_specs/AlternativeRepeat1.result b/core/codegen/src/test/resources/traces_expansion_specs/AlternativeRepeat1.result index 712ff87b75..98ad9ae678 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/AlternativeRepeat1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/AlternativeRepeat1.result @@ -16,11 +16,7 @@ public class Entry implements java.io.Serializable { return 1L; } - public String toString() { - return "Entry{}"; - } - - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + public void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); @@ -65,6 +61,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_expansion_specs/Concurrent1.result b/core/codegen/src/test/resources/traces_expansion_specs/Concurrent1.result index f24ac1c86d..54a4efdf5c 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/Concurrent1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/Concurrent1.result @@ -20,11 +20,7 @@ public class Entry implements java.io.Serializable { //Skip; } - public String toString() { - return "Entry{}"; - } - - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + public void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); @@ -79,6 +75,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_expansion_specs/Concurrent2.result b/core/codegen/src/test/resources/traces_expansion_specs/Concurrent2.result index 31d7712b1c..226a8f2bbb 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/Concurrent2.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/Concurrent2.result @@ -16,11 +16,7 @@ public class Entry implements java.io.Serializable { return b; } - public String toString() { - return "Entry{}"; - } - - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + public void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); @@ -68,6 +64,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentAlternative1.result b/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentAlternative1.result index f35914dc56..3f3b99306c 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentAlternative1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentAlternative1.result @@ -24,11 +24,7 @@ public class Entry implements java.io.Serializable { return 2L; } - public String toString() { - return "Entry{}"; - } - - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + public void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); @@ -106,6 +102,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentRepeat1.result b/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentRepeat1.result index 07237f0cf3..1e63443170 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentRepeat1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentRepeat1.result @@ -16,11 +16,7 @@ public class Entry implements java.io.Serializable { return 1L; } - public String toString() { - return "Entry{}"; - } - - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + public void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); @@ -62,6 +58,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentWithLetBeSt.result b/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentWithLetBeSt.result index 8dba794169..11173a81de 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentWithLetBeSt.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentWithLetBeSt.result @@ -24,11 +24,7 @@ public class Entry implements java.io.Serializable { return x; } - public String toString() { - return "Entry{" + "x := " + Utils.toString(x) + "}"; - } - - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + public void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); @@ -92,6 +88,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{" + "x := " + Utils.toString(x) + "}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_expansion_specs/LetBeSt1.result b/core/codegen/src/test/resources/traces_expansion_specs/LetBeSt1.result index 201a1f1488..ebab0e4795 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/LetBeSt1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/LetBeSt1.result @@ -12,11 +12,7 @@ public class Entry implements java.io.Serializable { return a; } - public String toString() { - return "Entry{}"; - } - - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + public void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); @@ -53,6 +49,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_expansion_specs/LetBeStNested.result b/core/codegen/src/test/resources/traces_expansion_specs/LetBeStNested.result index a7ae11fb39..2df43927f3 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/LetBeStNested.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/LetBeStNested.result @@ -24,11 +24,7 @@ public class Entry implements java.io.Serializable { return x; } - public String toString() { - return "Entry{" + "x := " + Utils.toString(x) + "}"; - } - - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + public void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); @@ -92,6 +88,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{" + "x := " + Utils.toString(x) + "}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_expansion_specs/LetDef1.result b/core/codegen/src/test/resources/traces_expansion_specs/LetDef1.result index 6a543489d3..0072569a99 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/LetDef1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/LetDef1.result @@ -12,11 +12,7 @@ public class Entry implements java.io.Serializable { return a; } - public String toString() { - return "Entry{}"; - } - - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + public void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); @@ -48,6 +44,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutive.result b/core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutive.result index 40ab9f52cb..fd306c5aef 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutive.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutive.result @@ -24,11 +24,7 @@ public class Entry implements java.io.Serializable { return x; } - public String toString() { - return "Entry{" + "x := " + Utils.toString(x) + "}"; - } - - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + public void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); @@ -75,6 +71,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{" + "x := " + Utils.toString(x) + "}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutiveRepeat.result b/core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutiveRepeat.result index 2639c76776..c487aa50a8 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutiveRepeat.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutiveRepeat.result @@ -24,11 +24,7 @@ public class Entry implements java.io.Serializable { return x; } - public String toString() { - return "Entry{" + "x := " + Utils.toString(x) + "}"; - } - - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + public void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); @@ -79,6 +75,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{" + "x := " + Utils.toString(x) + "}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_expansion_specs/ObjectBind.result b/core/codegen/src/test/resources/traces_expansion_specs/ObjectBind.result index b05fbea3cc..6a7e8c54ce 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/ObjectBind.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/ObjectBind.result @@ -16,11 +16,7 @@ public class Entry implements java.io.Serializable { return x; } - public String toString() { - return "Entry{" + "x := " + Utils.toString(x) + "}"; - } - - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + public void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); @@ -49,6 +45,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{" + "x := " + Utils.toString(x) + "}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_expansion_specs/Repeat1.result b/core/codegen/src/test/resources/traces_expansion_specs/Repeat1.result index 881a6d6d05..a845bdcfc7 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/Repeat1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/Repeat1.result @@ -12,11 +12,7 @@ public class Entry implements java.io.Serializable { //Skip; } - public String toString() { - return "Entry{}"; - } - - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + public void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); @@ -43,6 +39,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_expansion_specs/RepeatAlternative1.result b/core/codegen/src/test/resources/traces_expansion_specs/RepeatAlternative1.result index 267600f7bd..233449b8b3 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/RepeatAlternative1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/RepeatAlternative1.result @@ -16,11 +16,7 @@ public class Entry implements java.io.Serializable { return 23L; } - public String toString() { - return "Entry{}"; - } - - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + public void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); @@ -63,6 +59,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_expansion_specs/RepeatConcurrent1.result b/core/codegen/src/test/resources/traces_expansion_specs/RepeatConcurrent1.result index b5493bd891..7de42d7676 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/RepeatConcurrent1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/RepeatConcurrent1.result @@ -16,11 +16,7 @@ public class Entry implements java.io.Serializable { //Skip; } - public String toString() { - return "Entry{}"; - } - - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + public void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); @@ -65,6 +61,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_expansion_specs/SingleStatement1.result b/core/codegen/src/test/resources/traces_expansion_specs/SingleStatement1.result index 11ac1932f8..5c1509df24 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/SingleStatement1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/SingleStatement1.result @@ -12,11 +12,7 @@ public class Entry implements java.io.Serializable { //Skip; } - public String toString() { - return "Entry{}"; - } - - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + public void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); @@ -38,6 +34,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_verdict_specs/DivByZero.result b/core/codegen/src/test/resources/traces_verdict_specs/DivByZero.result index 587ac86dad..05ce476ba5 100644 --- a/core/codegen/src/test/resources/traces_verdict_specs/DivByZero.result +++ b/core/codegen/src/test/resources/traces_verdict_specs/DivByZero.result @@ -12,11 +12,7 @@ public class Entry implements java.io.Serializable { return Utils.divide(1L, x.doubleValue()); } - public String toString() { - return "Entry{}"; - } - - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + public void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); @@ -48,6 +44,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_verdict_specs/Filter.result b/core/codegen/src/test/resources/traces_verdict_specs/Filter.result index f1d6b4af60..5cc42fe102 100644 --- a/core/codegen/src/test/resources/traces_verdict_specs/Filter.result +++ b/core/codegen/src/test/resources/traces_verdict_specs/Filter.result @@ -20,11 +20,7 @@ public class Entry implements java.io.Serializable { return false; } - public String toString() { - return "Entry{}"; - } - - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + public void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); @@ -48,6 +44,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_verdict_specs/LetBeStNoBinding.result b/core/codegen/src/test/resources/traces_verdict_specs/LetBeStNoBinding.result index 0234b4b0ac..167c8bd8fe 100644 --- a/core/codegen/src/test/resources/traces_verdict_specs/LetBeStNoBinding.result +++ b/core/codegen/src/test/resources/traces_verdict_specs/LetBeStNoBinding.result @@ -29,11 +29,7 @@ public class Entry implements java.io.Serializable { return letBeStExp_1; } - public String toString() { - return "Entry{}"; - } - - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + public void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); @@ -100,6 +96,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_verdict_specs/MapNoSuchKey.result b/core/codegen/src/test/resources/traces_verdict_specs/MapNoSuchKey.result index 9da1437a22..bc2c54f9d5 100644 --- a/core/codegen/src/test/resources/traces_verdict_specs/MapNoSuchKey.result +++ b/core/codegen/src/test/resources/traces_verdict_specs/MapNoSuchKey.result @@ -14,11 +14,7 @@ public class Entry implements java.io.Serializable { return ((Character) MapUtil.get(xs, idx)); } - public String toString() { - return "Entry{}"; - } - - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + public void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); @@ -50,6 +46,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_verdict_specs/NilRefError.result b/core/codegen/src/test/resources/traces_verdict_specs/NilRefError.result index 6e2f08f613..e82e4d0673 100644 --- a/core/codegen/src/test/resources/traces_verdict_specs/NilRefError.result +++ b/core/codegen/src/test/resources/traces_verdict_specs/NilRefError.result @@ -32,11 +32,7 @@ public class Entry implements java.io.Serializable { return x.longValue() < 1L; } - public String toString() { - return "Entry{" + "x := " + Utils.toString(x) + "}"; - } - - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + public void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); @@ -60,6 +56,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{" + "x := " + Utils.toString(x) + "}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_verdict_specs/PreCondViolation.result b/core/codegen/src/test/resources/traces_verdict_specs/PreCondViolation.result index bdbad18c64..1587c35761 100644 --- a/core/codegen/src/test/resources/traces_verdict_specs/PreCondViolation.result +++ b/core/codegen/src/test/resources/traces_verdict_specs/PreCondViolation.result @@ -28,11 +28,7 @@ public class Entry implements java.io.Serializable { return andResult_1; } - public String toString() { - return "Entry{}"; - } - - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + public void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); @@ -66,6 +62,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_verdict_specs/SameTestTwice.result b/core/codegen/src/test/resources/traces_verdict_specs/SameTestTwice.result index 15586a0d53..f4d874eb83 100644 --- a/core/codegen/src/test/resources/traces_verdict_specs/SameTestTwice.result +++ b/core/codegen/src/test/resources/traces_verdict_specs/SameTestTwice.result @@ -30,11 +30,7 @@ public class Entry implements java.io.Serializable { return x; } - public String toString() { - return "Entry{" + "x := " + Utils.toString(x) + "}"; - } - - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + public void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); @@ -84,6 +80,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{" + "x := " + Utils.toString(x) + "}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_verdict_specs/SeqIndexOutOfRange.result b/core/codegen/src/test/resources/traces_verdict_specs/SeqIndexOutOfRange.result index 8f7b1145c7..24c32fb594 100644 --- a/core/codegen/src/test/resources/traces_verdict_specs/SeqIndexOutOfRange.result +++ b/core/codegen/src/test/resources/traces_verdict_specs/SeqIndexOutOfRange.result @@ -14,11 +14,7 @@ public class Entry implements java.io.Serializable { return ((Number) xs.get(Utils.index(idx))); } - public String toString() { - return "Entry{}"; - } - - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + public void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); @@ -50,6 +46,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{}"; + } } ########## diff --git a/core/codegen/src/test/resources/traces_verdict_specs/UnionTypeFailure.result b/core/codegen/src/test/resources/traces_verdict_specs/UnionTypeFailure.result index c56ce60764..d322cd563a 100644 --- a/core/codegen/src/test/resources/traces_verdict_specs/UnionTypeFailure.result +++ b/core/codegen/src/test/resources/traces_verdict_specs/UnionTypeFailure.result @@ -12,11 +12,7 @@ public class Entry implements java.io.Serializable { return 1L + ((Number) e).longValue(); } - public String toString() { - return "Entry{}"; - } - - public static void Entry_T1_Run(final TestAccumulator testAccumulator) { + public void Entry_T1_Run(final TestAccumulator testAccumulator) { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); @@ -83,6 +79,10 @@ public class Entry implements java.io.Serializable { TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); } + + public String toString() { + return "Entry{}"; + } } ########## From bb747eb1887c2643e9f3ec0470c9017a5a04310e Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 4 Feb 2015 19:03:30 +0100 Subject: [PATCH 064/323] Added trace test demonstrating a small problem with code generation of traces The trace method must be non-static to reflect the way that tests are initialised in VDM --- .../OpCallsUsedToInitLocalDefs | 31 ++++++ .../OpCallsUsedToInitLocalDefs.result | 95 +++++++++++++++++++ 2 files changed, 126 insertions(+) create mode 100644 core/codegen/src/test/resources/traces_expansion_specs/OpCallsUsedToInitLocalDefs create mode 100644 core/codegen/src/test/resources/traces_expansion_specs/OpCallsUsedToInitLocalDefs.result diff --git a/core/codegen/src/test/resources/traces_expansion_specs/OpCallsUsedToInitLocalDefs b/core/codegen/src/test/resources/traces_expansion_specs/OpCallsUsedToInitLocalDefs new file mode 100644 index 0000000000..8240f4b2f2 --- /dev/null +++ b/core/codegen/src/test/resources/traces_expansion_specs/OpCallsUsedToInitLocalDefs @@ -0,0 +1,31 @@ +class Entry + +instance variables + +x : nat := 1; + +operations + +public Entry : nat ==> Entry +Entry (px) == x := px; + +public op : () ==> nat +op () == +( + x := x + 1; + return x; +); + +public id : nat ==> nat +id (a) == return a; + +traces + +T1: +let x = op(), + y = op(), + z = op() +in + (op();id(z)){1,2}; + +end Entry \ No newline at end of file diff --git a/core/codegen/src/test/resources/traces_expansion_specs/OpCallsUsedToInitLocalDefs.result b/core/codegen/src/test/resources/traces_expansion_specs/OpCallsUsedToInitLocalDefs.result new file mode 100644 index 0000000000..224dad96db --- /dev/null +++ b/core/codegen/src/test/resources/traces_expansion_specs/OpCallsUsedToInitLocalDefs.result @@ -0,0 +1,95 @@ +import org.overture.codegen.runtime.*; +import org.overture.codegen.runtime.traces.*; + +import java.util.*; + + +public class Entry implements java.io.Serializable { + private Number x = 1L; + + public Entry(final Number px) { + cg_init_Entry_1(px); + } + + public Entry() { + } + + public void cg_init_Entry_1(final Number px) { + x = px; + } + + public Number op() { + x = x.longValue() + 1L; + + return x; + } + + public Number id(final Number a) { + return a; + } + + public void Entry_T1_Run(final TestAccumulator testAccumulator) { + final Store store = new Store(); + final IdGenerator gen = new IdGenerator(); + SequenceTraceNode sequence_1 = new SequenceTraceNode(); + final Number x = op(); + final Number y = op(); + final Number z = op(); + final Number ID_1 = gen.inc(); + + store.register(ID_1, x); + + final Number ID_2 = gen.inc(); + + store.register(ID_2, y); + + final Number ID_3 = gen.inc(); + + store.register(ID_3, z); + + SequenceTraceNode sequence_2 = new SequenceTraceNode(); + CallStatement callStm_1 = new CallStatement() { + public Object execute(final Object instance) { + Number result_1 = ((Entry) instance).op(); + + return result_1; + } + + public String toString() { + return "op()"; + } + }; + + StatementTraceNode apply_1 = new StatementTraceNode(callStm_1); + + CallStatement callStm_2 = new CallStatement() { + public Object execute(final Object instance) { + Number result_2 = ((Entry) instance).id(((Number) store.getValue( + ID_3))); + + return result_2; + } + + public String toString() { + return "id(" + Utils.toString(z) + ")"; + } + }; + + StatementTraceNode apply_2 = new StatementTraceNode(callStm_2); + + sequence_2.add(apply_1); + sequence_2.add(apply_2); + + RepeatTraceNode repeat_1 = new RepeatTraceNode(sequence_2, 1L, 2L); + + sequence_1.add(repeat_1); + + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); + } + + public String toString() { + return "Entry{" + "x := " + Utils.toString(x) + "}"; + } +} + +########## From dfaa2fe203a1b068a020d6004a154bb7203d1c28 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 4 Feb 2015 19:04:10 +0100 Subject: [PATCH 065/323] Small fix: The trace method must be non-static to reflect the way that tests are initialised in VDM --- .../java/org/overture/codegen/traces/TracesTransformation.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/TracesTransformation.java b/core/codegen/src/main/java/org/overture/codegen/traces/TracesTransformation.java index f58bdb8aed..d13ca51ef6 100644 --- a/core/codegen/src/main/java/org/overture/codegen/traces/TracesTransformation.java +++ b/core/codegen/src/main/java/org/overture/codegen/traces/TracesTransformation.java @@ -114,7 +114,7 @@ private AMethodDeclCG consTraceMethod(ANamedTraceDeclCG node) traceMethod.setAccess(IRConstants.PUBLIC); traceMethod.setBody(consTraceMethodBody(node)); traceMethod.setIsConstructor(false); - traceMethod.setStatic(true); + traceMethod.setStatic(false); traceMethod.setMethodType(methodType); traceMethod.setName(getTraceName(node) + "_" + tracePrefixes.runTraceMethodName()); From d0a22efc20bcd12da967e1cf9d8f6d03d8868bda Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 4 Feb 2015 19:08:34 +0100 Subject: [PATCH 066/323] Fix: Cloning of "trace let def" local definitions must be done to avoid concurrent modification exceptions --- .../org/overture/codegen/traces/TraceStmsBuilder.java | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/TraceStmsBuilder.java b/core/codegen/src/main/java/org/overture/codegen/traces/TraceStmsBuilder.java index 3fd01057cc..5e227148f4 100644 --- a/core/codegen/src/main/java/org/overture/codegen/traces/TraceStmsBuilder.java +++ b/core/codegen/src/main/java/org/overture/codegen/traces/TraceStmsBuilder.java @@ -252,12 +252,13 @@ public TraceNodeData caseALetDefBindingTraceDeclCG( for (AVarDeclCG dec : node.getLocalDefs()) { - dec.setFinal(true); - declBlock.getLocalDefs().add(dec); + AVarDeclCG decCopy = dec.clone(); + decCopy.setFinal(true); + declBlock.getLocalDefs().add(decCopy); - if (dec.getPattern() instanceof AIdentifierPatternCG) + if (decCopy.getPattern() instanceof AIdentifierPatternCG) { - storeAssistant.appendStoreRegStms(declBlock, dec.getType().clone(), ((AIdentifierPatternCG) dec.getPattern()).getName()); + storeAssistant.appendStoreRegStms(declBlock, decCopy.getType().clone(), ((AIdentifierPatternCG) decCopy.getPattern()).getName()); } else { From 65500f72ecca9e01a6545d5aa45b4f84f2c7a0a0 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 4 Feb 2015 19:10:37 +0100 Subject: [PATCH 067/323] Updates to the core/codegen test execution system. The trace method has been changed to a non-static method and the trace handler is updated to reflect this --- .../java/org/overture/codegen/tests/utils/TraceHandler.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/TraceHandler.java b/core/codegen/src/test/java/org/overture/codegen/tests/utils/TraceHandler.java index 6f3ea340df..943837cf1f 100644 --- a/core/codegen/src/test/java/org/overture/codegen/tests/utils/TraceHandler.java +++ b/core/codegen/src/test/java/org/overture/codegen/tests/utils/TraceHandler.java @@ -59,7 +59,7 @@ public List getMainClassMethods() " public static TestAccumulator computeTests()\n" + " {\n" + " InMemoryTestAccumulator acc = new InMemoryTestAccumulator();\n" - + " Entry.Entry_T1_Run(acc);\n" + + " new Entry().Entry_T1_Run(acc);\n" + " return acc;\n" + " }\n"; From 286d8798276056c49331e367443e5648ca83b4f2 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 4 Feb 2015 19:26:50 +0100 Subject: [PATCH 068/323] Added a store registration assistant to manage local trace definitions during the traces transformation process --- .../traces/StoreRegistrationAssistant.java | 69 +++++++++++++++++++ 1 file changed, 69 insertions(+) create mode 100644 core/codegen/src/main/java/org/overture/codegen/traces/StoreRegistrationAssistant.java diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/StoreRegistrationAssistant.java b/core/codegen/src/main/java/org/overture/codegen/traces/StoreRegistrationAssistant.java new file mode 100644 index 0000000000..dfae0fad96 --- /dev/null +++ b/core/codegen/src/main/java/org/overture/codegen/traces/StoreRegistrationAssistant.java @@ -0,0 +1,69 @@ +package org.overture.codegen.traces; + +import java.util.Map; + +import org.overture.codegen.cgast.SExpCG; +import org.overture.codegen.cgast.STypeCG; +import org.overture.codegen.cgast.declarations.AVarDeclCG; +import org.overture.codegen.cgast.expressions.AIdentifierVarExpCG; +import org.overture.codegen.cgast.statements.ABlockStmCG; +import org.overture.codegen.cgast.statements.ACallObjectExpStmCG; +import org.overture.codegen.cgast.types.AClassTypeCG; +import org.overture.codegen.cgast.types.ANatNumericBasicTypeCG; +import org.overture.codegen.ir.IRInfo; +import org.overture.codegen.trans.assistants.TransAssistantCG; + +public class StoreRegistrationAssistant +{ + private IRInfo info; + private TraceNames tracePrefixes; + private Map idConstNameMap; + private TransAssistantCG transAssistant; + + public StoreRegistrationAssistant(IRInfo info, TraceNames tracePrefixes, + Map idConstNameMap, TransAssistantCG transAssistant) + { + super(); + this.info = info; + this.tracePrefixes = tracePrefixes; + this.idConstNameMap = idConstNameMap; + this.transAssistant = transAssistant; + } + + public void appendStoreRegStms(ABlockStmCG declBlock, STypeCG varType, String varName) + { + String idConstName = idConstNameMap.get(varName); + + if(idConstName == null) + { + idConstName = info.getTempVarNameGen().nextVarName(tracePrefixes.idConstNamePrefix()); + } + + declBlock.getStatements().add(transAssistant.wrap(consIdConstDecl(idConstName))); + declBlock.getStatements().add(consStoreRegistration(idConstName, varType, varName)); + idConstNameMap.put(varName, idConstName); + } + + public AVarDeclCG consIdConstDecl(String idConstName) + { + ANatNumericBasicTypeCG intType = new ANatNumericBasicTypeCG(); + AClassTypeCG idGenType = transAssistant.consClassType(tracePrefixes.idGeneratorClassName()); + SExpCG init = transAssistant.consInstanceCall(idGenType, tracePrefixes.idGeneratorVarName(), + intType, tracePrefixes.idGeneratorIncrementMethodName()); + + AVarDeclCG idConstDecl = transAssistant.consDecl(idConstName, intType.clone(), init); + idConstDecl.setFinal(true); + + return idConstDecl; + } + + public ACallObjectExpStmCG consStoreRegistration(String idConstName, STypeCG varType, String varName) + { + AClassTypeCG storageType = transAssistant.consClassType(tracePrefixes.storeClassName()); + String storeVarName = tracePrefixes.storeVarName(); + AIdentifierVarExpCG idVarExp = transAssistant.consIdentifierVar(idConstName, new ANatNumericBasicTypeCG()); + + return transAssistant.consInstanceCallStm(storageType, storeVarName, tracePrefixes.storeRegisterMethodName(), + idVarExp, transAssistant.consIdentifierVar(varName, varType)); + } +} From a368e1b51115e9ea33d5c7af966554a150eb63e1 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 4 Feb 2015 21:40:54 +0100 Subject: [PATCH 069/323] Updates to trace related test result files. Scoping is now expected to be generated correctly in traces. --- .../traces_expansion_specs/Concurrent2.result | 6 +++-- .../traces_expansion_specs/LetBeSt1.result | 3 ++- .../traces_expansion_specs/LetDef1.result | 3 ++- .../LetDefConsecutive.result | 12 ++++++--- .../LetDefConsecutiveRepeat.result | 12 ++++++--- .../traces_expansion_specs/ObjectBind.result | 6 +++-- .../OpCallsUsedToInitLocalDefs.result | 21 +++++++-------- .../traces_verdict_specs/DivByZero.result | 3 ++- .../LetBeStNoBinding.result | 27 ++++++++++++------- .../traces_verdict_specs/MapNoSuchKey.result | 3 ++- .../PreCondViolation.result | 3 ++- .../traces_verdict_specs/SameTestTwice.result | 6 +++-- .../SeqIndexOutOfRange.result | 3 ++- .../UnionTypeFailure.result | 27 ++++++++++++------- 14 files changed, 86 insertions(+), 49 deletions(-) diff --git a/core/codegen/src/test/resources/traces_expansion_specs/Concurrent2.result b/core/codegen/src/test/resources/traces_expansion_specs/Concurrent2.result index 226a8f2bbb..1860a9602a 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/Concurrent2.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/Concurrent2.result @@ -36,7 +36,8 @@ public class Entry implements java.io.Serializable { } public String toString() { - return "fun1(" + Utils.toString(x) + ")"; + return "fun1(" + + Utils.toString(((Number) store.getValue(ID_1))) + ")"; } }; @@ -48,7 +49,8 @@ public class Entry implements java.io.Serializable { } public String toString() { - return "fun2(" + Utils.toString(x) + ")"; + return "fun2(" + + Utils.toString(((Number) store.getValue(ID_1))) + ")"; } }; diff --git a/core/codegen/src/test/resources/traces_expansion_specs/LetBeSt1.result b/core/codegen/src/test/resources/traces_expansion_specs/LetBeSt1.result index ebab0e4795..031bc66ec2 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/LetBeSt1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/LetBeSt1.result @@ -36,7 +36,8 @@ public class Entry implements java.io.Serializable { } public String toString() { - return "fun(" + Utils.toString(a) + ")"; + return "fun(" + + Utils.toString(((Number) store.getValue(ID_1))) + ")"; } }; diff --git a/core/codegen/src/test/resources/traces_expansion_specs/LetDef1.result b/core/codegen/src/test/resources/traces_expansion_specs/LetDef1.result index 0072569a99..3026cfbbac 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/LetDef1.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/LetDef1.result @@ -31,7 +31,8 @@ public class Entry implements java.io.Serializable { } public String toString() { - return "fun(" + Utils.toString(a) + ")"; + return "fun(" + + Utils.toString(((Number) store.getValue(ID_1))) + ")"; } }; diff --git a/core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutive.result b/core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutive.result index fd306c5aef..6f9c46ce5b 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutive.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutive.result @@ -28,10 +28,12 @@ public class Entry implements java.io.Serializable { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); - final Entry e1 = new Entry(2L); final Number ID_1 = gen.inc(); - store.register(ID_1, e1); + { + final Entry e1 = new Entry(2L); + store.register(ID_1, e1); + } CallStatement callStm_1 = new CallStatement() { public Object execute(final Object instance) { @@ -47,10 +49,12 @@ public class Entry implements java.io.Serializable { StatementTraceNode apply_1 = new StatementTraceNode(callStm_1); - final Entry e2 = new Entry(3L); final Number ID_2 = gen.inc(); - store.register(ID_2, e2); + { + final Entry e2 = new Entry(3L); + store.register(ID_2, e2); + } CallStatement callStm_2 = new CallStatement() { public Object execute(final Object instance) { diff --git a/core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutiveRepeat.result b/core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutiveRepeat.result index c487aa50a8..0fb49882ff 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutiveRepeat.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutiveRepeat.result @@ -28,10 +28,12 @@ public class Entry implements java.io.Serializable { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); - final Entry e1 = new Entry(2L); final Number ID_1 = gen.inc(); - store.register(ID_1, e1); + { + final Entry e1 = new Entry(2L); + store.register(ID_1, e1); + } CallStatement callStm_1 = new CallStatement() { public Object execute(final Object instance) { @@ -49,10 +51,12 @@ public class Entry implements java.io.Serializable { RepeatTraceNode repeat_1 = new RepeatTraceNode(apply_1, 1L, 2L); - final Entry e2 = new Entry(3L); final Number ID_2 = gen.inc(); - store.register(ID_2, e2); + { + final Entry e2 = new Entry(3L); + store.register(ID_2, e2); + } CallStatement callStm_2 = new CallStatement() { public Object execute(final Object instance) { diff --git a/core/codegen/src/test/resources/traces_expansion_specs/ObjectBind.result b/core/codegen/src/test/resources/traces_expansion_specs/ObjectBind.result index 6a7e8c54ce..c342d4b1bd 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/ObjectBind.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/ObjectBind.result @@ -20,10 +20,12 @@ public class Entry implements java.io.Serializable { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); - final Entry a = new Entry(); final Number ID_1 = gen.inc(); - store.register(ID_1, a); + { + final Entry a = new Entry(); + store.register(ID_1, a); + } CallStatement callStm_1 = new CallStatement() { public Object execute(final Object instance) { diff --git a/core/codegen/src/test/resources/traces_expansion_specs/OpCallsUsedToInitLocalDefs.result b/core/codegen/src/test/resources/traces_expansion_specs/OpCallsUsedToInitLocalDefs.result index 224dad96db..7463e89aab 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/OpCallsUsedToInitLocalDefs.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/OpCallsUsedToInitLocalDefs.result @@ -32,20 +32,18 @@ public class Entry implements java.io.Serializable { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); - final Number x = op(); - final Number y = op(); - final Number z = op(); final Number ID_1 = gen.inc(); - - store.register(ID_1, x); - final Number ID_2 = gen.inc(); - - store.register(ID_2, y); - final Number ID_3 = gen.inc(); - store.register(ID_3, z); + { + final Number x = op(); + final Number y = op(); + final Number z = op(); + store.register(ID_1, x); + store.register(ID_2, y); + store.register(ID_3, z); + } SequenceTraceNode sequence_2 = new SequenceTraceNode(); CallStatement callStm_1 = new CallStatement() { @@ -71,7 +69,8 @@ public class Entry implements java.io.Serializable { } public String toString() { - return "id(" + Utils.toString(z) + ")"; + return "id(" + + Utils.toString(((Number) store.getValue(ID_3))) + ")"; } }; diff --git a/core/codegen/src/test/resources/traces_verdict_specs/DivByZero.result b/core/codegen/src/test/resources/traces_verdict_specs/DivByZero.result index 05ce476ba5..777bcc8944 100644 --- a/core/codegen/src/test/resources/traces_verdict_specs/DivByZero.result +++ b/core/codegen/src/test/resources/traces_verdict_specs/DivByZero.result @@ -31,7 +31,8 @@ public class Entry implements java.io.Serializable { } public String toString() { - return "f(" + Utils.toString(x) + ")"; + return "f(" + + Utils.toString(((Number) store.getValue(ID_1))) + ")"; } }; diff --git a/core/codegen/src/test/resources/traces_verdict_specs/LetBeStNoBinding.result b/core/codegen/src/test/resources/traces_verdict_specs/LetBeStNoBinding.result index 167c8bd8fe..8ba0c129fc 100644 --- a/core/codegen/src/test/resources/traces_verdict_specs/LetBeStNoBinding.result +++ b/core/codegen/src/test/resources/traces_verdict_specs/LetBeStNoBinding.result @@ -33,20 +33,26 @@ public class Entry implements java.io.Serializable { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); - final Number a = 1L; final Number ID_1 = gen.inc(); - store.register(ID_1, a); + { + final Number a = 1L; + store.register(ID_1, a); + } - final Number b = 10L; final Number ID_2 = gen.inc(); - store.register(ID_2, b); + { + final Number b = 10L; + store.register(ID_2, b); + } - final Number c = 3L; final Number ID_3 = gen.inc(); - store.register(ID_3, c); + { + final Number c = 3L; + store.register(ID_3, c); + } SequenceTraceNode sequence_2 = new SequenceTraceNode(); AlternativeTraceNode alternatives_2 = new AlternativeTraceNode(); @@ -56,7 +62,8 @@ public class Entry implements java.io.Serializable { } public String toString() { - return "f(" + Utils.toString(a) + ")"; + return "f(" + + Utils.toString(((Number) store.getValue(ID_1))) + ")"; } }; @@ -68,7 +75,8 @@ public class Entry implements java.io.Serializable { } public String toString() { - return "f(" + Utils.toString(b) + ")"; + return "f(" + + Utils.toString(((Number) store.getValue(ID_2))) + ")"; } }; @@ -80,7 +88,8 @@ public class Entry implements java.io.Serializable { } public String toString() { - return "f(" + Utils.toString(c) + ")"; + return "f(" + + Utils.toString(((Number) store.getValue(ID_3))) + ")"; } }; diff --git a/core/codegen/src/test/resources/traces_verdict_specs/MapNoSuchKey.result b/core/codegen/src/test/resources/traces_verdict_specs/MapNoSuchKey.result index bc2c54f9d5..ecd5ff00b7 100644 --- a/core/codegen/src/test/resources/traces_verdict_specs/MapNoSuchKey.result +++ b/core/codegen/src/test/resources/traces_verdict_specs/MapNoSuchKey.result @@ -33,7 +33,8 @@ public class Entry implements java.io.Serializable { } public String toString() { - return "f(" + Utils.toString(a) + ")"; + return "f(" + + Utils.toString(((Number) store.getValue(ID_1))) + ")"; } }; diff --git a/core/codegen/src/test/resources/traces_verdict_specs/PreCondViolation.result b/core/codegen/src/test/resources/traces_verdict_specs/PreCondViolation.result index 1587c35761..3ae56ccdc2 100644 --- a/core/codegen/src/test/resources/traces_verdict_specs/PreCondViolation.result +++ b/core/codegen/src/test/resources/traces_verdict_specs/PreCondViolation.result @@ -49,7 +49,8 @@ public class Entry implements java.io.Serializable { } public String toString() { - return "op(" + Utils.toString(x) + ")"; + return "op(" + + Utils.toString(((Number) store.getValue(ID_1))) + ")"; } }; diff --git a/core/codegen/src/test/resources/traces_verdict_specs/SameTestTwice.result b/core/codegen/src/test/resources/traces_verdict_specs/SameTestTwice.result index f4d874eb83..d6f63843f6 100644 --- a/core/codegen/src/test/resources/traces_verdict_specs/SameTestTwice.result +++ b/core/codegen/src/test/resources/traces_verdict_specs/SameTestTwice.result @@ -34,10 +34,12 @@ public class Entry implements java.io.Serializable { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); - final Entry a = new Entry(3L); final Number ID_1 = gen.inc(); - store.register(ID_1, a); + { + final Entry a = new Entry(3L); + store.register(ID_1, a); + } SequenceTraceNode sequence_2 = new SequenceTraceNode(); AlternativeTraceNode alternatives_2 = new AlternativeTraceNode(); diff --git a/core/codegen/src/test/resources/traces_verdict_specs/SeqIndexOutOfRange.result b/core/codegen/src/test/resources/traces_verdict_specs/SeqIndexOutOfRange.result index 24c32fb594..09b734865d 100644 --- a/core/codegen/src/test/resources/traces_verdict_specs/SeqIndexOutOfRange.result +++ b/core/codegen/src/test/resources/traces_verdict_specs/SeqIndexOutOfRange.result @@ -33,7 +33,8 @@ public class Entry implements java.io.Serializable { } public String toString() { - return "f(" + Utils.toString(a) + ")"; + return "f(" + + Utils.toString(((Number) store.getValue(ID_1))) + ")"; } }; diff --git a/core/codegen/src/test/resources/traces_verdict_specs/UnionTypeFailure.result b/core/codegen/src/test/resources/traces_verdict_specs/UnionTypeFailure.result index d322cd563a..06b0b73c0f 100644 --- a/core/codegen/src/test/resources/traces_verdict_specs/UnionTypeFailure.result +++ b/core/codegen/src/test/resources/traces_verdict_specs/UnionTypeFailure.result @@ -16,20 +16,26 @@ public class Entry implements java.io.Serializable { final Store store = new Store(); final IdGenerator gen = new IdGenerator(); SequenceTraceNode sequence_1 = new SequenceTraceNode(); - final Number a = 1L; final Number ID_1 = gen.inc(); - store.register(ID_1, a); + { + final Number a = 1L; + store.register(ID_1, a); + } - final Character b = 'x'; final Number ID_2 = gen.inc(); - store.register(ID_2, b); + { + final Character b = 'x'; + store.register(ID_2, b); + } - final Number c = 3L; final Number ID_3 = gen.inc(); - store.register(ID_3, c); + { + final Number c = 3L; + store.register(ID_3, c); + } SequenceTraceNode sequence_2 = new SequenceTraceNode(); AlternativeTraceNode alternatives_2 = new AlternativeTraceNode(); @@ -39,7 +45,8 @@ public class Entry implements java.io.Serializable { } public String toString() { - return "f(" + Utils.toString(a) + ")"; + return "f(" + + Utils.toString(((Number) store.getValue(ID_1))) + ")"; } }; @@ -51,7 +58,8 @@ public class Entry implements java.io.Serializable { } public String toString() { - return "f(" + Utils.toString(b) + ")"; + return "f(" + + Utils.toString(((Character) store.getValue(ID_2))) + ")"; } }; @@ -63,7 +71,8 @@ public class Entry implements java.io.Serializable { } public String toString() { - return "f(" + Utils.toString(c) + ")"; + return "f(" + + Utils.toString(((Number) store.getValue(ID_3))) + ")"; } }; From 9f9fe1b664ea0665232ca96ed4fe1e076e7d83d5 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 4 Feb 2015 21:41:27 +0100 Subject: [PATCH 070/323] Added test revealing problem with code generation of scoping in traces --- .../traces_expansion_specs/ConcurrentRepeat2 | 39 +++++++ .../ConcurrentRepeat2.result | 101 ++++++++++++++++++ 2 files changed, 140 insertions(+) create mode 100644 core/codegen/src/test/resources/traces_expansion_specs/ConcurrentRepeat2 create mode 100644 core/codegen/src/test/resources/traces_expansion_specs/ConcurrentRepeat2.result diff --git a/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentRepeat2 b/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentRepeat2 new file mode 100644 index 0000000000..2eff937a96 --- /dev/null +++ b/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentRepeat2 @@ -0,0 +1,39 @@ +class Entry + +instance variables + +x : nat := 1; + +operations + +public Entry : nat ==> Entry +Entry (px) == x := px; + +public op : () ==> nat +op () == +( + x := x + 1; + return x; +); + +public id : nat ==> nat +id (a) == return a; + +traces + +T1: +|| +( + let x = op(), + y = op() + in + op(), + + let x = op(), + y = op() + in + id(y) + +){1,2}; + +end Entry \ No newline at end of file diff --git a/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentRepeat2.result b/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentRepeat2.result new file mode 100644 index 0000000000..754e2d0b8e --- /dev/null +++ b/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentRepeat2.result @@ -0,0 +1,101 @@ +import org.overture.codegen.runtime.*; +import org.overture.codegen.runtime.traces.*; + +import java.util.*; + + +public class Entry implements java.io.Serializable { + private Number x = 1L; + + public Entry(final Number px) { + cg_init_Entry_1(px); + } + + public Entry() { + } + + public void cg_init_Entry_1(final Number px) { + x = px; + } + + public Number op() { + x = x.longValue() + 1L; + + return x; + } + + public Number id(final Number a) { + return a; + } + + public void Entry_T1_Run(final TestAccumulator testAccumulator) { + final Store store = new Store(); + final IdGenerator gen = new IdGenerator(); + SequenceTraceNode sequence_1 = new SequenceTraceNode(); + ConcurrentTraceNode concurrent_1 = new ConcurrentTraceNode(); + final Number ID_1 = gen.inc(); + final Number ID_2 = gen.inc(); + + { + final Number x = op(); + final Number y = op(); + store.register(ID_1, x); + store.register(ID_2, y); + } + + CallStatement callStm_1 = new CallStatement() { + public Object execute(final Object instance) { + Number result_1 = ((Entry) instance).op(); + + return result_1; + } + + public String toString() { + return "op()"; + } + }; + + StatementTraceNode apply_1 = new StatementTraceNode(callStm_1); + + final Number ID_3 = gen.inc(); + final Number ID_4 = gen.inc(); + + { + final Number x = op(); + final Number y = op(); + store.register(ID_3, x); + store.register(ID_4, y); + } + + CallStatement callStm_2 = new CallStatement() { + public Object execute(final Object instance) { + Number result_2 = ((Entry) instance).id(((Number) store.getValue( + ID_4))); + + return result_2; + } + + public String toString() { + return "id(" + + Utils.toString(((Number) store.getValue(ID_4))) + ")"; + } + }; + + StatementTraceNode apply_2 = new StatementTraceNode(callStm_2); + + concurrent_1.add(apply_1); + concurrent_1.add(apply_2); + + RepeatTraceNode repeat_1 = new RepeatTraceNode(concurrent_1, 1L, 2L); + + sequence_1.add(repeat_1); + + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); + } + + public String toString() { + return "Entry{" + "x := " + Utils.toString(x) + "}"; + } +} + +########## From a7bb6acd905cc2f6b7ec94685a6460565c670bd3 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 4 Feb 2015 21:53:40 +0100 Subject: [PATCH 071/323] Added more utility functionality to the store assistant used in the traces transformation --- ...tionAssistant.java => StoreAssistant.java} | 35 +++++++++++-------- 1 file changed, 21 insertions(+), 14 deletions(-) rename core/codegen/src/main/java/org/overture/codegen/traces/{StoreRegistrationAssistant.java => StoreAssistant.java} (73%) diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/StoreRegistrationAssistant.java b/core/codegen/src/main/java/org/overture/codegen/traces/StoreAssistant.java similarity index 73% rename from core/codegen/src/main/java/org/overture/codegen/traces/StoreRegistrationAssistant.java rename to core/codegen/src/main/java/org/overture/codegen/traces/StoreAssistant.java index dfae0fad96..ff23ba2380 100644 --- a/core/codegen/src/main/java/org/overture/codegen/traces/StoreRegistrationAssistant.java +++ b/core/codegen/src/main/java/org/overture/codegen/traces/StoreAssistant.java @@ -5,41 +5,31 @@ import org.overture.codegen.cgast.SExpCG; import org.overture.codegen.cgast.STypeCG; import org.overture.codegen.cgast.declarations.AVarDeclCG; +import org.overture.codegen.cgast.expressions.ACastUnaryExpCG; import org.overture.codegen.cgast.expressions.AIdentifierVarExpCG; import org.overture.codegen.cgast.statements.ABlockStmCG; import org.overture.codegen.cgast.statements.ACallObjectExpStmCG; import org.overture.codegen.cgast.types.AClassTypeCG; import org.overture.codegen.cgast.types.ANatNumericBasicTypeCG; -import org.overture.codegen.ir.IRInfo; import org.overture.codegen.trans.assistants.TransAssistantCG; -public class StoreRegistrationAssistant +public class StoreAssistant { - private IRInfo info; private TraceNames tracePrefixes; private Map idConstNameMap; private TransAssistantCG transAssistant; - public StoreRegistrationAssistant(IRInfo info, TraceNames tracePrefixes, + public StoreAssistant(TraceNames tracePrefixes, Map idConstNameMap, TransAssistantCG transAssistant) { super(); - this.info = info; this.tracePrefixes = tracePrefixes; this.idConstNameMap = idConstNameMap; this.transAssistant = transAssistant; } - public void appendStoreRegStms(ABlockStmCG declBlock, STypeCG varType, String varName) + public void appendStoreRegStms(ABlockStmCG declBlock, STypeCG varType, String varName, String idConstName) { - String idConstName = idConstNameMap.get(varName); - - if(idConstName == null) - { - idConstName = info.getTempVarNameGen().nextVarName(tracePrefixes.idConstNamePrefix()); - } - - declBlock.getStatements().add(transAssistant.wrap(consIdConstDecl(idConstName))); declBlock.getStatements().add(consStoreRegistration(idConstName, varType, varName)); idConstNameMap.put(varName, idConstName); } @@ -66,4 +56,21 @@ public ACallObjectExpStmCG consStoreRegistration(String idConstName, STypeCG var return transAssistant.consInstanceCallStm(storageType, storeVarName, tracePrefixes.storeRegisterMethodName(), idVarExp, transAssistant.consIdentifierVar(varName, varType)); } + + public ACastUnaryExpCG consStoreLookup(AIdentifierVarExpCG node) + { + AClassTypeCG storeType = transAssistant.consClassType(tracePrefixes.storeClassName()); + + AIdentifierVarExpCG idArg = transAssistant.consIdentifierVar(idConstNameMap.get(node.getName()), + new ANatNumericBasicTypeCG()); + + SExpCG call = transAssistant.consInstanceCall(storeType, tracePrefixes.storeVarName(), + node.getType(), tracePrefixes.storeGetValueMethodName(), idArg); + + ACastUnaryExpCG cast = new ACastUnaryExpCG(); + cast.setType(node.getType().clone()); + cast.setExp(call); + + return cast; + } } From 4f3fd4e201df79ab1f485f7c5be0004222279cc0 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 4 Feb 2015 22:00:26 +0100 Subject: [PATCH 072/323] Fix: Prior to this fix code generation of traces did not take scoping of the "trace let def" construct into account --- .../traces/ICallStmToStringMethodBuilder.java | 8 ++- .../traces/JavaCallStmToStringBuilder.java | 23 ++++++-- .../codegen/traces/TraceLetBeStStrategy.java | 11 ++-- .../codegen/traces/TraceStmsBuilder.java | 54 ++++++++++--------- 4 files changed, 62 insertions(+), 34 deletions(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/ICallStmToStringMethodBuilder.java b/core/codegen/src/main/java/org/overture/codegen/traces/ICallStmToStringMethodBuilder.java index 923340c016..fe1eb9cd7e 100644 --- a/core/codegen/src/main/java/org/overture/codegen/traces/ICallStmToStringMethodBuilder.java +++ b/core/codegen/src/main/java/org/overture/codegen/traces/ICallStmToStringMethodBuilder.java @@ -1,10 +1,16 @@ package org.overture.codegen.traces; +import java.util.Map; + import org.overture.codegen.cgast.SStmCG; import org.overture.codegen.cgast.declarations.AMethodDeclCG; import org.overture.codegen.ir.IRInfo; +import org.overture.codegen.trans.assistants.TransAssistantCG; public interface ICallStmToStringMethodBuilder { - public AMethodDeclCG consToString(IRInfo info, SStmCG callStm); + public AMethodDeclCG consToString(IRInfo info, SStmCG callStm, + Map idConstNameMap, + StoreAssistant storeAssistant, + TransAssistantCG transAssistant); } diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/JavaCallStmToStringBuilder.java b/core/codegen/src/main/java/org/overture/codegen/traces/JavaCallStmToStringBuilder.java index 62d1359d7e..3965e25842 100644 --- a/core/codegen/src/main/java/org/overture/codegen/traces/JavaCallStmToStringBuilder.java +++ b/core/codegen/src/main/java/org/overture/codegen/traces/JavaCallStmToStringBuilder.java @@ -1,6 +1,7 @@ package org.overture.codegen.traces; import java.util.LinkedList; +import java.util.Map; import org.overture.codegen.cgast.SExpCG; import org.overture.codegen.cgast.SObjectDesignatorCG; @@ -8,6 +9,7 @@ import org.overture.codegen.cgast.STypeCG; import org.overture.codegen.cgast.declarations.AMethodDeclCG; import org.overture.codegen.cgast.expressions.AApplyExpCG; +import org.overture.codegen.cgast.expressions.AIdentifierVarExpCG; import org.overture.codegen.cgast.expressions.ASeqConcatBinaryExpCG; import org.overture.codegen.cgast.statements.ACallObjectStmCG; import org.overture.codegen.cgast.statements.APlainCallStmCG; @@ -16,12 +18,13 @@ import org.overture.codegen.cgast.types.AStringTypeCG; import org.overture.codegen.ir.IRInfo; import org.overture.codegen.logging.Logger; +import org.overture.codegen.trans.assistants.TransAssistantCG; import org.overture.codegen.vdm2java.JavaClassCreatorBase; public class JavaCallStmToStringBuilder extends JavaClassCreatorBase implements ICallStmToStringMethodBuilder { @Override - public AMethodDeclCG consToString(IRInfo info, SStmCG callStm) + public AMethodDeclCG consToString(IRInfo info, SStmCG callStm, Map idConstNameMap, StoreAssistant storeAssistant, TransAssistantCG transAssistant) { AMethodDeclCG toStringMethod = consToStringSignature(); @@ -44,7 +47,7 @@ public AMethodDeclCG consToString(IRInfo info, SStmCG callStm) prefix += name; - body.setExp(appendArgs(info, args, prefix)); + body.setExp(appendArgs(info, args, prefix, idConstNameMap, storeAssistant, transAssistant)); } else if (callStm instanceof ACallObjectStmCG) { @@ -57,7 +60,7 @@ public AMethodDeclCG consToString(IRInfo info, SStmCG callStm) String prefix = obj.toString(); prefix += "." + field; - body.setExp(appendArgs(info, args, prefix)); + body.setExp(appendArgs(info, args, prefix, idConstNameMap, storeAssistant, transAssistant)); } else { Logger.getLog().printErrorln("Expected statement to be a call statement or call object statement. Got: " @@ -70,7 +73,7 @@ public AMethodDeclCG consToString(IRInfo info, SStmCG callStm) return toStringMethod; } - private SExpCG appendArgs(IRInfo info, LinkedList args, String prefix) + private SExpCG appendArgs(IRInfo info, LinkedList args, String prefix, Map idConstNameMap, StoreAssistant storeAssistant, TransAssistantCG transAssistant) { if (args == null || args.isEmpty()) { @@ -89,7 +92,17 @@ private SExpCG appendArgs(IRInfo info, LinkedList args, String prefix) tmp.setType(new AStringTypeCG()); AApplyExpCG utilsToStrCall = consUtilsToStringCall(); - utilsToStrCall.getArgs().add(arg.clone()); + + if(arg instanceof AIdentifierVarExpCG && idConstNameMap.containsKey(((AIdentifierVarExpCG) arg).getName())) + { + AIdentifierVarExpCG idVarExp = ((AIdentifierVarExpCG) arg); + utilsToStrCall.getArgs().add(storeAssistant.consStoreLookup(idVarExp)); + } + else + { + utilsToStrCall.getArgs().add(arg.clone()); + } + tmp.setLeft(utilsToStrCall); next.setRight(tmp); diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/TraceLetBeStStrategy.java b/core/codegen/src/main/java/org/overture/codegen/traces/TraceLetBeStStrategy.java index 88b0586c8a..d278056785 100644 --- a/core/codegen/src/main/java/org/overture/codegen/traces/TraceLetBeStStrategy.java +++ b/core/codegen/src/main/java/org/overture/codegen/traces/TraceLetBeStStrategy.java @@ -1,6 +1,7 @@ package org.overture.codegen.traces; import java.util.List; +import java.util.Map; import org.overture.codegen.cgast.SExpCG; import org.overture.codegen.cgast.SPatternCG; @@ -29,17 +30,19 @@ public class TraceLetBeStStrategy extends LetBeStStrategy protected AVarDeclCG altTests; protected AIdentifierPatternCG id; protected TraceNames tracePrefixes; - protected StoreRegistrationAssistant storeAssistant; + protected StoreAssistant storeAssistant; + protected Map idConstNameMap; public TraceLetBeStStrategy(TransAssistantCG transformationAssistant, SExpCG suchThat, SSetTypeCG setType, ILanguageIterator langIterator, ITempVarGen tempGen, - TempVarPrefixes varPrefixes, StoreRegistrationAssistant storeAssistant,TraceNames tracePrefixes, + TempVarPrefixes varPrefixes, StoreAssistant storeAssistant,Map idConstNameMap, TraceNames tracePrefixes, AIdentifierPatternCG id, AVarDeclCG altTests, TraceNodeData nodeData) { super(transformationAssistant, suchThat, setType, langIterator, tempGen, varPrefixes); this.storeAssistant = storeAssistant; + this.idConstNameMap = idConstNameMap; this.tracePrefixes = tracePrefixes; this.id = id; this.altTests = altTests; @@ -114,7 +117,9 @@ public List getForLoopStms(AIdentifierVarExpCG setVar, if(nextElementDecl.getPattern() instanceof AIdentifierPatternCG) { AIdentifierPatternCG idToReg = (AIdentifierPatternCG) nextElementDecl.getPattern(); - storeAssistant.appendStoreRegStms(block, setType.getSetOf().clone(), idToReg.getName()); + String idConstName = idConstNameMap.get(idToReg.getName()); + block.getStatements().add(transAssistant.wrap(storeAssistant.consIdConstDecl(idConstName))); + storeAssistant.appendStoreRegStms(block, setType.getSetOf().clone(), idToReg.getName(), idConstName); } else { diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/TraceStmsBuilder.java b/core/codegen/src/main/java/org/overture/codegen/traces/TraceStmsBuilder.java index 5e227148f4..fd074406c7 100644 --- a/core/codegen/src/main/java/org/overture/codegen/traces/TraceStmsBuilder.java +++ b/core/codegen/src/main/java/org/overture/codegen/traces/TraceStmsBuilder.java @@ -50,7 +50,6 @@ import org.overture.codegen.cgast.types.AClassTypeCG; import org.overture.codegen.cgast.types.AExternalTypeCG; import org.overture.codegen.cgast.types.AMethodTypeCG; -import org.overture.codegen.cgast.types.ANatNumericBasicTypeCG; import org.overture.codegen.cgast.types.AObjectTypeCG; import org.overture.codegen.cgast.types.AVoidTypeCG; import org.overture.codegen.cgast.types.SSetTypeCG; @@ -75,7 +74,7 @@ public class TraceStmsBuilder extends AnswerAdaptor private TraceNames tracePrefixes; private String traceEnclosingClass; - private StoreRegistrationAssistant storeAssistant; + private StoreAssistant storeAssistant; private Map idConstNameMap; @@ -97,7 +96,7 @@ public TraceStmsBuilder(IRInfo info, List classes, this.idConstNameMap = new HashedMap(); - this.storeAssistant = new StoreRegistrationAssistant(info, tracePrefixes, idConstNameMap, transAssistant); + this.storeAssistant = new StoreAssistant(tracePrefixes, idConstNameMap, transAssistant); } @Override @@ -144,7 +143,7 @@ public TraceNodeData caseAApplyExpTraceCoreDeclCG( AAnonymousClassExpCG callStmCreation = new AAnonymousClassExpCG(); callStmCreation.setType(callStmType); callStmCreation.getMethods().add(consExecuteMethod(node.getCallStm().clone())); - callStmCreation.getMethods().add(toStringBuilder.consToString(info, node.getCallStm())); + callStmCreation.getMethods().add(toStringBuilder.consToString(info, node.getCallStm(), idConstNameMap, storeAssistant, transAssistant)); AVarDeclCG callStmDecl = transAssistant.consDecl(callStmName, callStmType.clone(), callStmCreation); AClassTypeCG stmTraceNodeType = transAssistant.consClassType(tracePrefixes.stmTraceNodeClassName()); @@ -231,7 +230,7 @@ public TraceNodeData caseALetBeStBindingTraceDeclCG( SSetTypeCG setType = transAssistant.getSetTypeCloned(bind.getSet()); TraceLetBeStStrategy strategy = new TraceLetBeStStrategy(transAssistant, exp, setType, langIterator, - info.getTempVarNameGen(), varPrefixes, storeAssistant, tracePrefixes, id, altTests, bodyTraceData); + info.getTempVarNameGen(), varPrefixes, storeAssistant, idConstNameMap, tracePrefixes, id, altTests, bodyTraceData); if (transAssistant.hasEmptySet(bind)) { @@ -248,7 +247,26 @@ public TraceNodeData caseALetBeStBindingTraceDeclCG( public TraceNodeData caseALetDefBindingTraceDeclCG( ALetDefBindingTraceDeclCG node) throws AnalysisException { + ABlockStmCG outer = new ABlockStmCG(); + + for(AVarDeclCG dec : node.getLocalDefs()) + { + if (dec.getPattern() instanceof AIdentifierPatternCG) + { + String idConstName = info.getTempVarNameGen().nextVarName(tracePrefixes.idConstNamePrefix()); + idConstNameMap.put(((AIdentifierPatternCG) dec.getPattern()).getName(), idConstName); + outer.getLocalDefs().add(storeAssistant.consIdConstDecl(idConstName)); + } + else + { + Logger.getLog().printErrorln("This should not happen. Only identifier patterns " + + "are currently supported in traces (see the TraceSupportedAnalysis class)."); + return null; + } + } + ABlockStmCG declBlock = new ABlockStmCG(); + declBlock.setScoped(true); for (AVarDeclCG dec : node.getLocalDefs()) { @@ -258,7 +276,7 @@ public TraceNodeData caseALetDefBindingTraceDeclCG( if (decCopy.getPattern() instanceof AIdentifierPatternCG) { - storeAssistant.appendStoreRegStms(declBlock, decCopy.getType().clone(), ((AIdentifierPatternCG) decCopy.getPattern()).getName()); + storeAssistant.appendStoreRegStms(declBlock, decCopy.getType().clone(), ((AIdentifierPatternCG) decCopy.getPattern()).getName(), idConstNameMap.get(((AIdentifierPatternCG) dec.getPattern()).getName())); } else { @@ -269,11 +287,10 @@ public TraceNodeData caseALetDefBindingTraceDeclCG( } TraceNodeData bodyNodeData = node.getBody().apply(this); - ABlockStmCG resultingStms = new ABlockStmCG(); - resultingStms.getStatements().add(declBlock); - resultingStms.getStatements().add(bodyNodeData.getStms()); - - return new TraceNodeData(bodyNodeData.getNodeVar(), resultingStms); + outer.getStatements().add(declBlock); + outer.getStatements().add(bodyNodeData.getStms()); + + return new TraceNodeData(bodyNodeData.getNodeVar(), outer); } @Override @@ -372,20 +389,7 @@ public void caseAIdentifierVarExpCG(AIdentifierVarExpCG node) { if(localVarNames.contains(node.getName())) { - AClassTypeCG storeType = transAssistant.consClassType(tracePrefixes.storeClassName()); - - AIdentifierVarExpCG idArg = transAssistant.consIdentifierVar(idConstNameMap.get(node.getName()), - new ANatNumericBasicTypeCG()); - - SExpCG call = transAssistant.consInstanceCall(storeType, tracePrefixes.storeVarName(), - node.getType(), tracePrefixes.storeGetValueMethodName(), idArg); - - ACastUnaryExpCG cast = new ACastUnaryExpCG(); - cast.setType(node.getType().clone()); - cast.setExp(call); - - - transAssistant.replaceNodeWith(node, cast); + transAssistant.replaceNodeWith(node, storeAssistant.consStoreLookup(node)); } } }); From f329d3be11a3c24a3cab8132338e578c225d3e1b Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Thu, 5 Feb 2015 21:04:35 +0100 Subject: [PATCH 073/323] Updated the 'TraceSupportedAnalysis' to allow use of patterns in traces --- .../traces/TraceSupportedAnalysis.java | 25 ++----------------- 1 file changed, 2 insertions(+), 23 deletions(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/TraceSupportedAnalysis.java b/core/codegen/src/main/java/org/overture/codegen/traces/TraceSupportedAnalysis.java index 00ca67208e..7be60e2592 100644 --- a/core/codegen/src/main/java/org/overture/codegen/traces/TraceSupportedAnalysis.java +++ b/core/codegen/src/main/java/org/overture/codegen/traces/TraceSupportedAnalysis.java @@ -1,11 +1,9 @@ package org.overture.codegen.traces; import org.overture.codegen.cgast.INode; -import org.overture.codegen.cgast.SPatternCG; import org.overture.codegen.cgast.analysis.AnalysisException; import org.overture.codegen.cgast.analysis.DepthFirstAnalysisAdaptor; import org.overture.codegen.cgast.declarations.ANamedTraceDeclCG; -import org.overture.codegen.cgast.patterns.AIdentifierPatternCG; import org.overture.codegen.cgast.statements.ASuperCallStmCG; /** @@ -29,11 +27,6 @@ * generator when it does appear in traces. Therefore, this analysis * will detect this case. * - * Finally, code generation of traces only support the identifier - * pattern among the different types of patterns. This analysis also - * checks that the only type of pattern occurring in a trace is the identifier - * pattern. - * * @author pvj * */ @@ -57,25 +50,11 @@ public void caseASuperCallStmCG(ASuperCallStmCG node) return; } - reason = "The super call statement is not supported in traces, and as a consequence the trace is not generated."; + reason = "The super call statement is not supported in traces," + + "and as a consequence the trace is not generated."; isUnsupported = true; } - @Override - public void defaultInSPatternCG(SPatternCG node) throws AnalysisException - { - if(!isWithinTrace(node)) - { - return; - } - - if(!(node instanceof AIdentifierPatternCG)) - { - reason = "Only identifier patterns are supported in traces, and as a consequence the trace is not generated."; - isUnsupported = true; - } - } - public void run() throws AnalysisException { trace.apply(this); From b2a957b88cb953abf7de9f943eeffaeabccef19b Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Thu, 5 Feb 2015 21:20:52 +0100 Subject: [PATCH 074/323] Updated the traces transformation to support patterns in the "trace let def" --- .../traces/IdentifierPatternCollector.java | 80 +++++++++++++++++++ .../codegen/traces/StoreAssistant.java | 7 +- .../codegen/traces/TraceLetBeStStrategy.java | 2 +- .../codegen/traces/TraceStmsBuilder.java | 32 +++----- 4 files changed, 95 insertions(+), 26 deletions(-) create mode 100644 core/codegen/src/main/java/org/overture/codegen/traces/IdentifierPatternCollector.java diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/IdentifierPatternCollector.java b/core/codegen/src/main/java/org/overture/codegen/traces/IdentifierPatternCollector.java new file mode 100644 index 0000000000..d5dad1c4d0 --- /dev/null +++ b/core/codegen/src/main/java/org/overture/codegen/traces/IdentifierPatternCollector.java @@ -0,0 +1,80 @@ +package org.overture.codegen.traces; + +import java.util.HashSet; +import java.util.Set; + +import org.overture.codegen.cgast.INode; +import org.overture.codegen.cgast.analysis.AnalysisException; +import org.overture.codegen.cgast.analysis.DepthFirstAnalysisAdaptor; +import org.overture.codegen.cgast.patterns.AIdentifierPatternCG; +import org.overture.codegen.logging.Logger; + +public class IdentifierPatternCollector extends DepthFirstAnalysisAdaptor +{ + private INode topNode; + private Set idOccurences; + + public IdentifierPatternCollector() + { + this.topNode = null; + this.idOccurences = null; + } + + public void setTopNode(INode topNode) + { + this.topNode = topNode; + } + + public Set findOccurences() + { + this.idOccurences = new HashSet(); + + try + { + topNode.apply(this); + } catch (AnalysisException e) + { + Logger.getLog().printErrorln("Problems finding identifier " + + "pattern occurences in 'IdentifierPatternCollector' for node: " + topNode); + e.printStackTrace(); + } + + return idOccurences; + } + + @Override + public void caseAIdentifierPatternCG(AIdentifierPatternCG node) + throws AnalysisException + { + if (proceed(node)) + { + idOccurences.add(node); + } + } + + private boolean proceed(INode node) + { + if(topNode == null) + { + return false; + } + + if (node == topNode) + { + return true; + } + + INode parent = node.parent(); + + Set visited = new HashSet(); + + while (parent != null && !visited.contains(parent) + && this.topNode != parent) + { + parent = parent.parent(); + visited.add(parent); + } + + return this.topNode == parent; + } +} diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/StoreAssistant.java b/core/codegen/src/main/java/org/overture/codegen/traces/StoreAssistant.java index ff23ba2380..2438b64fc1 100644 --- a/core/codegen/src/main/java/org/overture/codegen/traces/StoreAssistant.java +++ b/core/codegen/src/main/java/org/overture/codegen/traces/StoreAssistant.java @@ -11,6 +11,7 @@ import org.overture.codegen.cgast.statements.ACallObjectExpStmCG; import org.overture.codegen.cgast.types.AClassTypeCG; import org.overture.codegen.cgast.types.ANatNumericBasicTypeCG; +import org.overture.codegen.cgast.types.AUnknownTypeCG; import org.overture.codegen.trans.assistants.TransAssistantCG; public class StoreAssistant @@ -28,9 +29,11 @@ public StoreAssistant(TraceNames tracePrefixes, this.transAssistant = transAssistant; } - public void appendStoreRegStms(ABlockStmCG declBlock, STypeCG varType, String varName, String idConstName) + public void appendStoreRegStms(ABlockStmCG declBlock, String varName, String idConstName) { - declBlock.getStatements().add(consStoreRegistration(idConstName, varType, varName)); + // Passing the variable type as the unknown type is not very accurate. + // However, it simplifies the store registration. + declBlock.getStatements().add(consStoreRegistration(idConstName, new AUnknownTypeCG(), varName)); idConstNameMap.put(varName, idConstName); } diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/TraceLetBeStStrategy.java b/core/codegen/src/main/java/org/overture/codegen/traces/TraceLetBeStStrategy.java index d278056785..e2fa9b0a15 100644 --- a/core/codegen/src/main/java/org/overture/codegen/traces/TraceLetBeStStrategy.java +++ b/core/codegen/src/main/java/org/overture/codegen/traces/TraceLetBeStStrategy.java @@ -119,7 +119,7 @@ public List getForLoopStms(AIdentifierVarExpCG setVar, AIdentifierPatternCG idToReg = (AIdentifierPatternCG) nextElementDecl.getPattern(); String idConstName = idConstNameMap.get(idToReg.getName()); block.getStatements().add(transAssistant.wrap(storeAssistant.consIdConstDecl(idConstName))); - storeAssistant.appendStoreRegStms(block, setType.getSetOf().clone(), idToReg.getName(), idConstName); + storeAssistant.appendStoreRegStms(block, idToReg.getName(), idConstName); } else { diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/TraceStmsBuilder.java b/core/codegen/src/main/java/org/overture/codegen/traces/TraceStmsBuilder.java index fd074406c7..c06031ba29 100644 --- a/core/codegen/src/main/java/org/overture/codegen/traces/TraceStmsBuilder.java +++ b/core/codegen/src/main/java/org/overture/codegen/traces/TraceStmsBuilder.java @@ -249,40 +249,26 @@ public TraceNodeData caseALetDefBindingTraceDeclCG( { ABlockStmCG outer = new ABlockStmCG(); - for(AVarDeclCG dec : node.getLocalDefs()) - { - if (dec.getPattern() instanceof AIdentifierPatternCG) - { - String idConstName = info.getTempVarNameGen().nextVarName(tracePrefixes.idConstNamePrefix()); - idConstNameMap.put(((AIdentifierPatternCG) dec.getPattern()).getName(), idConstName); - outer.getLocalDefs().add(storeAssistant.consIdConstDecl(idConstName)); - } - else - { - Logger.getLog().printErrorln("This should not happen. Only identifier patterns " - + "are currently supported in traces (see the TraceSupportedAnalysis class)."); - return null; - } - } + IdentifierPatternCollector idCollector = new IdentifierPatternCollector(); ABlockStmCG declBlock = new ABlockStmCG(); declBlock.setScoped(true); for (AVarDeclCG dec : node.getLocalDefs()) { + idCollector.setTopNode(dec); + Set idOccurences = idCollector.findOccurences(); + AVarDeclCG decCopy = dec.clone(); decCopy.setFinal(true); declBlock.getLocalDefs().add(decCopy); - if (decCopy.getPattern() instanceof AIdentifierPatternCG) - { - storeAssistant.appendStoreRegStms(declBlock, decCopy.getType().clone(), ((AIdentifierPatternCG) decCopy.getPattern()).getName(), idConstNameMap.get(((AIdentifierPatternCG) dec.getPattern()).getName())); - } - else + for(AIdentifierPatternCG occ : idOccurences) { - Logger.getLog().printErrorln("This should not happen. Only identifier patterns " - + "are currently supported in traces (see the TraceSupportedAnalysis class)."); - return null; + String idConstName = info.getTempVarNameGen().nextVarName(tracePrefixes.idConstNamePrefix()); + idConstNameMap.put(occ.getName(), idConstName); + outer.getLocalDefs().add(storeAssistant.consIdConstDecl(idConstName)); + storeAssistant.appendStoreRegStms(declBlock, occ.getName(), idConstName); } } TraceNodeData bodyNodeData = node.getBody().apply(this); From 9d0c03aef97dc07ddcf9b5bfea79df730a172b59 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Thu, 5 Feb 2015 21:28:30 +0100 Subject: [PATCH 075/323] Added trace test that exercises use patterns in the "trace let def" --- .../traces_expansion_specs/LetDefTuplePattern | 15 ++++ .../LetDefTuplePattern.result | 82 +++++++++++++++++++ 2 files changed, 97 insertions(+) create mode 100644 core/codegen/src/test/resources/traces_expansion_specs/LetDefTuplePattern create mode 100644 core/codegen/src/test/resources/traces_expansion_specs/LetDefTuplePattern.result diff --git a/core/codegen/src/test/resources/traces_expansion_specs/LetDefTuplePattern b/core/codegen/src/test/resources/traces_expansion_specs/LetDefTuplePattern new file mode 100644 index 0000000000..5bba9932f2 --- /dev/null +++ b/core/codegen/src/test/resources/traces_expansion_specs/LetDefTuplePattern @@ -0,0 +1,15 @@ +class Entry + +functions + +public f : nat -> nat +f (x) == x; + +traces + +T1: +let mk_(a,b) = mk_(1,2) +in + (f(a);f(b)) + +end Entry \ No newline at end of file diff --git a/core/codegen/src/test/resources/traces_expansion_specs/LetDefTuplePattern.result b/core/codegen/src/test/resources/traces_expansion_specs/LetDefTuplePattern.result new file mode 100644 index 0000000000..c2f49154ca --- /dev/null +++ b/core/codegen/src/test/resources/traces_expansion_specs/LetDefTuplePattern.result @@ -0,0 +1,82 @@ +import org.overture.codegen.runtime.*; +import org.overture.codegen.runtime.traces.*; + +import java.util.*; + + +public class Entry implements java.io.Serializable { + public Entry() { + } + + public static Number f(final Number x) { + return x; + } + + public void Entry_T1_Run(final TestAccumulator testAccumulator) { + final Store store = new Store(); + final IdGenerator gen = new IdGenerator(); + SequenceTraceNode sequence_1 = new SequenceTraceNode(); + final Number ID_1 = gen.inc(); + final Number ID_2 = gen.inc(); + + { + final Tuple tuplePattern_1 = Tuple.mk_(1L, 2L); + Boolean success_1 = tuplePattern_1.compatible(Number.class, + Number.class); + Number a = null; + Number b = null; + + if (success_1) { + a = ((Number) tuplePattern_1.get(0)); + b = ((Number) tuplePattern_1.get(1)); + } + + if (!(success_1)) { + throw new RuntimeException("Tuple pattern match failed"); + } + + store.register(ID_1, a); + store.register(ID_2, b); + } + + SequenceTraceNode sequence_2 = new SequenceTraceNode(); + CallStatement callStm_1 = new CallStatement() { + public Object execute(final Object instance) { + return f(((Number) store.getValue(ID_1))); + } + + public String toString() { + return "f(" + + Utils.toString(((Number) store.getValue(ID_1))) + ")"; + } + }; + + StatementTraceNode apply_1 = new StatementTraceNode(callStm_1); + + CallStatement callStm_2 = new CallStatement() { + public Object execute(final Object instance) { + return f(((Number) store.getValue(ID_2))); + } + + public String toString() { + return "f(" + + Utils.toString(((Number) store.getValue(ID_2))) + ")"; + } + }; + + StatementTraceNode apply_2 = new StatementTraceNode(callStm_2); + + sequence_2.add(apply_1); + sequence_2.add(apply_2); + + sequence_1.add(sequence_2); + + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); + } + + public String toString() { + return "Entry{}"; + } +} + +########## From a47280adfbc1cd13c3f2cee854512be09774c1a2 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Mon, 16 Feb 2015 20:51:29 +0100 Subject: [PATCH 076/323] Arguments of a constructed instance call should not be null --- .../codegen/trans/assistants/TransAssistantCG.java | 9 ++++++--- .../codegen/trans/iterator/JavaLanguageIterator.java | 4 ++-- 2 files changed, 8 insertions(+), 5 deletions(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/assistants/TransAssistantCG.java b/core/codegen/src/main/java/org/overture/codegen/trans/assistants/TransAssistantCG.java index cd34102807..4f31cb5c16 100644 --- a/core/codegen/src/main/java/org/overture/codegen/trans/assistants/TransAssistantCG.java +++ b/core/codegen/src/main/java/org/overture/codegen/trans/assistants/TransAssistantCG.java @@ -287,10 +287,13 @@ public SExpCG consInstanceCall(STypeCG instanceType, String instanceName, instanceCall.setType(returnType.clone()); - for (SExpCG arg : args) + if (args != null) { - methodType.getParams().add(arg.getType().clone()); - instanceCall.getArgs().add(arg); + for (SExpCG arg : args) + { + methodType.getParams().add(arg.getType().clone()); + instanceCall.getArgs().add(arg); + } } fieldExp.setType(methodType.clone()); diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/iterator/JavaLanguageIterator.java b/core/codegen/src/main/java/org/overture/codegen/trans/iterator/JavaLanguageIterator.java index c34d1fd951..4d41f39e38 100644 --- a/core/codegen/src/main/java/org/overture/codegen/trans/iterator/JavaLanguageIterator.java +++ b/core/codegen/src/main/java/org/overture/codegen/trans/iterator/JavaLanguageIterator.java @@ -69,7 +69,7 @@ public AVarDeclCG getForLoopInit(AIdentifierVarExpCG setVar, String setName = setVar.getName(); AClassTypeCG iteratorType = transAssistant.consClassType(ITERATOR_TYPE); STypeCG setType = setVar.getType().clone(); - SExpCG getIteratorCall = transAssistant.consInstanceCall(setType, setName, iteratorType.clone(), GET_ITERATOR, null); + SExpCG getIteratorCall = transAssistant.consInstanceCall(setType, setName, iteratorType.clone(), GET_ITERATOR); return transAssistant.getInfo().getDeclAssistant(). consLocalVarDecl(iteratorType, transAssistant.consIdPattern(iteratorName), getIteratorCall); @@ -82,7 +82,7 @@ public SExpCG getForLoopCond(AIdentifierVarExpCG setVar, { AClassTypeCG iteratorType = transAssistant.consClassType(ITERATOR_TYPE); - return transAssistant.consInstanceCall(iteratorType, iteratorName, new ABoolBasicTypeCG(), HAS_NEXT_ELEMENT_ITERATOR, null); + return transAssistant.consInstanceCall(iteratorType, iteratorName, new ABoolBasicTypeCG(), HAS_NEXT_ELEMENT_ITERATOR); } @Override From 25f14caa8e70d0360c6c5eff07ea1834f911da2b Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Tue, 17 Feb 2015 10:27:31 +0100 Subject: [PATCH 077/323] Make sure that the order of identifier pattern occurences is always the same --- .../codegen/traces/IdentifierPatternCollector.java | 8 +++++--- .../org/overture/codegen/traces/TraceStmsBuilder.java | 3 ++- 2 files changed, 7 insertions(+), 4 deletions(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/IdentifierPatternCollector.java b/core/codegen/src/main/java/org/overture/codegen/traces/IdentifierPatternCollector.java index d5dad1c4d0..0c0c08a8da 100644 --- a/core/codegen/src/main/java/org/overture/codegen/traces/IdentifierPatternCollector.java +++ b/core/codegen/src/main/java/org/overture/codegen/traces/IdentifierPatternCollector.java @@ -1,6 +1,8 @@ package org.overture.codegen.traces; import java.util.HashSet; +import java.util.LinkedList; +import java.util.List; import java.util.Set; import org.overture.codegen.cgast.INode; @@ -12,7 +14,7 @@ public class IdentifierPatternCollector extends DepthFirstAnalysisAdaptor { private INode topNode; - private Set idOccurences; + private List idOccurences; public IdentifierPatternCollector() { @@ -25,9 +27,9 @@ public void setTopNode(INode topNode) this.topNode = topNode; } - public Set findOccurences() + public List findOccurences() { - this.idOccurences = new HashSet(); + idOccurences = new LinkedList(); try { diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/TraceStmsBuilder.java b/core/codegen/src/main/java/org/overture/codegen/traces/TraceStmsBuilder.java index c06031ba29..2083f1c578 100644 --- a/core/codegen/src/main/java/org/overture/codegen/traces/TraceStmsBuilder.java +++ b/core/codegen/src/main/java/org/overture/codegen/traces/TraceStmsBuilder.java @@ -206,6 +206,7 @@ public TraceNodeData caseALetBeStBindingTraceDeclCG( ASetMultipleBindCG bind = node.getBind(); LinkedList patterns = bind.getPatterns(); + //TODO: Can the pattern not be other patterns? Use a pattern collector here? for(SPatternCG p : patterns) { if(p instanceof AIdentifierPatternCG) @@ -257,7 +258,7 @@ public TraceNodeData caseALetDefBindingTraceDeclCG( for (AVarDeclCG dec : node.getLocalDefs()) { idCollector.setTopNode(dec); - Set idOccurences = idCollector.findOccurences(); + List idOccurences = idCollector.findOccurences(); AVarDeclCG decCopy = dec.clone(); decCopy.setFinal(true); From 6c8b175f4a65e42f49bc35b8841eb7cff766427b Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Tue, 17 Feb 2015 11:21:11 +0100 Subject: [PATCH 078/323] Initial poms for isabelle CG prototype. [Issue: ] --- core/cgisa/pom.xml | 53 ++++++++++++++++++++++++++++++++++++++++++++++ core/pom.xml | 1 + 2 files changed, 54 insertions(+) create mode 100644 core/cgisa/pom.xml diff --git a/core/cgisa/pom.xml b/core/cgisa/pom.xml new file mode 100644 index 0000000000..55e399d52c --- /dev/null +++ b/core/cgisa/pom.xml @@ -0,0 +1,53 @@ + + 4.0.0 + + + org.overturetool + core + 2.2.1-SNAPSHOT + ../pom.xml + + + org.overturetool.core + cgisa + Isabelle Code Generation + + + + org.overturetool.core + ast + ${project.version} + + + org.overturetool.core + codegen + ${project.version} + + + org.overturetool.core.testing + framework + ${project.version} + test + + + + + + + org.apache.maven.plugins + maven-surefire-plugin + + + true + + **/*Test.java + **/*Test?.java + **/*TestSuite.java + + + + + + + + diff --git a/core/pom.xml b/core/pom.xml index db2d041025..2681edcff0 100644 --- a/core/pom.xml +++ b/core/pom.xml @@ -26,6 +26,7 @@ vdmjc codegen codegen-runtime + cgisa guibuilder modelcheckers From 4b7568a830d17b42ce35adc34f7cd6edca15b6f6 Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Tue, 17 Feb 2015 13:40:12 +0100 Subject: [PATCH 079/323] Complete bootstrapping of cgISA --- core/cgisa/pom.xml | 5 + .../org/overturetool/cgisa/IsaCodeGen.java | 132 ++++++++++++++++++ 2 files changed, 137 insertions(+) create mode 100644 core/cgisa/src/main/java/org/overturetool/cgisa/IsaCodeGen.java diff --git a/core/cgisa/pom.xml b/core/cgisa/pom.xml index 55e399d52c..def76b14d3 100644 --- a/core/cgisa/pom.xml +++ b/core/cgisa/pom.xml @@ -29,6 +29,11 @@ ${project.version} test + + junit + junit + 4.11 + diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaCodeGen.java b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaCodeGen.java new file mode 100644 index 0000000000..47c6e12b6f --- /dev/null +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaCodeGen.java @@ -0,0 +1,132 @@ +/* + * #%~ + * VDM to Isabelle Code Generator + * %% + * Copyright (C) 2008 - 2014 Overture + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program. If not, see + * . + * #~% + */ +package org.overturetool.cgisa; + +import java.io.StringWriter; +import java.util.ArrayList; +import java.util.HashSet; +import java.util.LinkedList; +import java.util.List; + +import org.overture.ast.analysis.AnalysisException; +import org.overture.ast.definitions.SClassDefinition; +import org.overture.codegen.cgast.declarations.AClassDeclCG; +import org.overture.codegen.ir.CodeGenBase; +import org.overture.codegen.ir.IRClassDeclStatus; +import org.overture.codegen.ir.IRGenerator; +import org.overture.codegen.ir.IrNodeInfo; +import org.overture.codegen.ir.VdmNodeInfo; +import org.overture.codegen.logging.ILogger; +import org.overture.codegen.merging.MergeVisitor; +import org.overture.codegen.merging.TemplateCallable; +import org.overture.codegen.merging.TemplateManager; +import org.overture.codegen.merging.TemplateStructure; +import org.overture.codegen.utils.GeneratedModule; +import org.overture.codegen.vdm2java.JavaCodeGenUtil; + +/** + * Main facade class for VDM 2 Isabelle CG + * + * @author ldc + */ +public class IsaCodeGen extends CodeGenBase +{ + public IsaCodeGen() + { + this(null); + } + + public IsaCodeGen(ILogger log) + { + super(log); + + // TODO: Set up template engine (see JavaCodeGen) + // TODO Auto-generated constructor stub + } + + /** + * Main entry point into the Isabelle CG component. Takes an AST and returns corresponding Isabelle Syntax. + * + * @param ast + * of the complete VDM++ model + * @return Isabelly syntax encoded in a string + * @throws AnalysisException + * @throws org.overture.codegen.cgast.analysis.AnalysisException + */ + List generateIsabelleSyntax(List ast) + throws AnalysisException, + org.overture.codegen.cgast.analysis.AnalysisException + { + + // <> + // Transform AST into IR + List statuses = new LinkedList<>(); + for (SClassDefinition clazz : ast) + { + IRClassDeclStatus result = this.generator.generateFrom(clazz); + + if (result.canBeGenerated()) + { + statuses.add(result); + } + } + + // Apply transformations (none atm...) + // Apply merge visitor to pretty print isabelle syntax + + // No utility methods (template callables) added for now + + TemplateStructure ts = new TemplateStructure("IsaTemplates"); + MergeVisitor pp = new MergeVisitor(ts, new TemplateCallable[] {}); + + StringWriter sw = new StringWriter(); + + List generated = new ArrayList(); + + for (IRClassDeclStatus status : statuses) + { + AClassDeclCG irClass = status.getClassCg(); + + irClass.apply(pp, sw); + + if (pp.hasMergeErrors()) + { + generated.add(new GeneratedModule(irClass.getName(), irClass, pp.getMergeErrors())); + } else if (pp.hasUnsupportedTargLangNodes()) + { + generated.add(new GeneratedModule(irClass.getName(), new HashSet(), pp.getUnsupportedInTargLang())); + } else + { + // Code can be generated + // Here should code be formatted + GeneratedModule generatedModule = new GeneratedModule(irClass.getName(), irClass, sw.toString()); + generatedModule.setTransformationWarnings(status.getTransformationWarnings()); + } + + } + + // Return syntax + return generated; + + } + +} From fe8079ca12f889faae9c657b796a49cb20134b46 Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Tue, 17 Feb 2015 13:40:25 +0100 Subject: [PATCH 080/323] Add playground test for cgisa experiments --- .../org/overturetool/cgisa/AdHocTest.java | 85 +++++++++++++++++++ core/cgisa/src/test/resources/test.vdmpp | 7 ++ 2 files changed, 92 insertions(+) create mode 100644 core/cgisa/src/test/java/org/overturetool/cgisa/AdHocTest.java create mode 100644 core/cgisa/src/test/resources/test.vdmpp diff --git a/core/cgisa/src/test/java/org/overturetool/cgisa/AdHocTest.java b/core/cgisa/src/test/java/org/overturetool/cgisa/AdHocTest.java new file mode 100644 index 0000000000..e91d57e8b5 --- /dev/null +++ b/core/cgisa/src/test/java/org/overturetool/cgisa/AdHocTest.java @@ -0,0 +1,85 @@ +package org.overturetool.cgisa; + +import java.io.File; +import java.util.LinkedList; +import java.util.List; +import java.util.Set; + +import org.junit.Test; +import org.overture.ast.analysis.AnalysisException; +import org.overture.ast.definitions.SClassDefinition; +import org.overture.ast.lex.Dialect; +import org.overture.ast.node.INode; +import org.overture.codegen.ir.IrNodeInfo; +import org.overture.codegen.logging.Logger; +import org.overture.codegen.utils.GeneratedModule; +import org.overture.codegen.vdm2java.JavaCodeGenUtil; +import org.overture.core.tests.ParseTcFacade; + +public class AdHocTest +{ + @Test + public void testQuick() throws AnalysisException, org.overture.codegen.cgast.analysis.AnalysisException + { + + File f = new File("src/test/resources/test.vdmpp"); + List files = new LinkedList<>(); + files.add(f); + + List ast = ParseTcFacade.typedAstNoRetry(files, "Quick", Dialect.VDM_PP); + + IsaCodeGen gen = new IsaCodeGen(); + + List classes = new LinkedList<>(); + + for(INode n : ast) + { + classes.add((SClassDefinition) n); + } + + List result = gen.generateIsabelleSyntax(classes); + + for (GeneratedModule generatedClass : result) + { + Logger.getLog().println("**********"); + + if (generatedClass.hasMergeErrors()) + { + Logger.getLog().println(String.format("Class %s could not be merged. Following merge errors were found:", generatedClass.getName())); + + JavaCodeGenUtil.printMergeErrors(generatedClass.getMergeErrors()); + } else if (!generatedClass.canBeGenerated()) + { + Logger.getLog().println("Could not generate class: " + + generatedClass.getName() + "\n"); + + if(generatedClass.hasUnsupportedIrNodes()) + { + Logger.getLog().println("Following VDM constructs are not supported by the IR:"); + JavaCodeGenUtil.printUnsupportedIrNodes(generatedClass.getUnsupportedInIr()); + } + + if(generatedClass.hasUnsupportedTargLangNodes()) + { + Logger.getLog().println("Following IR constructs are not supported by the backend/target languages:"); + JavaCodeGenUtil.printUnsupportedNodes(generatedClass.getUnsupportedInTargLang()); + } + + } else + { + Logger.getLog().println(generatedClass.getContent()); + + Set warnings = generatedClass.getTransformationWarnings(); + + if(!warnings.isEmpty()) + { + Logger.getLog().println("Following transformation warnings were found:"); + JavaCodeGenUtil.printUnsupportedNodes(generatedClass.getTransformationWarnings()); + } + } + + Logger.getLog().println("\n"); + } + + } +} diff --git a/core/cgisa/src/test/resources/test.vdmpp b/core/cgisa/src/test/resources/test.vdmpp new file mode 100644 index 0000000000..bf3c451cc8 --- /dev/null +++ b/core/cgisa/src/test/resources/test.vdmpp @@ -0,0 +1,7 @@ +class A +functions + +f : nat -> nat +f(x) == x; + +end A \ No newline at end of file From 0718714065d972c6f15bea37f5f96e482b4dffb7 Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Tue, 17 Feb 2015 14:50:01 +0100 Subject: [PATCH 081/323] Add support classes for template calls and management. --- .../main/java/org/overturetool/cgisa/Isa.java | 40 +++++++++++++++++++ .../cgisa/IsaTemplateManager.java | 27 +++++++++++++ 2 files changed, 67 insertions(+) create mode 100644 core/cgisa/src/main/java/org/overturetool/cgisa/Isa.java create mode 100644 core/cgisa/src/main/java/org/overturetool/cgisa/IsaTemplateManager.java diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/Isa.java b/core/cgisa/src/main/java/org/overturetool/cgisa/Isa.java new file mode 100644 index 0000000000..5fe831e841 --- /dev/null +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/Isa.java @@ -0,0 +1,40 @@ +package org.overturetool.cgisa; + +import java.io.StringWriter; + +import org.overture.codegen.cgast.INode; +import org.overture.codegen.cgast.analysis.AnalysisException; +import org.overture.codegen.merging.MergeVisitor; +import org.overture.codegen.merging.TemplateCallable; +import org.overture.codegen.merging.TemplateStructure; + +public class Isa +{ + private MergeVisitor mergeVisitor; + + public Isa(TemplateStructure templateStructure) + { + TemplateCallable[] templateCallables = new TemplateCallable[]{new TemplateCallable("Isa",this)}; + this.mergeVisitor = new MergeVisitor(new IsaTemplateManager(templateStructure), templateCallables); + } + + + + + public MergeVisitor getMergeVisitor() + { + return mergeVisitor; + } + + + + + public String trans(INode node) throws AnalysisException + { + StringWriter writer = new StringWriter(); + node.apply(mergeVisitor, writer); + + return writer.toString(); + } + +} diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTemplateManager.java b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTemplateManager.java new file mode 100644 index 0000000000..bbd94f1603 --- /dev/null +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTemplateManager.java @@ -0,0 +1,27 @@ +package org.overturetool.cgisa; + +import org.overture.codegen.cgast.declarations.AFuncDeclCG; +import org.overture.codegen.merging.TemplateManager; +import org.overture.codegen.merging.TemplateStructure; + + +public class IsaTemplateManager extends TemplateManager +{ + + private static final String FUNCTEMPLATE = "Function"; + + public IsaTemplateManager(TemplateStructure templateStructure) + { + super(templateStructure); + initIsaNodes(); + } + + private void initIsaNodes() + { + nodeTemplateFileNames.put(AFuncDeclCG.class, templateStructure.DECL_PATH + FUNCTEMPLATE); + + } + + + +} From 31f7d0514bbd67e5f2aede14346bc13278ad8a89 Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Tue, 17 Feb 2015 14:50:19 +0100 Subject: [PATCH 082/323] Initialize velocity as part of isa codegen. --- .../java/org/overturetool/cgisa/IsaCodeGen.java | 17 +++++++++++++---- 1 file changed, 13 insertions(+), 4 deletions(-) diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaCodeGen.java b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaCodeGen.java index 47c6e12b6f..2f0f353c2a 100644 --- a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaCodeGen.java +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaCodeGen.java @@ -27,6 +27,7 @@ import java.util.LinkedList; import java.util.List; +import org.apache.velocity.app.Velocity; import org.overture.ast.analysis.AnalysisException; import org.overture.ast.definitions.SClassDefinition; import org.overture.codegen.cgast.declarations.AClassDeclCG; @@ -58,11 +59,15 @@ public IsaCodeGen() public IsaCodeGen(ILogger log) { super(log); - - // TODO: Set up template engine (see JavaCodeGen) - // TODO Auto-generated constructor stub + initVelocity(); } + private void initVelocity() + { + Velocity.setProperty("runtime.log.logsystem.class", "org.apache.velocity.runtime.log.NullLogSystem"); + Velocity.init(); + } + /** * Main entry point into the Isabelle CG component. Takes an AST and returns corresponding Isabelle Syntax. * @@ -96,7 +101,10 @@ List generateIsabelleSyntax(List ast) // No utility methods (template callables) added for now TemplateStructure ts = new TemplateStructure("IsaTemplates"); - MergeVisitor pp = new MergeVisitor(ts, new TemplateCallable[] {}); + + Isa isa = new Isa(ts); + + MergeVisitor pp = isa.getMergeVisitor(); StringWriter sw = new StringWriter(); @@ -120,6 +128,7 @@ List generateIsabelleSyntax(List ast) // Here should code be formatted GeneratedModule generatedModule = new GeneratedModule(irClass.getName(), irClass, sw.toString()); generatedModule.setTransformationWarnings(status.getTransformationWarnings()); + generated.add(generatedModule); } } From a4607c3fe8e8b46041c07ab48bb0019748cc897c Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Tue, 17 Feb 2015 14:50:41 +0100 Subject: [PATCH 083/323] Add stub templates for class and function --- .../src/main/resources/IsaTemplates/Declarations/Class.vm | 6 ++++++ .../main/resources/IsaTemplates/Declarations/Function.vm | 1 + 2 files changed, 7 insertions(+) create mode 100644 core/cgisa/src/main/resources/IsaTemplates/Declarations/Class.vm create mode 100644 core/cgisa/src/main/resources/IsaTemplates/Declarations/Function.vm diff --git a/core/cgisa/src/main/resources/IsaTemplates/Declarations/Class.vm b/core/cgisa/src/main/resources/IsaTemplates/Declarations/Class.vm new file mode 100644 index 0000000000..e6f807904a --- /dev/null +++ b/core/cgisa/src/main/resources/IsaTemplates/Declarations/Class.vm @@ -0,0 +1,6 @@ +Hello from $node.getName() + + +#foreach( $func in $node.getFunctions() ) +$Isa.trans($func) +#end \ No newline at end of file diff --git a/core/cgisa/src/main/resources/IsaTemplates/Declarations/Function.vm b/core/cgisa/src/main/resources/IsaTemplates/Declarations/Function.vm new file mode 100644 index 0000000000..6fe78bbba4 --- /dev/null +++ b/core/cgisa/src/main/resources/IsaTemplates/Declarations/Function.vm @@ -0,0 +1 @@ +Hello from $node.getName() From 71ca8b02f8b6d6dab7909dd32adb9184feb14346 Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Tue, 17 Feb 2015 15:00:10 +0100 Subject: [PATCH 084/323] Update header files. [Issue: ] --- core/cgisa/pom.xml | 2 +- .../main/java/org/overturetool/cgisa/Isa.java | 21 +++++++++++++++++++ .../org/overturetool/cgisa/IsaCodeGen.java | 10 +++------ .../cgisa/IsaTemplateManager.java | 21 +++++++++++++++++++ .../org/overturetool/cgisa/AdHocTest.java | 21 +++++++++++++++++++ 5 files changed, 67 insertions(+), 8 deletions(-) diff --git a/core/cgisa/pom.xml b/core/cgisa/pom.xml index def76b14d3..879ef2ac1a 100644 --- a/core/cgisa/pom.xml +++ b/core/cgisa/pom.xml @@ -10,7 +10,7 @@ org.overturetool.core cgisa - Isabelle Code Generation + VDM to Isabelle Code Generation diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/Isa.java b/core/cgisa/src/main/java/org/overturetool/cgisa/Isa.java index 5fe831e841..f9711f31f1 100644 --- a/core/cgisa/src/main/java/org/overturetool/cgisa/Isa.java +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/Isa.java @@ -1,3 +1,24 @@ +/* + * #%~ + * VDM to Isabelle Code Generation + * %% + * Copyright (C) 2008 - 2015 Overture + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program. If not, see + * . + * #~% + */ package org.overturetool.cgisa; import java.io.StringWriter; diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaCodeGen.java b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaCodeGen.java index 2f0f353c2a..b2fafd4ff8 100644 --- a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaCodeGen.java +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaCodeGen.java @@ -1,8 +1,8 @@ /* * #%~ - * VDM to Isabelle Code Generator + * VDM to Isabelle Code Generation * %% - * Copyright (C) 2008 - 2014 Overture + * Copyright (C) 2008 - 2015 Overture * %% * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as @@ -19,6 +19,7 @@ * . * #~% */ + package org.overturetool.cgisa; import java.io.StringWriter; @@ -33,16 +34,11 @@ import org.overture.codegen.cgast.declarations.AClassDeclCG; import org.overture.codegen.ir.CodeGenBase; import org.overture.codegen.ir.IRClassDeclStatus; -import org.overture.codegen.ir.IRGenerator; -import org.overture.codegen.ir.IrNodeInfo; import org.overture.codegen.ir.VdmNodeInfo; import org.overture.codegen.logging.ILogger; import org.overture.codegen.merging.MergeVisitor; -import org.overture.codegen.merging.TemplateCallable; -import org.overture.codegen.merging.TemplateManager; import org.overture.codegen.merging.TemplateStructure; import org.overture.codegen.utils.GeneratedModule; -import org.overture.codegen.vdm2java.JavaCodeGenUtil; /** * Main facade class for VDM 2 Isabelle CG diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTemplateManager.java b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTemplateManager.java index bbd94f1603..333a482996 100644 --- a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTemplateManager.java +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTemplateManager.java @@ -1,3 +1,24 @@ +/* + * #%~ + * VDM to Isabelle Code Generation + * %% + * Copyright (C) 2008 - 2015 Overture + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program. If not, see + * . + * #~% + */ package org.overturetool.cgisa; import org.overture.codegen.cgast.declarations.AFuncDeclCG; diff --git a/core/cgisa/src/test/java/org/overturetool/cgisa/AdHocTest.java b/core/cgisa/src/test/java/org/overturetool/cgisa/AdHocTest.java index e91d57e8b5..314d1e461a 100644 --- a/core/cgisa/src/test/java/org/overturetool/cgisa/AdHocTest.java +++ b/core/cgisa/src/test/java/org/overturetool/cgisa/AdHocTest.java @@ -1,3 +1,24 @@ +/* + * #%~ + * VDM to Isabelle Code Generation + * %% + * Copyright (C) 2008 - 2015 Overture + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program. If not, see + * . + * #~% + */ package org.overturetool.cgisa; import java.io.File; From fb9d285bd509d2b09f21df5e9547fab06e893e3f Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Tue, 17 Feb 2015 16:12:46 +0100 Subject: [PATCH 085/323] Rename Isa to sth. more descriptive The template callables allows us to to give it an alias in the velocity templates. --- .../org/overturetool/cgisa/IsaCodeGen.java | 2 +- .../cgisa/{Isa.java => IsaTemplateUtils.java} | 46 ++++++++++++++----- 2 files changed, 36 insertions(+), 12 deletions(-) rename core/cgisa/src/main/java/org/overturetool/cgisa/{Isa.java => IsaTemplateUtils.java} (61%) diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaCodeGen.java b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaCodeGen.java index b2fafd4ff8..29c6f78795 100644 --- a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaCodeGen.java +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaCodeGen.java @@ -98,7 +98,7 @@ List generateIsabelleSyntax(List ast) TemplateStructure ts = new TemplateStructure("IsaTemplates"); - Isa isa = new Isa(ts); + IsaTemplateUtils isa = new IsaTemplateUtils(ts); MergeVisitor pp = isa.getMergeVisitor(); diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/Isa.java b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTemplateUtils.java similarity index 61% rename from core/cgisa/src/main/java/org/overturetool/cgisa/Isa.java rename to core/cgisa/src/main/java/org/overturetool/cgisa/IsaTemplateUtils.java index f9711f31f1..9658eff67d 100644 --- a/core/cgisa/src/main/java/org/overturetool/cgisa/Isa.java +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTemplateUtils.java @@ -22,34 +22,59 @@ package org.overturetool.cgisa; import java.io.StringWriter; +import java.util.Iterator; +import java.util.List; import org.overture.codegen.cgast.INode; import org.overture.codegen.cgast.analysis.AnalysisException; +import org.overture.codegen.cgast.declarations.AFormalParamLocalParamCG; import org.overture.codegen.merging.MergeVisitor; import org.overture.codegen.merging.TemplateCallable; import org.overture.codegen.merging.TemplateStructure; -public class Isa +public class IsaTemplateUtils { + + private static final String TEMPLATE_CALLABLE_NAME = "Isa"; + private static final Object PARAM_SEP = " and "; private MergeVisitor mergeVisitor; - - public Isa(TemplateStructure templateStructure) + + public IsaTemplateUtils(TemplateStructure templateStructure) { - TemplateCallable[] templateCallables = new TemplateCallable[]{new TemplateCallable("Isa",this)}; + TemplateCallable[] templateCallables = new TemplateCallable[] { new TemplateCallable(TEMPLATE_CALLABLE_NAME, this) }; this.mergeVisitor = new MergeVisitor(new IsaTemplateManager(templateStructure), templateCallables); } - - - - + public MergeVisitor getMergeVisitor() { return mergeVisitor; } + public String norm(String name) + { + return name; + } - - + public String trans(List params) throws AnalysisException{ + StringBuilder sb = new StringBuilder(); + + Iterator it = params.iterator(); + + while (it.hasNext()){ + StringWriter writer = new StringWriter(); + it.next().apply(mergeVisitor, writer); + sb.append(writer.toString()); + if (it.hasNext()){ + sb.append(PARAM_SEP); + } + + } + + + return sb.toString(); + + } + public String trans(INode node) throws AnalysisException { StringWriter writer = new StringWriter(); @@ -57,5 +82,4 @@ public String trans(INode node) throws AnalysisException return writer.toString(); } - } From ce8555ef5d8ef3d54117d4c28dcbb9e65838a63a Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Tue, 17 Feb 2015 16:14:01 +0100 Subject: [PATCH 086/323] Clean class template --- .../main/resources/IsaTemplates/Declarations/Class.vm | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/core/cgisa/src/main/resources/IsaTemplates/Declarations/Class.vm b/core/cgisa/src/main/resources/IsaTemplates/Declarations/Class.vm index e6f807904a..cb26554798 100644 --- a/core/cgisa/src/main/resources/IsaTemplates/Declarations/Class.vm +++ b/core/cgisa/src/main/resources/IsaTemplates/Declarations/Class.vm @@ -1,6 +1,9 @@ -Hello from $node.getName() +theory $Isa.norm($node.Name) + imports utp_cml +begin - -#foreach( $func in $node.getFunctions() ) +#foreach( $func in $node.Functions ) $Isa.trans($func) -#end \ No newline at end of file +#end + +end \ No newline at end of file From 0ad6ee5d45dc4ba3246ceacf804137362b9b18f5 Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Tue, 17 Feb 2015 16:14:41 +0100 Subject: [PATCH 087/323] Add FormalParamTemplate; rename Function constant --- .../java/org/overturetool/cgisa/IsaTemplateManager.java | 7 +++++-- .../main/resources/IsaTemplates/Declarations/Function.vm | 5 ++++- .../main/resources/IsaTemplates/LocalDecls/FormalParam.vm | 1 + 3 files changed, 10 insertions(+), 3 deletions(-) create mode 100644 core/cgisa/src/main/resources/IsaTemplates/LocalDecls/FormalParam.vm diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTemplateManager.java b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTemplateManager.java index 333a482996..d2b2443f42 100644 --- a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTemplateManager.java +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTemplateManager.java @@ -21,6 +21,7 @@ */ package org.overturetool.cgisa; +import org.overture.codegen.cgast.declarations.AFormalParamLocalParamCG; import org.overture.codegen.cgast.declarations.AFuncDeclCG; import org.overture.codegen.merging.TemplateManager; import org.overture.codegen.merging.TemplateStructure; @@ -29,7 +30,8 @@ public class IsaTemplateManager extends TemplateManager { - private static final String FUNCTEMPLATE = "Function"; + private static final String FUNC_TEMPLATE = "Function"; + private static final String FORMAL_PARAM = "FormalParam"; public IsaTemplateManager(TemplateStructure templateStructure) { @@ -39,7 +41,8 @@ public IsaTemplateManager(TemplateStructure templateStructure) private void initIsaNodes() { - nodeTemplateFileNames.put(AFuncDeclCG.class, templateStructure.DECL_PATH + FUNCTEMPLATE); + nodeTemplateFileNames.put(AFuncDeclCG.class, templateStructure.DECL_PATH + FUNC_TEMPLATE); + nodeTemplateFileNames.put(AFormalParamLocalParamCG.class, templateStructure.LOCAL_DECLS_PATH + FORMAL_PARAM); } diff --git a/core/cgisa/src/main/resources/IsaTemplates/Declarations/Function.vm b/core/cgisa/src/main/resources/IsaTemplates/Declarations/Function.vm index 6fe78bbba4..2f123ac8da 100644 --- a/core/cgisa/src/main/resources/IsaTemplates/Declarations/Function.vm +++ b/core/cgisa/src/main/resources/IsaTemplates/Declarations/Function.vm @@ -1 +1,4 @@ -Hello from $node.getName() +cmlefun $node.Name + inp $Isa.trans($node.FormalParams) + out "@type" + is "body" \ No newline at end of file diff --git a/core/cgisa/src/main/resources/IsaTemplates/LocalDecls/FormalParam.vm b/core/cgisa/src/main/resources/IsaTemplates/LocalDecls/FormalParam.vm new file mode 100644 index 0000000000..f28295c0da --- /dev/null +++ b/core/cgisa/src/main/resources/IsaTemplates/LocalDecls/FormalParam.vm @@ -0,0 +1 @@ +$Isa.trans($node.Pattern) :: $Isa.trans($node.Type) \ No newline at end of file From 6f5b598133386b3150b85c72a28116430594863c Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Tue, 17 Feb 2015 16:15:18 +0100 Subject: [PATCH 088/323] Add Identifier pattern and basic type Nat templates. --- core/cgisa/src/main/resources/IsaTemplates/Pattern/Identifier.vm | 1 + core/cgisa/src/main/resources/IsaTemplates/Types/Basic/Nat.vm | 1 + 2 files changed, 2 insertions(+) create mode 100644 core/cgisa/src/main/resources/IsaTemplates/Pattern/Identifier.vm create mode 100644 core/cgisa/src/main/resources/IsaTemplates/Types/Basic/Nat.vm diff --git a/core/cgisa/src/main/resources/IsaTemplates/Pattern/Identifier.vm b/core/cgisa/src/main/resources/IsaTemplates/Pattern/Identifier.vm new file mode 100644 index 0000000000..305d477e9f --- /dev/null +++ b/core/cgisa/src/main/resources/IsaTemplates/Pattern/Identifier.vm @@ -0,0 +1 @@ +$Isa.norm($node.Name) \ No newline at end of file diff --git a/core/cgisa/src/main/resources/IsaTemplates/Types/Basic/Nat.vm b/core/cgisa/src/main/resources/IsaTemplates/Types/Basic/Nat.vm new file mode 100644 index 0000000000..193d7efdba --- /dev/null +++ b/core/cgisa/src/main/resources/IsaTemplates/Types/Basic/Nat.vm @@ -0,0 +1 @@ +"@nat" \ No newline at end of file From 5ffa6840b3525437181255acdfa0b462b946c763 Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Tue, 17 Feb 2015 16:55:47 +0100 Subject: [PATCH 089/323] Dont run AdHoc test in maven --- .../java/org/overturetool/cgisa/{AdHocTest.java => AdHoc.java} | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) rename core/cgisa/src/test/java/org/overturetool/cgisa/{AdHocTest.java => AdHoc.java} (99%) diff --git a/core/cgisa/src/test/java/org/overturetool/cgisa/AdHocTest.java b/core/cgisa/src/test/java/org/overturetool/cgisa/AdHoc.java similarity index 99% rename from core/cgisa/src/test/java/org/overturetool/cgisa/AdHocTest.java rename to core/cgisa/src/test/java/org/overturetool/cgisa/AdHoc.java index 314d1e461a..a2075b0d39 100644 --- a/core/cgisa/src/test/java/org/overturetool/cgisa/AdHocTest.java +++ b/core/cgisa/src/test/java/org/overturetool/cgisa/AdHoc.java @@ -37,7 +37,7 @@ import org.overture.codegen.vdm2java.JavaCodeGenUtil; import org.overture.core.tests.ParseTcFacade; -public class AdHocTest +public class AdHoc { @Test public void testQuick() throws AnalysisException, org.overture.codegen.cgast.analysis.AnalysisException From 19e4ed3170b977f1d771a04805cb1e7e7b60998b Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Tue, 17 Feb 2015 16:57:04 +0100 Subject: [PATCH 090/323] Initial, basic test setup for CGIsa Errors are simplistically represented with a single boolean. Translations are encoded as lists of strings and compared via string equality. --- .../overturetool/cgisa/CgIsaParamTest.java | 90 ++++++++++++++++++ .../overturetool/cgisa/CgIsaTestResult.java | 93 +++++++++++++++++++ 2 files changed, 183 insertions(+) create mode 100644 core/cgisa/src/test/java/org/overturetool/cgisa/CgIsaParamTest.java create mode 100644 core/cgisa/src/test/java/org/overturetool/cgisa/CgIsaTestResult.java diff --git a/core/cgisa/src/test/java/org/overturetool/cgisa/CgIsaParamTest.java b/core/cgisa/src/test/java/org/overturetool/cgisa/CgIsaParamTest.java new file mode 100644 index 0000000000..bc9266b872 --- /dev/null +++ b/core/cgisa/src/test/java/org/overturetool/cgisa/CgIsaParamTest.java @@ -0,0 +1,90 @@ +package org.overturetool.cgisa; + +import java.lang.reflect.Type; +import java.util.Collection; +import java.util.LinkedList; +import java.util.List; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.fail; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; +import org.junit.runners.Parameterized.Parameters; +import org.overture.ast.analysis.AnalysisException; +import org.overture.ast.definitions.SClassDefinition; +import org.overture.ast.node.INode; +import org.overture.codegen.utils.GeneratedModule; +import org.overture.core.tests.ParamStandardTest; +import org.overture.core.tests.PathsProvider; + +import com.google.gson.reflect.TypeToken; + +@RunWith(Parameterized.class) +public class CgIsaParamTest extends ParamStandardTest +{ + + public CgIsaParamTest(String nameParameter, String inputParameter, + String resultParameter) + { + super(nameParameter, inputParameter, resultParameter); + } + + private static final String UPDATE = "tests.update.cgisa"; + private static final String CGISA_ROOT = "src/test/resources/micro"; + + @Override + public CgIsaTestResult processModel(List ast) + { + IsaCodeGen gen = new IsaCodeGen(); + + List classes = new LinkedList<>(); + + for (INode n : ast) + { + classes.add((SClassDefinition) n); + } + + List result; + try + { + result = gen.generateIsabelleSyntax(classes); + } catch (AnalysisException + | org.overture.codegen.cgast.analysis.AnalysisException e) + { + fail("Could not process test file " + testName); + return null; + } + + return CgIsaTestResult.convert(result); + } + + @Parameters(name = "{index} : {0}") + public static Collection testData() + { + return PathsProvider.computePaths(CGISA_ROOT); + } + + @Override + public Type getResultType() + { + Type resultType = new TypeToken() + { + }.getType(); + return resultType; + } + + @Override + protected String getUpdatePropertyString() + { + return UPDATE; + } + + @Override + public void compareResults(CgIsaTestResult actual, CgIsaTestResult expected) + { + assertEquals(expected, actual); + + } + +} diff --git a/core/cgisa/src/test/java/org/overturetool/cgisa/CgIsaTestResult.java b/core/cgisa/src/test/java/org/overturetool/cgisa/CgIsaTestResult.java new file mode 100644 index 0000000000..90eeb139d6 --- /dev/null +++ b/core/cgisa/src/test/java/org/overturetool/cgisa/CgIsaTestResult.java @@ -0,0 +1,93 @@ +package org.overturetool.cgisa; + +import java.util.LinkedList; +import java.util.List; + +import org.overture.codegen.utils.GeneratedModule; + +public class CgIsaTestResult +{ + List translation; + boolean errors; + + public CgIsaTestResult() + { + } + + private CgIsaTestResult(List translation, boolean errors) + { + super(); + this.translation = translation; + this.errors = errors; + } + + + + @Override + public String toString() + { + return "CgIsaTestResult [translation=" + translation + ", errors=" + + errors + "]"; + } + + @Override + public int hashCode() + { + final int prime = 31; + int result = 1; + result = prime * result + (errors ? 1231 : 1237); + result = prime * result + + ((translation == null) ? 0 : translation.hashCode()); + return result; + } + + @Override + public boolean equals(Object obj) + { + if (this == obj) + return true; + if (obj == null) + return false; + if (getClass() != obj.getClass()) + return false; + CgIsaTestResult other = (CgIsaTestResult) obj; + if (errors != other.errors) + return false; + if (translation == null) + { + if (other.translation != null) + return false; + } else if (!translation.equals(other.translation)) + return false; + return true; + } + + public static CgIsaTestResult convert(List result) + { + List trans = new LinkedList<>(); + boolean err = false; + + for (GeneratedModule g : result) + { + if (g.hasMergeErrors()) + { + err = true; + + } else if (!g.canBeGenerated()) + { + err = true; + } else if (g.hasUnsupportedIrNodes()) + { + err = true; + } + + else + { + trans.add(g.getContent()); + + } + + } + return new CgIsaTestResult(trans, err); + } +} From e4c641636a1212ac0e97e12ba6985b18ce5079f3 Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Tue, 17 Feb 2015 16:57:27 +0100 Subject: [PATCH 091/323] 3 initial tests for functions with 0-2 parameters Results will need to be updated as we go. --- core/cgisa/src/test/resources/micro/Func1Param.vdmpp | 7 +++++++ .../cgisa/src/test/resources/micro/Func1Param.vdmpp.result | 1 + core/cgisa/src/test/resources/micro/Func2Params.vdmpp | 7 +++++++ .../src/test/resources/micro/Func2Params.vdmpp.result | 1 + core/cgisa/src/test/resources/micro/FuncNoParam.vdmpp | 7 +++++++ .../src/test/resources/micro/FuncNoParam.vdmpp.result | 1 + 6 files changed, 24 insertions(+) create mode 100644 core/cgisa/src/test/resources/micro/Func1Param.vdmpp create mode 100644 core/cgisa/src/test/resources/micro/Func1Param.vdmpp.result create mode 100644 core/cgisa/src/test/resources/micro/Func2Params.vdmpp create mode 100644 core/cgisa/src/test/resources/micro/Func2Params.vdmpp.result create mode 100644 core/cgisa/src/test/resources/micro/FuncNoParam.vdmpp create mode 100644 core/cgisa/src/test/resources/micro/FuncNoParam.vdmpp.result diff --git a/core/cgisa/src/test/resources/micro/Func1Param.vdmpp b/core/cgisa/src/test/resources/micro/Func1Param.vdmpp new file mode 100644 index 0000000000..bf3c451cc8 --- /dev/null +++ b/core/cgisa/src/test/resources/micro/Func1Param.vdmpp @@ -0,0 +1,7 @@ +class A +functions + +f : nat -> nat +f(x) == x; + +end A \ No newline at end of file diff --git a/core/cgisa/src/test/resources/micro/Func1Param.vdmpp.result b/core/cgisa/src/test/resources/micro/Func1Param.vdmpp.result new file mode 100644 index 0000000000..26ee64b4d7 --- /dev/null +++ b/core/cgisa/src/test/resources/micro/Func1Param.vdmpp.result @@ -0,0 +1 @@ +{"translation":["theory A\n imports utp_cml\nbegin\n\ncmlefun f\n inp x :: \"@nat\"\n out \"@type\"\n is \"body\"\n\nend"],"errors":false} \ No newline at end of file diff --git a/core/cgisa/src/test/resources/micro/Func2Params.vdmpp b/core/cgisa/src/test/resources/micro/Func2Params.vdmpp new file mode 100644 index 0000000000..2386ab8888 --- /dev/null +++ b/core/cgisa/src/test/resources/micro/Func2Params.vdmpp @@ -0,0 +1,7 @@ +class A +functions + +f : nat * nat -> nat +f(x,y) == x; + +end A \ No newline at end of file diff --git a/core/cgisa/src/test/resources/micro/Func2Params.vdmpp.result b/core/cgisa/src/test/resources/micro/Func2Params.vdmpp.result new file mode 100644 index 0000000000..7011e1cdf5 --- /dev/null +++ b/core/cgisa/src/test/resources/micro/Func2Params.vdmpp.result @@ -0,0 +1 @@ +{"translation":["theory A\n imports utp_cml\nbegin\n\ncmlefun f\n inp x :: \"@nat\" and y :: \"@nat\"\n out \"@type\"\n is \"body\"\n\nend"],"errors":false} \ No newline at end of file diff --git a/core/cgisa/src/test/resources/micro/FuncNoParam.vdmpp b/core/cgisa/src/test/resources/micro/FuncNoParam.vdmpp new file mode 100644 index 0000000000..a3f92c9e46 --- /dev/null +++ b/core/cgisa/src/test/resources/micro/FuncNoParam.vdmpp @@ -0,0 +1,7 @@ +class A +functions + +f : () -> nat +f() == 0; + +end A \ No newline at end of file diff --git a/core/cgisa/src/test/resources/micro/FuncNoParam.vdmpp.result b/core/cgisa/src/test/resources/micro/FuncNoParam.vdmpp.result new file mode 100644 index 0000000000..8aea44912f --- /dev/null +++ b/core/cgisa/src/test/resources/micro/FuncNoParam.vdmpp.result @@ -0,0 +1 @@ +{"translation":["theory A\n imports utp_cml\nbegin\n\ncmlefun f\n inp \n out \"@type\"\n is \"body\"\n\nend"],"errors":false} \ No newline at end of file From 39739420142f1b9fadcc6d87e0a149bfc81591a2 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Thu, 19 Feb 2015 00:03:52 +0100 Subject: [PATCH 092/323] Added two tests revealing problem with use of patterns in 'trace let be st' --- .../traces_expansion_specs/LetBeStRecPattern | 23 ++++ .../LetBeStRecPattern.result | 107 ++++++++++++++++++ .../traces_expansion_specs/LetBeStTupPattern | 15 +++ .../LetBeStTupPattern.result | 91 +++++++++++++++ 4 files changed, 236 insertions(+) create mode 100644 core/codegen/src/test/resources/traces_expansion_specs/LetBeStRecPattern create mode 100644 core/codegen/src/test/resources/traces_expansion_specs/LetBeStRecPattern.result create mode 100644 core/codegen/src/test/resources/traces_expansion_specs/LetBeStTupPattern create mode 100644 core/codegen/src/test/resources/traces_expansion_specs/LetBeStTupPattern.result diff --git a/core/codegen/src/test/resources/traces_expansion_specs/LetBeStRecPattern b/core/codegen/src/test/resources/traces_expansion_specs/LetBeStRecPattern new file mode 100644 index 0000000000..6e2137cb0c --- /dev/null +++ b/core/codegen/src/test/resources/traces_expansion_specs/LetBeStRecPattern @@ -0,0 +1,23 @@ +class Entry + +values + +xs : set of (nat | A) = {1,2,3,4,mk_A(5), 6, 7, 8} + +types + +A :: a : int; + +operations + +id : nat ==> nat +id (x) == return x; + +traces + +T1: +let mk_A(a) in set xs be st a = 5 +in + id(a); + +end Entry \ No newline at end of file diff --git a/core/codegen/src/test/resources/traces_expansion_specs/LetBeStRecPattern.result b/core/codegen/src/test/resources/traces_expansion_specs/LetBeStRecPattern.result new file mode 100644 index 0000000000..ad3312d04c --- /dev/null +++ b/core/codegen/src/test/resources/traces_expansion_specs/LetBeStRecPattern.result @@ -0,0 +1,107 @@ +import org.overture.codegen.runtime.*; +import org.overture.codegen.runtime.traces.*; + +import java.util.*; + + +public class Entry implements java.io.Serializable { + private static final VDMSet xs = SetUtil.set(1L, 2L, 3L, 4L, new A(5L), 6L, + 7L, 8L); + + public Entry() { + } + + private Number id(final Number x) { + return x; + } + + public void Entry_T1_Run(final TestAccumulator testAccumulator) { + final Store store = new Store(); + final IdGenerator gen = new IdGenerator(); + SequenceTraceNode sequence_1 = new SequenceTraceNode(); + AlternativeTraceNode alternatives_2 = new AlternativeTraceNode(); + VDMSet set_1 = Utils.clone(xs); + + for (Iterator iterator_1 = set_1.iterator(); iterator_1.hasNext();) { + final Object recordPattern_1 = ((Object) iterator_1.next()); + Boolean success_2 = true; + Number a = null; + + if (recordPattern_1 instanceof A) { + a = ((A) recordPattern_1).a; + } else { + success_2 = false; + } + + if (!(success_2)) { + continue; + } + + if (!(Utils.equals(a, 5L))) { + continue; + } + + final Number ID_1 = gen.inc(); + + store.register(ID_1, a); + + CallStatement callStm_1 = new CallStatement() { + public Object execute(final Object instance) { + Number result_1 = ((Entry) instance).id(((Number) store.getValue( + ID_1))); + + return result_1; + } + + public String toString() { + return "id(" + + Utils.toString(((Number) store.getValue(ID_1))) + ")"; + } + }; + + StatementTraceNode apply_1 = new StatementTraceNode(callStm_1); + + alternatives_2.add(apply_1); + } + + sequence_1.add(alternatives_2); + + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); + } + + public String toString() { + return "Entry{" + "xs = " + Utils.toString(xs) + "}"; + } + + private static class A implements Record { + public Number a; + + public A(final Number _a) { + a = _a; + } + + public boolean equals(final Object obj) { + if (!(obj instanceof A)) { + return false; + } + + A other = ((A) obj); + + return Utils.equals(a, other.a); + } + + public int hashCode() { + return Utils.hashCode(a); + } + + public A clone() { + return new A(a); + } + + public String toString() { + return "mk_Entry`A" + Utils.formatFields(a); + } + } +} + +########## diff --git a/core/codegen/src/test/resources/traces_expansion_specs/LetBeStTupPattern b/core/codegen/src/test/resources/traces_expansion_specs/LetBeStTupPattern new file mode 100644 index 0000000000..1fc799a391 --- /dev/null +++ b/core/codegen/src/test/resources/traces_expansion_specs/LetBeStTupPattern @@ -0,0 +1,15 @@ +class Entry + +functions + +public f : nat -> nat +f (x) == x; + +traces + +T1: +let mk_(a,b) in set { mk_(1,2)} +in + (f(a);f(b)){1,2} + +end Entry \ No newline at end of file diff --git a/core/codegen/src/test/resources/traces_expansion_specs/LetBeStTupPattern.result b/core/codegen/src/test/resources/traces_expansion_specs/LetBeStTupPattern.result new file mode 100644 index 0000000000..a3fc9003e8 --- /dev/null +++ b/core/codegen/src/test/resources/traces_expansion_specs/LetBeStTupPattern.result @@ -0,0 +1,91 @@ +import org.overture.codegen.runtime.*; +import org.overture.codegen.runtime.traces.*; + +import java.util.*; + + +public class Entry implements java.io.Serializable { + public Entry() { + } + + public static Number f(final Number x) { + return x; + } + + public void Entry_T1_Run(final TestAccumulator testAccumulator) { + final Store store = new Store(); + final IdGenerator gen = new IdGenerator(); + SequenceTraceNode sequence_1 = new SequenceTraceNode(); + AlternativeTraceNode alternatives_2 = new AlternativeTraceNode(); + VDMSet set_1 = SetUtil.set(Tuple.mk_(1L, 2L)); + + for (Iterator iterator_1 = set_1.iterator(); iterator_1.hasNext();) { + final Tuple tuplePattern_1 = ((Tuple) iterator_1.next()); + Boolean success_2 = tuplePattern_1.compatible(Number.class, + Number.class); + Number a = null; + Number b = null; + + if (success_2) { + a = ((Number) tuplePattern_1.get(0)); + b = ((Number) tuplePattern_1.get(1)); + } + + if (!(success_2)) { + continue; + } + + final Number ID_1 = gen.inc(); + + store.register(ID_1, a); + + final Number ID_2 = gen.inc(); + + store.register(ID_2, b); + + SequenceTraceNode sequence_2 = new SequenceTraceNode(); + CallStatement callStm_1 = new CallStatement() { + public Object execute(final Object instance) { + return f(((Number) store.getValue(ID_1))); + } + + public String toString() { + return "f(" + + Utils.toString(((Number) store.getValue(ID_1))) + ")"; + } + }; + + StatementTraceNode apply_1 = new StatementTraceNode(callStm_1); + + CallStatement callStm_2 = new CallStatement() { + public Object execute(final Object instance) { + return f(((Number) store.getValue(ID_2))); + } + + public String toString() { + return "f(" + + Utils.toString(((Number) store.getValue(ID_2))) + ")"; + } + }; + + StatementTraceNode apply_2 = new StatementTraceNode(callStm_2); + + sequence_2.add(apply_1); + sequence_2.add(apply_2); + + RepeatTraceNode repeat_1 = new RepeatTraceNode(sequence_2, 1L, 2L); + + alternatives_2.add(repeat_1); + } + + sequence_1.add(alternatives_2); + + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); + } + + public String toString() { + return "Entry{}"; + } +} + +########## From 9d7b6c251061eb8a6a43fad7fe495ad02464ebd3 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Thu, 19 Feb 2015 00:05:54 +0100 Subject: [PATCH 093/323] Fix for problem with code generation of pattern matching in 'trace let be st' --- .../codegen/traces/TraceLetBeStStrategy.java | 26 +++++++++++-------- .../codegen/traces/TraceStmsBuilder.java | 8 +++--- 2 files changed, 20 insertions(+), 14 deletions(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/TraceLetBeStStrategy.java b/core/codegen/src/main/java/org/overture/codegen/traces/TraceLetBeStStrategy.java index 5a06495d06..f3366981c4 100644 --- a/core/codegen/src/main/java/org/overture/codegen/traces/TraceLetBeStStrategy.java +++ b/core/codegen/src/main/java/org/overture/codegen/traces/TraceLetBeStStrategy.java @@ -10,6 +10,7 @@ import org.overture.codegen.cgast.analysis.AnalysisException; import org.overture.codegen.cgast.declarations.AVarDeclCG; import org.overture.codegen.cgast.expressions.AIdentifierVarExpCG; +import org.overture.codegen.cgast.expressions.ANullExpCG; import org.overture.codegen.cgast.patterns.AIdentifierPatternCG; import org.overture.codegen.cgast.statements.ABlockStmCG; import org.overture.codegen.cgast.statements.ACallObjectExpStmCG; @@ -18,7 +19,7 @@ import org.overture.codegen.cgast.statements.ALocalPatternAssignmentStmCG; import org.overture.codegen.cgast.types.SSetTypeCG; import org.overture.codegen.ir.ITempVarGen; -import org.overture.codegen.logging.Logger; +import org.overture.codegen.trans.DeclarationTag; import org.overture.codegen.trans.TempVarPrefixes; import org.overture.codegen.trans.assistants.TransAssistantCG; import org.overture.codegen.trans.iterator.ILanguageIterator; @@ -56,7 +57,7 @@ public List getOuterBlockDecls(AIdentifierVarExpCG setVar, for (SPatternCG id : patterns) { AVarDeclCG decl = transAssistant.getInfo().getDeclAssistant(). - consLocalVarDecl(setType, id, null); + consLocalVarDecl(setType.getSetOf().clone(), id.clone(), new ANullExpCG()); decl.setFinal(true); decls.add(decl); } @@ -79,6 +80,12 @@ public SExpCG getForLoopCond(AIdentifierVarExpCG setVar, return langIterator.getForLoopCond(setVar, patterns, pattern); } + @Override + public DeclarationTag consDeclarationTag() + { + return new DeclarationTag(false, successVarDecl); + } + @Override public AVarDeclCG getNextElementDeclared(AIdentifierVarExpCG setVar, List patterns, SPatternCG pattern) @@ -115,20 +122,17 @@ public List getForLoopStms(AIdentifierVarExpCG setVar, } AVarDeclCG nextElementDecl = decls.get(count - 1); - if(nextElementDecl.getPattern() instanceof AIdentifierPatternCG) + + + IdentifierPatternCollector idCollector = new IdentifierPatternCollector(); + idCollector.setTopNode(nextElementDecl); + + for(AIdentifierPatternCG idToReg : idCollector.findOccurences()) { - AIdentifierPatternCG idToReg = (AIdentifierPatternCG) nextElementDecl.getPattern(); String idConstName = idConstNameMap.get(idToReg.getName()); block.getStatements().add(transAssistant.wrap(storeAssistant.consIdConstDecl(idConstName))); storeAssistant.appendStoreRegStms(block, idToReg.getName(), idConstName); } - else - { - Logger.getLog().printErrorln("This should not happen. Only identifier patterns " - + "are currently supported in traces (see the TraceSupportedAnalysis class)."); - return null; - } - block.getStatements().add(nodeData.getStms()); diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/TraceStmsBuilder.java b/core/codegen/src/main/java/org/overture/codegen/traces/TraceStmsBuilder.java index 2083f1c578..87774971fb 100644 --- a/core/codegen/src/main/java/org/overture/codegen/traces/TraceStmsBuilder.java +++ b/core/codegen/src/main/java/org/overture/codegen/traces/TraceStmsBuilder.java @@ -204,9 +204,11 @@ public TraceNodeData caseALetBeStBindingTraceDeclCG( { ASetMultipleBindCG bind = node.getBind(); - LinkedList patterns = bind.getPatterns(); - //TODO: Can the pattern not be other patterns? Use a pattern collector here? + IdentifierPatternCollector idCollector = new IdentifierPatternCollector(); + idCollector.setTopNode(bind); + List patterns = idCollector.findOccurences(); + for(SPatternCG p : patterns) { if(p instanceof AIdentifierPatternCG) @@ -239,7 +241,7 @@ public TraceNodeData caseALetBeStBindingTraceDeclCG( return new TraceNodeData(null, transAssistant.wrap(new ASkipStmCG())); } - ABlockStmCG outerBlock = transAssistant.consIterationBlock(patterns, bind.getSet(), info.getTempVarNameGen(), strategy); + ABlockStmCG outerBlock = transAssistant.consIterationBlock(node.getBind().getPatterns(), bind.getSet(), info.getTempVarNameGen(), strategy); return new TraceNodeData(transAssistant.consIdentifierVar(name, classType.clone()), transAssistant.wrap(outerBlock)); } From dc2811c6f27ddb37f7ca1a40643e64ac3b61ffab Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Thu, 19 Feb 2015 15:39:49 +0100 Subject: [PATCH 094/323] Rename Template to Translation. --- .../src/main/java/org/overturetool/cgisa/IsaCodeGen.java | 2 +- .../cgisa/{IsaTemplateUtils.java => IsaTranslationUtils.java} | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) rename core/cgisa/src/main/java/org/overturetool/cgisa/{IsaTemplateUtils.java => IsaTranslationUtils.java} (95%) diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaCodeGen.java b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaCodeGen.java index 29c6f78795..506a73c918 100644 --- a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaCodeGen.java +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaCodeGen.java @@ -98,7 +98,7 @@ List generateIsabelleSyntax(List ast) TemplateStructure ts = new TemplateStructure("IsaTemplates"); - IsaTemplateUtils isa = new IsaTemplateUtils(ts); + IsaTranslationUtils isa = new IsaTranslationUtils(ts); MergeVisitor pp = isa.getMergeVisitor(); diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTemplateUtils.java b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslationUtils.java similarity index 95% rename from core/cgisa/src/main/java/org/overturetool/cgisa/IsaTemplateUtils.java rename to core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslationUtils.java index 9658eff67d..bb04007596 100644 --- a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTemplateUtils.java +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslationUtils.java @@ -32,14 +32,14 @@ import org.overture.codegen.merging.TemplateCallable; import org.overture.codegen.merging.TemplateStructure; -public class IsaTemplateUtils +public class IsaTranslationUtils { private static final String TEMPLATE_CALLABLE_NAME = "Isa"; private static final Object PARAM_SEP = " and "; private MergeVisitor mergeVisitor; - public IsaTemplateUtils(TemplateStructure templateStructure) + public IsaTranslationUtils(TemplateStructure templateStructure) { TemplateCallable[] templateCallables = new TemplateCallable[] { new TemplateCallable(TEMPLATE_CALLABLE_NAME, this) }; this.mergeVisitor = new MergeVisitor(new IsaTemplateManager(templateStructure), templateCallables); From 2152e680a7aa3337f84cf74ac07e2179e4ed3353 Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Thu, 19 Feb 2015 15:40:14 +0100 Subject: [PATCH 095/323] Ignore whitespace in test comparisons. --- .../overturetool/cgisa/CgIsaParamTest.java | 5 ++--- .../overturetool/cgisa/CgIsaTestResult.java | 22 ++++++++++++++----- 2 files changed, 18 insertions(+), 9 deletions(-) diff --git a/core/cgisa/src/test/java/org/overturetool/cgisa/CgIsaParamTest.java b/core/cgisa/src/test/java/org/overturetool/cgisa/CgIsaParamTest.java index bc9266b872..9b84e370a9 100644 --- a/core/cgisa/src/test/java/org/overturetool/cgisa/CgIsaParamTest.java +++ b/core/cgisa/src/test/java/org/overturetool/cgisa/CgIsaParamTest.java @@ -5,7 +5,7 @@ import java.util.LinkedList; import java.util.List; -import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; import org.junit.runner.RunWith; @@ -83,8 +83,7 @@ protected String getUpdatePropertyString() @Override public void compareResults(CgIsaTestResult actual, CgIsaTestResult expected) { - assertEquals(expected, actual); - + assertTrue("Expected: "+expected.translation + "\nGot: "+actual.translation, expected.compare(actual)); } } diff --git a/core/cgisa/src/test/java/org/overturetool/cgisa/CgIsaTestResult.java b/core/cgisa/src/test/java/org/overturetool/cgisa/CgIsaTestResult.java index 90eeb139d6..67a0dd4568 100644 --- a/core/cgisa/src/test/java/org/overturetool/cgisa/CgIsaTestResult.java +++ b/core/cgisa/src/test/java/org/overturetool/cgisa/CgIsaTestResult.java @@ -1,20 +1,19 @@ package org.overturetool.cgisa; -import java.util.LinkedList; import java.util.List; import org.overture.codegen.utils.GeneratedModule; public class CgIsaTestResult { - List translation; + String translation; boolean errors; public CgIsaTestResult() { } - private CgIsaTestResult(List translation, boolean errors) + private CgIsaTestResult(String translation, boolean errors) { super(); this.translation = translation; @@ -62,9 +61,20 @@ public boolean equals(Object obj) return true; } + public boolean compare(CgIsaTestResult other){ + if (errors != other.errors){ + return false; + } + if (!translation.replaceAll("\\s", "").equals(other.translation.replaceAll("\\s", ""))){ + return false; + } + + return true; + } + public static CgIsaTestResult convert(List result) { - List trans = new LinkedList<>(); + StringBuilder trans = new StringBuilder(); boolean err = false; for (GeneratedModule g : result) @@ -83,11 +93,11 @@ public static CgIsaTestResult convert(List result) else { - trans.add(g.getContent()); + trans.append(g.getContent()); } } - return new CgIsaTestResult(trans, err); + return new CgIsaTestResult(trans.toString(), err); } } From 9ff64182eebb727f081f0ffa7b5b12cbb5edc12e Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Thu, 19 Feb 2015 16:05:11 +0100 Subject: [PATCH 096/323] Process and translate values. --- .../cgisa/IsaTranslationUtils.java | 19 +++++++++++++++++++ .../IsaTemplates/Declarations/Class.vm | 4 ++++ .../IsaTemplates/Declarations/Field.vm | 2 ++ 3 files changed, 25 insertions(+) create mode 100644 core/cgisa/src/main/resources/IsaTemplates/Declarations/Field.vm diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslationUtils.java b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslationUtils.java index bb04007596..2c11af1f12 100644 --- a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslationUtils.java +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslationUtils.java @@ -27,6 +27,7 @@ import org.overture.codegen.cgast.INode; import org.overture.codegen.cgast.analysis.AnalysisException; +import org.overture.codegen.cgast.declarations.AFieldDeclCG; import org.overture.codegen.cgast.declarations.AFormalParamLocalParamCG; import org.overture.codegen.merging.MergeVisitor; import org.overture.codegen.merging.TemplateCallable; @@ -54,7 +55,25 @@ public String norm(String name) { return name; } + + public String filter(AFieldDeclCG field) throws AnalysisException { + if (field.getFinal() && field.getStatic()){ + trans(field.getInitial()); + } + + return ""; + } +// public String trans(AFieldDeclCG field) throws AnalysisException{ +// +// +// // Only interested in VDM values - static and final +// if (field.getFinal() && field.getStatic()){ +// trans(field.getInitial()); +// } +// +// return ""; +// } public String trans(List params) throws AnalysisException{ StringBuilder sb = new StringBuilder(); diff --git a/core/cgisa/src/main/resources/IsaTemplates/Declarations/Class.vm b/core/cgisa/src/main/resources/IsaTemplates/Declarations/Class.vm index cb26554798..3366ec3ddf 100644 --- a/core/cgisa/src/main/resources/IsaTemplates/Declarations/Class.vm +++ b/core/cgisa/src/main/resources/IsaTemplates/Declarations/Class.vm @@ -4,6 +4,10 @@ begin #foreach( $func in $node.Functions ) $Isa.trans($func) + #end +#foreach( $field in $node.Fields ) +$Isa.trans($field) +#end end \ No newline at end of file diff --git a/core/cgisa/src/main/resources/IsaTemplates/Declarations/Field.vm b/core/cgisa/src/main/resources/IsaTemplates/Declarations/Field.vm new file mode 100644 index 0000000000..27b3d21369 --- /dev/null +++ b/core/cgisa/src/main/resources/IsaTemplates/Declarations/Field.vm @@ -0,0 +1,2 @@ +definition "$node.Name" = +|$Isa.trans($node.Initial) : $Isa.trans($node.type)|+" +declare ${node.Name}_def [eval,evalp] \ No newline at end of file From 464e2cbbc7128ac23da38f3d768b5453f230aa71 Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Thu, 19 Feb 2015 16:06:50 +0100 Subject: [PATCH 097/323] Process function body in template. --- .../src/main/resources/IsaTemplates/Declarations/Function.vm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/cgisa/src/main/resources/IsaTemplates/Declarations/Function.vm b/core/cgisa/src/main/resources/IsaTemplates/Declarations/Function.vm index 2f123ac8da..e578992cc1 100644 --- a/core/cgisa/src/main/resources/IsaTemplates/Declarations/Function.vm +++ b/core/cgisa/src/main/resources/IsaTemplates/Declarations/Function.vm @@ -1,4 +1,4 @@ cmlefun $node.Name inp $Isa.trans($node.FormalParams) out "@type" - is "body" \ No newline at end of file + is "$Isa.trans($node.Body)" \ No newline at end of file From 67ff251c6fe7264630c9874c751de57a47f0341b Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Thu, 19 Feb 2015 16:07:14 +0100 Subject: [PATCH 098/323] Add quote marks to function type. --- .../src/main/resources/IsaTemplates/LocalDecls/FormalParam.vm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/cgisa/src/main/resources/IsaTemplates/LocalDecls/FormalParam.vm b/core/cgisa/src/main/resources/IsaTemplates/LocalDecls/FormalParam.vm index f28295c0da..2c6de32400 100644 --- a/core/cgisa/src/main/resources/IsaTemplates/LocalDecls/FormalParam.vm +++ b/core/cgisa/src/main/resources/IsaTemplates/LocalDecls/FormalParam.vm @@ -1 +1 @@ -$Isa.trans($node.Pattern) :: $Isa.trans($node.Type) \ No newline at end of file +$Isa.trans($node.Pattern) :: "$Isa.trans($node.Type)" \ No newline at end of file From 52d0966834d2f2517eafa81d0e25ae70d04426e3 Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Thu, 19 Feb 2015 16:07:59 +0100 Subject: [PATCH 099/323] Clean up nat and add nat1 and int basic types. --- core/cgisa/src/main/resources/IsaTemplates/Types/Basic/Int.vm | 1 + core/cgisa/src/main/resources/IsaTemplates/Types/Basic/Nat.vm | 2 +- core/cgisa/src/main/resources/IsaTemplates/Types/Basic/Nat1.vm | 1 + 3 files changed, 3 insertions(+), 1 deletion(-) create mode 100644 core/cgisa/src/main/resources/IsaTemplates/Types/Basic/Int.vm create mode 100644 core/cgisa/src/main/resources/IsaTemplates/Types/Basic/Nat1.vm diff --git a/core/cgisa/src/main/resources/IsaTemplates/Types/Basic/Int.vm b/core/cgisa/src/main/resources/IsaTemplates/Types/Basic/Int.vm new file mode 100644 index 0000000000..cc92457d0e --- /dev/null +++ b/core/cgisa/src/main/resources/IsaTemplates/Types/Basic/Int.vm @@ -0,0 +1 @@ +@int \ No newline at end of file diff --git a/core/cgisa/src/main/resources/IsaTemplates/Types/Basic/Nat.vm b/core/cgisa/src/main/resources/IsaTemplates/Types/Basic/Nat.vm index 193d7efdba..38b5795b52 100644 --- a/core/cgisa/src/main/resources/IsaTemplates/Types/Basic/Nat.vm +++ b/core/cgisa/src/main/resources/IsaTemplates/Types/Basic/Nat.vm @@ -1 +1 @@ -"@nat" \ No newline at end of file +@nat \ No newline at end of file diff --git a/core/cgisa/src/main/resources/IsaTemplates/Types/Basic/Nat1.vm b/core/cgisa/src/main/resources/IsaTemplates/Types/Basic/Nat1.vm new file mode 100644 index 0000000000..a25118c527 --- /dev/null +++ b/core/cgisa/src/main/resources/IsaTemplates/Types/Basic/Nat1.vm @@ -0,0 +1 @@ +@nat1 \ No newline at end of file From f9ba929b126a800284b2dea9372ee953939308e6 Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Thu, 19 Feb 2015 16:08:23 +0100 Subject: [PATCH 100/323] Add templates for int literal and var expressions. --- .../src/main/resources/IsaTemplates/Expressions/IntLiteral.vm | 1 + .../src/main/resources/IsaTemplates/Expressions/Variable.vm | 1 + 2 files changed, 2 insertions(+) create mode 100644 core/cgisa/src/main/resources/IsaTemplates/Expressions/IntLiteral.vm create mode 100644 core/cgisa/src/main/resources/IsaTemplates/Expressions/Variable.vm diff --git a/core/cgisa/src/main/resources/IsaTemplates/Expressions/IntLiteral.vm b/core/cgisa/src/main/resources/IsaTemplates/Expressions/IntLiteral.vm new file mode 100644 index 0000000000..17f8910e04 --- /dev/null +++ b/core/cgisa/src/main/resources/IsaTemplates/Expressions/IntLiteral.vm @@ -0,0 +1 @@ +$node.Value \ No newline at end of file diff --git a/core/cgisa/src/main/resources/IsaTemplates/Expressions/Variable.vm b/core/cgisa/src/main/resources/IsaTemplates/Expressions/Variable.vm new file mode 100644 index 0000000000..0aed265d43 --- /dev/null +++ b/core/cgisa/src/main/resources/IsaTemplates/Expressions/Variable.vm @@ -0,0 +1 @@ +^$node.Name^ \ No newline at end of file From b79c742cb21f0ec7de94ce23d518b7348b5016ad Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Thu, 19 Feb 2015 16:10:58 +0100 Subject: [PATCH 101/323] Add line breaks to test failure message. Trying to improve readability. Message is now: Expected: syntax.... Got: syntax... [Issue: ] --- .../src/test/java/org/overturetool/cgisa/CgIsaParamTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/cgisa/src/test/java/org/overturetool/cgisa/CgIsaParamTest.java b/core/cgisa/src/test/java/org/overturetool/cgisa/CgIsaParamTest.java index 9b84e370a9..a752fa2427 100644 --- a/core/cgisa/src/test/java/org/overturetool/cgisa/CgIsaParamTest.java +++ b/core/cgisa/src/test/java/org/overturetool/cgisa/CgIsaParamTest.java @@ -83,7 +83,7 @@ protected String getUpdatePropertyString() @Override public void compareResults(CgIsaTestResult actual, CgIsaTestResult expected) { - assertTrue("Expected: "+expected.translation + "\nGot: "+actual.translation, expected.compare(actual)); + assertTrue("Expected: \n"+expected.translation + "\nGot: \n"+actual.translation, expected.compare(actual)); } } From ac46bdf6f20a5bdf4285ac3c3f8717cf4b35477e Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Thu, 19 Feb 2015 16:13:00 +0100 Subject: [PATCH 102/323] Add more tests and add some structure to resource folder. --- .../cgisa/src/test/resources/micro/Func1Param.vdmpp.result | 1 - .../src/test/resources/micro/Func2Params.vdmpp.result | 1 - .../src/test/resources/micro/FuncNoParam.vdmpp.result | 1 - .../test/resources/micro/{ => Functions}/Func1Param.vdmpp | 0 .../test/resources/micro/Functions/Func1Param.vdmpp.result | 1 + .../test/resources/micro/{ => Functions}/Func2Params.vdmpp | 0 .../resources/micro/Functions/Func2Params.vdmpp.result | 1 + .../test/resources/micro/{ => Functions}/FuncNoParam.vdmpp | 0 .../resources/micro/Functions/FuncNoParam.vdmpp.result | 1 + core/cgisa/src/test/resources/micro/Values/IntExp.vdmpp | 6 ++++++ .../src/test/resources/micro/Values/IntExp.vdmpp.result | 1 + .../src/test/resources/micro/Values/IntExpVarExp.vdmpp | 7 +++++++ .../test/resources/micro/Values/IntExpVarExp.vdmpp.result | 1 + 13 files changed, 18 insertions(+), 3 deletions(-) delete mode 100644 core/cgisa/src/test/resources/micro/Func1Param.vdmpp.result delete mode 100644 core/cgisa/src/test/resources/micro/Func2Params.vdmpp.result delete mode 100644 core/cgisa/src/test/resources/micro/FuncNoParam.vdmpp.result rename core/cgisa/src/test/resources/micro/{ => Functions}/Func1Param.vdmpp (100%) create mode 100644 core/cgisa/src/test/resources/micro/Functions/Func1Param.vdmpp.result rename core/cgisa/src/test/resources/micro/{ => Functions}/Func2Params.vdmpp (100%) create mode 100644 core/cgisa/src/test/resources/micro/Functions/Func2Params.vdmpp.result rename core/cgisa/src/test/resources/micro/{ => Functions}/FuncNoParam.vdmpp (100%) create mode 100644 core/cgisa/src/test/resources/micro/Functions/FuncNoParam.vdmpp.result create mode 100644 core/cgisa/src/test/resources/micro/Values/IntExp.vdmpp create mode 100644 core/cgisa/src/test/resources/micro/Values/IntExp.vdmpp.result create mode 100644 core/cgisa/src/test/resources/micro/Values/IntExpVarExp.vdmpp create mode 100644 core/cgisa/src/test/resources/micro/Values/IntExpVarExp.vdmpp.result diff --git a/core/cgisa/src/test/resources/micro/Func1Param.vdmpp.result b/core/cgisa/src/test/resources/micro/Func1Param.vdmpp.result deleted file mode 100644 index 26ee64b4d7..0000000000 --- a/core/cgisa/src/test/resources/micro/Func1Param.vdmpp.result +++ /dev/null @@ -1 +0,0 @@ -{"translation":["theory A\n imports utp_cml\nbegin\n\ncmlefun f\n inp x :: \"@nat\"\n out \"@type\"\n is \"body\"\n\nend"],"errors":false} \ No newline at end of file diff --git a/core/cgisa/src/test/resources/micro/Func2Params.vdmpp.result b/core/cgisa/src/test/resources/micro/Func2Params.vdmpp.result deleted file mode 100644 index 7011e1cdf5..0000000000 --- a/core/cgisa/src/test/resources/micro/Func2Params.vdmpp.result +++ /dev/null @@ -1 +0,0 @@ -{"translation":["theory A\n imports utp_cml\nbegin\n\ncmlefun f\n inp x :: \"@nat\" and y :: \"@nat\"\n out \"@type\"\n is \"body\"\n\nend"],"errors":false} \ No newline at end of file diff --git a/core/cgisa/src/test/resources/micro/FuncNoParam.vdmpp.result b/core/cgisa/src/test/resources/micro/FuncNoParam.vdmpp.result deleted file mode 100644 index 8aea44912f..0000000000 --- a/core/cgisa/src/test/resources/micro/FuncNoParam.vdmpp.result +++ /dev/null @@ -1 +0,0 @@ -{"translation":["theory A\n imports utp_cml\nbegin\n\ncmlefun f\n inp \n out \"@type\"\n is \"body\"\n\nend"],"errors":false} \ No newline at end of file diff --git a/core/cgisa/src/test/resources/micro/Func1Param.vdmpp b/core/cgisa/src/test/resources/micro/Functions/Func1Param.vdmpp similarity index 100% rename from core/cgisa/src/test/resources/micro/Func1Param.vdmpp rename to core/cgisa/src/test/resources/micro/Functions/Func1Param.vdmpp diff --git a/core/cgisa/src/test/resources/micro/Functions/Func1Param.vdmpp.result b/core/cgisa/src/test/resources/micro/Functions/Func1Param.vdmpp.result new file mode 100644 index 0000000000..1704c291f6 --- /dev/null +++ b/core/cgisa/src/test/resources/micro/Functions/Func1Param.vdmpp.result @@ -0,0 +1 @@ +{"translation":"theory A\n imports utp_cml\nbegin\n\ncmlefun f\n inp x :: \"@nat\"\n out \"@type\"\n is \"^x^\"\n\nend","errors":false} \ No newline at end of file diff --git a/core/cgisa/src/test/resources/micro/Func2Params.vdmpp b/core/cgisa/src/test/resources/micro/Functions/Func2Params.vdmpp similarity index 100% rename from core/cgisa/src/test/resources/micro/Func2Params.vdmpp rename to core/cgisa/src/test/resources/micro/Functions/Func2Params.vdmpp diff --git a/core/cgisa/src/test/resources/micro/Functions/Func2Params.vdmpp.result b/core/cgisa/src/test/resources/micro/Functions/Func2Params.vdmpp.result new file mode 100644 index 0000000000..34bd40b2fd --- /dev/null +++ b/core/cgisa/src/test/resources/micro/Functions/Func2Params.vdmpp.result @@ -0,0 +1 @@ +{"translation":"theory A\n imports utp_cml\nbegin\n\ncmlefun f\n inp x :: \"@nat\" and y :: \"@nat\"\n out \"@type\"\n is \"^x^\"\n\nend","errors":false} \ No newline at end of file diff --git a/core/cgisa/src/test/resources/micro/FuncNoParam.vdmpp b/core/cgisa/src/test/resources/micro/Functions/FuncNoParam.vdmpp similarity index 100% rename from core/cgisa/src/test/resources/micro/FuncNoParam.vdmpp rename to core/cgisa/src/test/resources/micro/Functions/FuncNoParam.vdmpp diff --git a/core/cgisa/src/test/resources/micro/Functions/FuncNoParam.vdmpp.result b/core/cgisa/src/test/resources/micro/Functions/FuncNoParam.vdmpp.result new file mode 100644 index 0000000000..c6c992bfe8 --- /dev/null +++ b/core/cgisa/src/test/resources/micro/Functions/FuncNoParam.vdmpp.result @@ -0,0 +1 @@ +{"translation":"theory A\n imports utp_cml\nbegin\n\ncmlefun f\n inp \n out \"@type\"\n is \"0\"\n\nend","errors":false} \ No newline at end of file diff --git a/core/cgisa/src/test/resources/micro/Values/IntExp.vdmpp b/core/cgisa/src/test/resources/micro/Values/IntExp.vdmpp new file mode 100644 index 0000000000..b8da58e88d --- /dev/null +++ b/core/cgisa/src/test/resources/micro/Values/IntExp.vdmpp @@ -0,0 +1,6 @@ +class A + +values +x = 1; + +end A \ No newline at end of file diff --git a/core/cgisa/src/test/resources/micro/Values/IntExp.vdmpp.result b/core/cgisa/src/test/resources/micro/Values/IntExp.vdmpp.result new file mode 100644 index 0000000000..00a6d4a08c --- /dev/null +++ b/core/cgisa/src/test/resources/micro/Values/IntExp.vdmpp.result @@ -0,0 +1 @@ +{"translation":"theory A\n imports utp_cml\nbegin\n\ndefinition \"x\" \u003d +|1 : @nat1|+\"\ndeclare x_def [eval,evalp]\n\nend","errors":false} \ No newline at end of file diff --git a/core/cgisa/src/test/resources/micro/Values/IntExpVarExp.vdmpp b/core/cgisa/src/test/resources/micro/Values/IntExpVarExp.vdmpp new file mode 100644 index 0000000000..11ceefde91 --- /dev/null +++ b/core/cgisa/src/test/resources/micro/Values/IntExpVarExp.vdmpp @@ -0,0 +1,7 @@ +class A + +values +x = 1; +y = x; + +end A \ No newline at end of file diff --git a/core/cgisa/src/test/resources/micro/Values/IntExpVarExp.vdmpp.result b/core/cgisa/src/test/resources/micro/Values/IntExpVarExp.vdmpp.result new file mode 100644 index 0000000000..a77dbb6404 --- /dev/null +++ b/core/cgisa/src/test/resources/micro/Values/IntExpVarExp.vdmpp.result @@ -0,0 +1 @@ +{"translation":"theory A\n imports utp_cml\nbegin\n\ndefinition \"x\" \u003d +|1 : @nat1|+\"\ndeclare x_def [eval,evalp]\n\ndefinition \"y\" \u003d +|^x^ : @nat1|+\"\ndeclare y_def [eval,evalp]\n\nend","errors":false} \ No newline at end of file From b334f8198446d54caa233429a00085ace579b16c Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Thu, 19 Feb 2015 16:38:28 +0100 Subject: [PATCH 103/323] Remove extraneous quote mark. --- .../cgisa/src/main/resources/IsaTemplates/Declarations/Field.vm | 2 +- core/cgisa/src/test/resources/micro/Values/IntExp.vdmpp.result | 2 +- .../src/test/resources/micro/Values/IntExpVarExp.vdmpp.result | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/core/cgisa/src/main/resources/IsaTemplates/Declarations/Field.vm b/core/cgisa/src/main/resources/IsaTemplates/Declarations/Field.vm index 27b3d21369..6ccb74acbb 100644 --- a/core/cgisa/src/main/resources/IsaTemplates/Declarations/Field.vm +++ b/core/cgisa/src/main/resources/IsaTemplates/Declarations/Field.vm @@ -1,2 +1,2 @@ -definition "$node.Name" = +|$Isa.trans($node.Initial) : $Isa.trans($node.type)|+" +definition "$node.Name = +|$Isa.trans($node.Initial) : $Isa.trans($node.type)|+" declare ${node.Name}_def [eval,evalp] \ No newline at end of file diff --git a/core/cgisa/src/test/resources/micro/Values/IntExp.vdmpp.result b/core/cgisa/src/test/resources/micro/Values/IntExp.vdmpp.result index 00a6d4a08c..8620d5ba7f 100644 --- a/core/cgisa/src/test/resources/micro/Values/IntExp.vdmpp.result +++ b/core/cgisa/src/test/resources/micro/Values/IntExp.vdmpp.result @@ -1 +1 @@ -{"translation":"theory A\n imports utp_cml\nbegin\n\ndefinition \"x\" \u003d +|1 : @nat1|+\"\ndeclare x_def [eval,evalp]\n\nend","errors":false} \ No newline at end of file +{"translation":"theory A\n imports utp_cml\nbegin\n\ndefinition \"x \u003d +|1 : @nat1|+\"\ndeclare x_def [eval,evalp]\n\nend","errors":false} \ No newline at end of file diff --git a/core/cgisa/src/test/resources/micro/Values/IntExpVarExp.vdmpp.result b/core/cgisa/src/test/resources/micro/Values/IntExpVarExp.vdmpp.result index a77dbb6404..5e73968a12 100644 --- a/core/cgisa/src/test/resources/micro/Values/IntExpVarExp.vdmpp.result +++ b/core/cgisa/src/test/resources/micro/Values/IntExpVarExp.vdmpp.result @@ -1 +1 @@ -{"translation":"theory A\n imports utp_cml\nbegin\n\ndefinition \"x\" \u003d +|1 : @nat1|+\"\ndeclare x_def [eval,evalp]\n\ndefinition \"y\" \u003d +|^x^ : @nat1|+\"\ndeclare y_def [eval,evalp]\n\nend","errors":false} \ No newline at end of file +{"translation":"theory A\n imports utp_cml\nbegin\n\ndefinition \"x \u003d +|1 : @nat1|+\"\ndeclare x_def [eval,evalp]\n\ndefinition \"y \u003d +|^x^ : @nat1|+\"\ndeclare y_def [eval,evalp]\n\nend","errors":false} \ No newline at end of file From 06e0327506810a61de4d7557f3932a41a2aff8eb Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Thu, 19 Feb 2015 16:38:38 +0100 Subject: [PATCH 104/323] Add numeric binary expressions. --- .../resources/IsaTemplates/Expressions/Binary/Numeric/Plus.vm | 1 + 1 file changed, 1 insertion(+) create mode 100644 core/cgisa/src/main/resources/IsaTemplates/Expressions/Binary/Numeric/Plus.vm diff --git a/core/cgisa/src/main/resources/IsaTemplates/Expressions/Binary/Numeric/Plus.vm b/core/cgisa/src/main/resources/IsaTemplates/Expressions/Binary/Numeric/Plus.vm new file mode 100644 index 0000000000..19606f1ff5 --- /dev/null +++ b/core/cgisa/src/main/resources/IsaTemplates/Expressions/Binary/Numeric/Plus.vm @@ -0,0 +1 @@ +($node.Left + $node.Right) \ No newline at end of file From 3c09b5e980b53ced4f0dc2fc3ee39bfb2b7d15d8 Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Thu, 19 Feb 2015 17:05:18 +0100 Subject: [PATCH 105/323] Properly filter non-value fields. --- .../org/overturetool/cgisa/IsaTranslationUtils.java | 12 +----------- .../resources/IsaTemplates/Declarations/Class.vm | 2 +- 2 files changed, 2 insertions(+), 12 deletions(-) diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslationUtils.java b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslationUtils.java index 2c11af1f12..d634238caa 100644 --- a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslationUtils.java +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslationUtils.java @@ -58,22 +58,12 @@ public String norm(String name) public String filter(AFieldDeclCG field) throws AnalysisException { if (field.getFinal() && field.getStatic()){ - trans(field.getInitial()); + return trans(field); } return ""; } -// public String trans(AFieldDeclCG field) throws AnalysisException{ -// -// -// // Only interested in VDM values - static and final -// if (field.getFinal() && field.getStatic()){ -// trans(field.getInitial()); -// } -// -// return ""; -// } public String trans(List params) throws AnalysisException{ StringBuilder sb = new StringBuilder(); diff --git a/core/cgisa/src/main/resources/IsaTemplates/Declarations/Class.vm b/core/cgisa/src/main/resources/IsaTemplates/Declarations/Class.vm index 3366ec3ddf..fb1cb2e267 100644 --- a/core/cgisa/src/main/resources/IsaTemplates/Declarations/Class.vm +++ b/core/cgisa/src/main/resources/IsaTemplates/Declarations/Class.vm @@ -7,7 +7,7 @@ $Isa.trans($func) #end #foreach( $field in $node.Fields ) -$Isa.trans($field) +$Isa.filter($field) #end end \ No newline at end of file From d0fe596f521505848f0e5b82095c1fdbf4de0ce0 Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Thu, 19 Feb 2015 17:14:25 +0100 Subject: [PATCH 106/323] Rename param translation method. We will need to translate different lists of nodes and this gets around type erasure issues. --- .../overturetool/cgisa/IsaTranslationUtils.java | 16 ++++++++++++++-- .../IsaTemplates/Declarations/Function.vm | 2 +- 2 files changed, 15 insertions(+), 3 deletions(-) diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslationUtils.java b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslationUtils.java index d634238caa..a0c5d82c3a 100644 --- a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslationUtils.java +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslationUtils.java @@ -21,11 +21,15 @@ */ package org.overturetool.cgisa; +import helpers.IsSeqTypeVisitor; + import java.io.StringWriter; import java.util.Iterator; import java.util.List; import org.overture.codegen.cgast.INode; +import org.overture.codegen.cgast.SExpCG; +import org.overture.codegen.cgast.STypeCG; import org.overture.codegen.cgast.analysis.AnalysisException; import org.overture.codegen.cgast.declarations.AFieldDeclCG; import org.overture.codegen.cgast.declarations.AFormalParamLocalParamCG; @@ -63,8 +67,8 @@ public String filter(AFieldDeclCG field) throws AnalysisException { return ""; } - - public String trans(List params) throws AnalysisException{ + + public String transParams(List params) throws AnalysisException{ StringBuilder sb = new StringBuilder(); Iterator it = params.iterator(); @@ -84,6 +88,10 @@ public String trans(List params) throws AnalysisExcept } + public String transArgs(List args){ + return "A list of dudes"; + } + public String trans(INode node) throws AnalysisException { StringWriter writer = new StringWriter(); @@ -91,4 +99,8 @@ public String trans(INode node) throws AnalysisException return writer.toString(); } + + public boolean isSeq(STypeCG node) throws AnalysisException{ + return node.apply(new IsSeqTypeVisitor()); + } } diff --git a/core/cgisa/src/main/resources/IsaTemplates/Declarations/Function.vm b/core/cgisa/src/main/resources/IsaTemplates/Declarations/Function.vm index e578992cc1..0d3c172ecd 100644 --- a/core/cgisa/src/main/resources/IsaTemplates/Declarations/Function.vm +++ b/core/cgisa/src/main/resources/IsaTemplates/Declarations/Function.vm @@ -1,4 +1,4 @@ cmlefun $node.Name - inp $Isa.trans($node.FormalParams) + inp $Isa.transParams($node.FormalParams) out "@type" is "$Isa.trans($node.Body)" \ No newline at end of file From 58d2c74cf9245db7f4cfe63720a736ad64ba3403 Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Thu, 19 Feb 2015 18:14:38 +0100 Subject: [PATCH 107/323] Add various is-of-type visitors. --- .../cgisa/helpers/IsCharTypeVisitor.java | 30 +++++++++++++++++++ .../cgisa/helpers/IsMethodTypeVisitor.java | 30 +++++++++++++++++++ .../cgisa/helpers/IsSeqOfCharTypeVisitor.java | 29 ++++++++++++++++++ 3 files changed, 89 insertions(+) create mode 100644 core/cgisa/src/main/java/org/overturetool/cgisa/helpers/IsCharTypeVisitor.java create mode 100644 core/cgisa/src/main/java/org/overturetool/cgisa/helpers/IsMethodTypeVisitor.java create mode 100644 core/cgisa/src/main/java/org/overturetool/cgisa/helpers/IsSeqOfCharTypeVisitor.java diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/helpers/IsCharTypeVisitor.java b/core/cgisa/src/main/java/org/overturetool/cgisa/helpers/IsCharTypeVisitor.java new file mode 100644 index 0000000000..b7daa840a1 --- /dev/null +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/helpers/IsCharTypeVisitor.java @@ -0,0 +1,30 @@ +package org.overturetool.cgisa.helpers; + +import org.overture.codegen.cgast.INode; +import org.overture.codegen.cgast.analysis.AnalysisException; +import org.overture.codegen.cgast.analysis.AnswerAdaptor; +import org.overture.codegen.cgast.types.ACharBasicTypeCG; + +public class IsCharTypeVisitor extends AnswerAdaptor +{ + + @Override + public Boolean createNewReturnValue(INode node) throws AnalysisException + { + return false; + } + + @Override + public Boolean createNewReturnValue(Object node) throws AnalysisException + { + return false; + } + + + @Override + public Boolean caseACharBasicTypeCG(ACharBasicTypeCG node) + throws AnalysisException + { + return true; + } +} diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/helpers/IsMethodTypeVisitor.java b/core/cgisa/src/main/java/org/overturetool/cgisa/helpers/IsMethodTypeVisitor.java new file mode 100644 index 0000000000..112c5cce64 --- /dev/null +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/helpers/IsMethodTypeVisitor.java @@ -0,0 +1,30 @@ +package org.overturetool.cgisa.helpers; + +import org.overture.codegen.cgast.INode; +import org.overture.codegen.cgast.analysis.AnalysisException; +import org.overture.codegen.cgast.analysis.AnswerAdaptor; +import org.overture.codegen.cgast.types.AMethodTypeCG; + +public class IsMethodTypeVisitor extends AnswerAdaptor +{ + + @Override + public Boolean createNewReturnValue(INode node) throws AnalysisException + { + return false; + } + + @Override + public Boolean createNewReturnValue(Object node) throws AnalysisException + { + return false; + } + + @Override + public Boolean caseAMethodTypeCG(AMethodTypeCG node) + throws AnalysisException + { + return true; + } + +} \ No newline at end of file diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/helpers/IsSeqOfCharTypeVisitor.java b/core/cgisa/src/main/java/org/overturetool/cgisa/helpers/IsSeqOfCharTypeVisitor.java new file mode 100644 index 0000000000..bb618d54cb --- /dev/null +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/helpers/IsSeqOfCharTypeVisitor.java @@ -0,0 +1,29 @@ +package org.overturetool.cgisa.helpers; + +import org.overture.codegen.cgast.INode; +import org.overture.codegen.cgast.analysis.AnalysisException; +import org.overture.codegen.cgast.analysis.AnswerAdaptor; +import org.overture.codegen.cgast.types.ASeqSeqTypeCG; + +public class IsSeqOfCharTypeVisitor extends AnswerAdaptor +{ + + @Override + public Boolean createNewReturnValue(INode node) throws AnalysisException + { + return false; + } + + @Override + public Boolean createNewReturnValue(Object node) throws AnalysisException + { + return false; + } + + @Override + public Boolean caseASeqSeqTypeCG(ASeqSeqTypeCG node) + throws AnalysisException + { + return node.getSeqOf().apply(new IsCharTypeVisitor()); + } +} \ No newline at end of file From 71850455a08447ec272aa6c3992575f7912bab5a Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Thu, 19 Feb 2015 18:14:59 +0100 Subject: [PATCH 108/323] Add templates for char types and literals --- .../src/main/resources/IsaTemplates/Expressions/CharLiteral.vm | 1 + core/cgisa/src/main/resources/IsaTemplates/Types/Basic/Char.vm | 1 + 2 files changed, 2 insertions(+) create mode 100644 core/cgisa/src/main/resources/IsaTemplates/Expressions/CharLiteral.vm create mode 100644 core/cgisa/src/main/resources/IsaTemplates/Types/Basic/Char.vm diff --git a/core/cgisa/src/main/resources/IsaTemplates/Expressions/CharLiteral.vm b/core/cgisa/src/main/resources/IsaTemplates/Expressions/CharLiteral.vm new file mode 100644 index 0000000000..17f8910e04 --- /dev/null +++ b/core/cgisa/src/main/resources/IsaTemplates/Expressions/CharLiteral.vm @@ -0,0 +1 @@ +$node.Value \ No newline at end of file diff --git a/core/cgisa/src/main/resources/IsaTemplates/Types/Basic/Char.vm b/core/cgisa/src/main/resources/IsaTemplates/Types/Basic/Char.vm new file mode 100644 index 0000000000..f387add6ce --- /dev/null +++ b/core/cgisa/src/main/resources/IsaTemplates/Types/Basic/Char.vm @@ -0,0 +1 @@ +@char \ No newline at end of file From 614a955da730503af20ce34b19c4b7067366012e Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Thu, 19 Feb 2015 18:15:32 +0100 Subject: [PATCH 109/323] Reorder and cleanup utils. --- .../cgisa/IsaTranslationUtils.java | 111 +++++++++++++----- 1 file changed, 79 insertions(+), 32 deletions(-) diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslationUtils.java b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslationUtils.java index a0c5d82c3a..29bb75fe91 100644 --- a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslationUtils.java +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslationUtils.java @@ -21,8 +21,6 @@ */ package org.overturetool.cgisa; -import helpers.IsSeqTypeVisitor; - import java.io.StringWriter; import java.util.Iterator; import java.util.List; @@ -36,6 +34,8 @@ import org.overture.codegen.merging.MergeVisitor; import org.overture.codegen.merging.TemplateCallable; import org.overture.codegen.merging.TemplateStructure; +import org.overturetool.cgisa.helpers.IsMethodTypeVisitor; +import org.overturetool.cgisa.helpers.IsSeqOfCharTypeVisitor; public class IsaTranslationUtils { @@ -55,52 +55,99 @@ public MergeVisitor getMergeVisitor() return mergeVisitor; } - public String norm(String name) + // Translations (call merge visitor) + + public String trans(INode node) throws AnalysisException { - return name; - } - - public String filter(AFieldDeclCG field) throws AnalysisException { - if (field.getFinal() && field.getStatic()){ - return trans(field); - } - - return ""; + StringWriter writer = new StringWriter(); + node.apply(mergeVisitor, writer); + + return writer.toString(); } - - public String transParams(List params) throws AnalysisException{ + + public String transParams(List params) + throws AnalysisException + { StringBuilder sb = new StringBuilder(); - + Iterator it = params.iterator(); - - while (it.hasNext()){ + + while (it.hasNext()) + { StringWriter writer = new StringWriter(); it.next().apply(mergeVisitor, writer); sb.append(writer.toString()); + if (it.hasNext()) + { + sb.append(PARAM_SEP); + } + + } + + return sb.toString(); + } + + public String transArgs(List args) throws AnalysisException + { + if (args.isEmpty()) + { + return ""; + } + StringBuilder sb = new StringBuilder(); + + Iterator it = args.iterator(); + + while (it.hasNext()) + { + sb.append(trans(it.next())); if (it.hasNext()){ sb.append(PARAM_SEP); } - } - - + return sb.toString(); - } - - public String transArgs(List args){ - return "A list of dudes"; + + // Auxiliary Constructions + + public String norm(String name) + { + return name; } - - public String trans(INode node) throws AnalysisException + + public String makeString(List args) throws AnalysisException { - StringWriter writer = new StringWriter(); - node.apply(mergeVisitor, writer); + StringBuilder sb = new StringBuilder(); + sb.append("''"); + for (SExpCG arg : args) + { + sb.append(trans(arg)); + } + sb.append("''"); + return sb.toString(); + } - return writer.toString(); + // Controlflow + + public String filter(AFieldDeclCG field) throws AnalysisException + { + if (field.getFinal() && field.getStatic()) + { + return trans(field); + } + + return ""; } - - public boolean isSeq(STypeCG node) throws AnalysisException{ - return node.apply(new IsSeqTypeVisitor()); + + // Checks + + public boolean isString(STypeCG node) throws AnalysisException + { + return node.apply(new IsSeqOfCharTypeVisitor()); + } + + public boolean isFunc(STypeCG node) throws AnalysisException + { + return node.apply(new IsMethodTypeVisitor()); } } From ed22ef4d420c98635c3ef118002076048cbdf8e3 Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Thu, 19 Feb 2015 18:15:45 +0100 Subject: [PATCH 110/323] Add template for seq enums. --- .../src/main/resources/IsaTemplates/Expressions/Seq/Enum.vm | 3 +++ 1 file changed, 3 insertions(+) create mode 100644 core/cgisa/src/main/resources/IsaTemplates/Expressions/Seq/Enum.vm diff --git a/core/cgisa/src/main/resources/IsaTemplates/Expressions/Seq/Enum.vm b/core/cgisa/src/main/resources/IsaTemplates/Expressions/Seq/Enum.vm new file mode 100644 index 0000000000..7faedac9df --- /dev/null +++ b/core/cgisa/src/main/resources/IsaTemplates/Expressions/Seq/Enum.vm @@ -0,0 +1,3 @@ +#if ($Isa.isString($node.Type)) +$Isa.makeString($node.Members)#else +$Isa.makeSeq($node.Members)#end \ No newline at end of file From 2aa36c86987af40eb87cd41bcb4f333491686f2a Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Thu, 19 Feb 2015 18:16:13 +0100 Subject: [PATCH 111/323] Initial support for apply exps (char seqs only). --- .../src/main/resources/IsaTemplates/Expressions/Apply.vm | 6 ++++++ 1 file changed, 6 insertions(+) create mode 100644 core/cgisa/src/main/resources/IsaTemplates/Expressions/Apply.vm diff --git a/core/cgisa/src/main/resources/IsaTemplates/Expressions/Apply.vm b/core/cgisa/src/main/resources/IsaTemplates/Expressions/Apply.vm new file mode 100644 index 0000000000..794c646ab6 --- /dev/null +++ b/core/cgisa/src/main/resources/IsaTemplates/Expressions/Apply.vm @@ -0,0 +1,6 @@ +#set( $root = $Isa.trans($node.Root) ) +#set( $args = $Isa.transArgs($node.Args) ) +#if ($Isa.isFuncType($node.Root.Type) ) +a func! +#else +$root<$args>#end \ No newline at end of file From eb27e357e4b0d7e3edaae24a55fd54e53ee3bfc6 Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Thu, 19 Feb 2015 18:26:45 +0100 Subject: [PATCH 112/323] Add translation of non-string seq enums. --- .../cgisa/IsaTranslationUtils.java | 44 ++++++++++++++----- .../IsaTemplates/Expressions/Seq/Enum.vm | 4 +- 2 files changed, 35 insertions(+), 13 deletions(-) diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslationUtils.java b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslationUtils.java index 29bb75fe91..53f905c413 100644 --- a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslationUtils.java +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslationUtils.java @@ -42,6 +42,7 @@ public class IsaTranslationUtils private static final String TEMPLATE_CALLABLE_NAME = "Isa"; private static final Object PARAM_SEP = " and "; + private static final Object LIST_SEP = ", "; private MergeVisitor mergeVisitor; public IsaTranslationUtils(TemplateStructure templateStructure) @@ -55,7 +56,7 @@ public MergeVisitor getMergeVisitor() return mergeVisitor; } - // Translations (call merge visitor) + // Translations public String trans(INode node) throws AnalysisException { @@ -100,7 +101,8 @@ public String transArgs(List args) throws AnalysisException while (it.hasNext()) { sb.append(trans(it.next())); - if (it.hasNext()){ + if (it.hasNext()) + { sb.append(PARAM_SEP); } } @@ -108,14 +110,7 @@ public String transArgs(List args) throws AnalysisException return sb.toString(); } - // Auxiliary Constructions - - public String norm(String name) - { - return name; - } - - public String makeString(List args) throws AnalysisException + public String transString(List args) throws AnalysisException { StringBuilder sb = new StringBuilder(); sb.append("''"); @@ -127,7 +122,34 @@ public String makeString(List args) throws AnalysisException return sb.toString(); } - // Controlflow + public String transSeq(List args) throws AnalysisException + { + StringBuilder sb = new StringBuilder(); + sb.append("["); + + Iterator it = args.iterator(); + + while (it.hasNext()) + { + sb.append(trans(it.next())); + if (it.hasNext()) + { + sb.append(LIST_SEP); + } + } + + sb.append("]"); + return sb.toString(); + } + + // Renamings + + public String norm(String name) + { + return name.replaceAll("-", "_"); + } + + // Control flow public String filter(AFieldDeclCG field) throws AnalysisException { diff --git a/core/cgisa/src/main/resources/IsaTemplates/Expressions/Seq/Enum.vm b/core/cgisa/src/main/resources/IsaTemplates/Expressions/Seq/Enum.vm index 7faedac9df..a9631ed327 100644 --- a/core/cgisa/src/main/resources/IsaTemplates/Expressions/Seq/Enum.vm +++ b/core/cgisa/src/main/resources/IsaTemplates/Expressions/Seq/Enum.vm @@ -1,3 +1,3 @@ #if ($Isa.isString($node.Type)) -$Isa.makeString($node.Members)#else -$Isa.makeSeq($node.Members)#end \ No newline at end of file +$Isa.transString($node.Members)#else +$Isa.transSeq($node.Members)#end \ No newline at end of file From eacca06a877903c3bd56403ad35b63d620933a8f Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Thu, 19 Feb 2015 18:30:48 +0100 Subject: [PATCH 113/323] Add tests for SeqEnum and String apply translations. --- .../src/test/resources/micro/Values/SeqEnumApply.vdmpp | 6 ++++++ .../test/resources/micro/Values/SeqEnumApply.vdmpp.result | 1 + .../cgisa/src/test/resources/micro/Values/StringApply.vdmpp | 6 ++++++ .../test/resources/micro/Values/StringApply.vdmpp.result | 1 + 4 files changed, 14 insertions(+) create mode 100644 core/cgisa/src/test/resources/micro/Values/SeqEnumApply.vdmpp create mode 100644 core/cgisa/src/test/resources/micro/Values/SeqEnumApply.vdmpp.result create mode 100644 core/cgisa/src/test/resources/micro/Values/StringApply.vdmpp create mode 100644 core/cgisa/src/test/resources/micro/Values/StringApply.vdmpp.result diff --git a/core/cgisa/src/test/resources/micro/Values/SeqEnumApply.vdmpp b/core/cgisa/src/test/resources/micro/Values/SeqEnumApply.vdmpp new file mode 100644 index 0000000000..1174368431 --- /dev/null +++ b/core/cgisa/src/test/resources/micro/Values/SeqEnumApply.vdmpp @@ -0,0 +1,6 @@ +class A + +values +x = [1,2,3](1); + +end A \ No newline at end of file diff --git a/core/cgisa/src/test/resources/micro/Values/SeqEnumApply.vdmpp.result b/core/cgisa/src/test/resources/micro/Values/SeqEnumApply.vdmpp.result new file mode 100644 index 0000000000..de2c5b6d21 --- /dev/null +++ b/core/cgisa/src/test/resources/micro/Values/SeqEnumApply.vdmpp.result @@ -0,0 +1 @@ +{"translation":"theory A\n imports utp_cml\nbegin\n\ndefinition \"x \u003d +|[1, 2, 3]\u003c1\u003e : @nat1|+\"\ndeclare x_def [eval,evalp]\n\nend","errors":false} \ No newline at end of file diff --git a/core/cgisa/src/test/resources/micro/Values/StringApply.vdmpp b/core/cgisa/src/test/resources/micro/Values/StringApply.vdmpp new file mode 100644 index 0000000000..d2b07be106 --- /dev/null +++ b/core/cgisa/src/test/resources/micro/Values/StringApply.vdmpp @@ -0,0 +1,6 @@ +class A + +values +x = "abc"(1); + +end A \ No newline at end of file diff --git a/core/cgisa/src/test/resources/micro/Values/StringApply.vdmpp.result b/core/cgisa/src/test/resources/micro/Values/StringApply.vdmpp.result new file mode 100644 index 0000000000..58c3b16fa9 --- /dev/null +++ b/core/cgisa/src/test/resources/micro/Values/StringApply.vdmpp.result @@ -0,0 +1 @@ +{"translation":"theory A\n imports utp_cml\nbegin\n\ndefinition \"x \u003d +|\u0027\u0027abc\u0027\u0027\u003c1\u003e : @char|+\"\ndeclare x_def [eval,evalp]\n\nend","errors":false} \ No newline at end of file From 758fff1e597efd57acb1bc90b53d5ff6e7cd6288 Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Thu, 19 Feb 2015 18:30:57 +0100 Subject: [PATCH 114/323] Rename module in pom. --- core/cgisa/pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/cgisa/pom.xml b/core/cgisa/pom.xml index 879ef2ac1a..aa2ad6e0e9 100644 --- a/core/cgisa/pom.xml +++ b/core/cgisa/pom.xml @@ -10,7 +10,7 @@ org.overturetool.core cgisa - VDM to Isabelle Code Generation + VDM to Isabelle Translation From dea159aade4428af8c0a726e5fffa480a04a979a Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Thu, 19 Feb 2015 18:34:25 +0100 Subject: [PATCH 115/323] update license headers. --- .../org/overturetool/cgisa/IsaCodeGen.java | 2 +- .../cgisa/IsaTemplateManager.java | 2 +- .../cgisa/IsaTranslationUtils.java | 2 +- .../cgisa/helpers/IsCharTypeVisitor.java | 21 +++++++++++++++++++ .../cgisa/helpers/IsMethodTypeVisitor.java | 21 +++++++++++++++++++ .../cgisa/helpers/IsSeqOfCharTypeVisitor.java | 21 +++++++++++++++++++ .../java/org/overturetool/cgisa/AdHoc.java | 2 +- .../overturetool/cgisa/CgIsaParamTest.java | 21 +++++++++++++++++++ .../overturetool/cgisa/CgIsaTestResult.java | 21 +++++++++++++++++++ 9 files changed, 109 insertions(+), 4 deletions(-) diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaCodeGen.java b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaCodeGen.java index 506a73c918..5e3de20424 100644 --- a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaCodeGen.java +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaCodeGen.java @@ -1,6 +1,6 @@ /* * #%~ - * VDM to Isabelle Code Generation + * VDM to Isabelle Translation * %% * Copyright (C) 2008 - 2015 Overture * %% diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTemplateManager.java b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTemplateManager.java index d2b2443f42..7628671429 100644 --- a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTemplateManager.java +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTemplateManager.java @@ -1,6 +1,6 @@ /* * #%~ - * VDM to Isabelle Code Generation + * VDM to Isabelle Translation * %% * Copyright (C) 2008 - 2015 Overture * %% diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslationUtils.java b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslationUtils.java index 53f905c413..a4a2a5a440 100644 --- a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslationUtils.java +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslationUtils.java @@ -1,6 +1,6 @@ /* * #%~ - * VDM to Isabelle Code Generation + * VDM to Isabelle Translation * %% * Copyright (C) 2008 - 2015 Overture * %% diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/helpers/IsCharTypeVisitor.java b/core/cgisa/src/main/java/org/overturetool/cgisa/helpers/IsCharTypeVisitor.java index b7daa840a1..cf49af8a81 100644 --- a/core/cgisa/src/main/java/org/overturetool/cgisa/helpers/IsCharTypeVisitor.java +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/helpers/IsCharTypeVisitor.java @@ -1,3 +1,24 @@ +/* + * #%~ + * VDM to Isabelle Translation + * %% + * Copyright (C) 2008 - 2015 Overture + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program. If not, see + * . + * #~% + */ package org.overturetool.cgisa.helpers; import org.overture.codegen.cgast.INode; diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/helpers/IsMethodTypeVisitor.java b/core/cgisa/src/main/java/org/overturetool/cgisa/helpers/IsMethodTypeVisitor.java index 112c5cce64..ca55900be8 100644 --- a/core/cgisa/src/main/java/org/overturetool/cgisa/helpers/IsMethodTypeVisitor.java +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/helpers/IsMethodTypeVisitor.java @@ -1,3 +1,24 @@ +/* + * #%~ + * VDM to Isabelle Translation + * %% + * Copyright (C) 2008 - 2015 Overture + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program. If not, see + * . + * #~% + */ package org.overturetool.cgisa.helpers; import org.overture.codegen.cgast.INode; diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/helpers/IsSeqOfCharTypeVisitor.java b/core/cgisa/src/main/java/org/overturetool/cgisa/helpers/IsSeqOfCharTypeVisitor.java index bb618d54cb..dd8b7cb626 100644 --- a/core/cgisa/src/main/java/org/overturetool/cgisa/helpers/IsSeqOfCharTypeVisitor.java +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/helpers/IsSeqOfCharTypeVisitor.java @@ -1,3 +1,24 @@ +/* + * #%~ + * VDM to Isabelle Translation + * %% + * Copyright (C) 2008 - 2015 Overture + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program. If not, see + * . + * #~% + */ package org.overturetool.cgisa.helpers; import org.overture.codegen.cgast.INode; diff --git a/core/cgisa/src/test/java/org/overturetool/cgisa/AdHoc.java b/core/cgisa/src/test/java/org/overturetool/cgisa/AdHoc.java index a2075b0d39..22a33fb85a 100644 --- a/core/cgisa/src/test/java/org/overturetool/cgisa/AdHoc.java +++ b/core/cgisa/src/test/java/org/overturetool/cgisa/AdHoc.java @@ -1,6 +1,6 @@ /* * #%~ - * VDM to Isabelle Code Generation + * VDM to Isabelle Translation * %% * Copyright (C) 2008 - 2015 Overture * %% diff --git a/core/cgisa/src/test/java/org/overturetool/cgisa/CgIsaParamTest.java b/core/cgisa/src/test/java/org/overturetool/cgisa/CgIsaParamTest.java index a752fa2427..5cd5788bb0 100644 --- a/core/cgisa/src/test/java/org/overturetool/cgisa/CgIsaParamTest.java +++ b/core/cgisa/src/test/java/org/overturetool/cgisa/CgIsaParamTest.java @@ -1,3 +1,24 @@ +/* + * #%~ + * VDM to Isabelle Translation + * %% + * Copyright (C) 2008 - 2015 Overture + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program. If not, see + * . + * #~% + */ package org.overturetool.cgisa; import java.lang.reflect.Type; diff --git a/core/cgisa/src/test/java/org/overturetool/cgisa/CgIsaTestResult.java b/core/cgisa/src/test/java/org/overturetool/cgisa/CgIsaTestResult.java index 67a0dd4568..8b9e8fc07b 100644 --- a/core/cgisa/src/test/java/org/overturetool/cgisa/CgIsaTestResult.java +++ b/core/cgisa/src/test/java/org/overturetool/cgisa/CgIsaTestResult.java @@ -1,3 +1,24 @@ +/* + * #%~ + * VDM to Isabelle Translation + * %% + * Copyright (C) 2008 - 2015 Overture + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program. If not, see + * . + * #~% + */ package org.overturetool.cgisa; import java.util.List; From a296f274161a8c5b306d96f27be69df20a0f725f Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Thu, 19 Feb 2015 20:44:53 +0100 Subject: [PATCH 116/323] Added test to exercise shared object binds in code generated traces --- .../traces_expansion_specs/SharedObjectBind | 42 ++++++ .../SharedObjectBind.result | 139 ++++++++++++++++++ 2 files changed, 181 insertions(+) create mode 100644 core/codegen/src/test/resources/traces_expansion_specs/SharedObjectBind create mode 100644 core/codegen/src/test/resources/traces_expansion_specs/SharedObjectBind.result diff --git a/core/codegen/src/test/resources/traces_expansion_specs/SharedObjectBind b/core/codegen/src/test/resources/traces_expansion_specs/SharedObjectBind new file mode 100644 index 0000000000..1225f8756a --- /dev/null +++ b/core/codegen/src/test/resources/traces_expansion_specs/SharedObjectBind @@ -0,0 +1,42 @@ +class Counter + +instance variables + +n : nat := 0; + +operations + +public inc : () ==> nat +inc () == +( + n := n + 1; + return n; +); + +end Counter + +class Entry + +instance variables + +counter : Counter; + +operations + +public Entry : Counter ==> Entry +Entry (pC) == counter := pC; + +public inc : () ==> nat +inc () == counter.inc(); + +traces + +T1: +let c = new Counter(), + a1 = new Entry(c), + a2 = new Entry(c) +in + (a1.inc();a1.inc();a2.inc();a2.inc()){1,2}; + + +end Entry \ No newline at end of file diff --git a/core/codegen/src/test/resources/traces_expansion_specs/SharedObjectBind.result b/core/codegen/src/test/resources/traces_expansion_specs/SharedObjectBind.result new file mode 100644 index 0000000000..e78a057439 --- /dev/null +++ b/core/codegen/src/test/resources/traces_expansion_specs/SharedObjectBind.result @@ -0,0 +1,139 @@ +import org.overture.codegen.runtime.*; + +import java.util.*; + + +public class Counter { + private Number n = 0L; + + public Counter() { + } + + public Number inc() { + n = n.longValue() + 1L; + + return n; + } + + public String toString() { + return "Counter{" + "n := " + Utils.toString(n) + "}"; + } +} + +########## +import org.overture.codegen.runtime.*; +import org.overture.codegen.runtime.traces.*; + +import java.util.*; + + +public class Entry implements java.io.Serializable { + private Counter counter; + + public Entry(final Counter pC) { + cg_init_Entry_1(pC); + } + + public Entry() { + } + + public void cg_init_Entry_1(final Counter pC) { + counter = pC; + } + + public Number inc() { + return counter.inc(); + } + + public void Entry_T1_Run(final TestAccumulator testAccumulator) { + final Store store = new Store(); + final IdGenerator gen = new IdGenerator(); + SequenceTraceNode sequence_1 = new SequenceTraceNode(); + final Number ID_1 = gen.inc(); + final Number ID_2 = gen.inc(); + final Number ID_3 = gen.inc(); + + { + final Counter c = new Counter(); + final Entry a1 = new Entry(c); + final Entry a2 = new Entry(c); + store.register(ID_1, c); + store.register(ID_2, a1); + store.register(ID_3, a2); + } + + SequenceTraceNode sequence_2 = new SequenceTraceNode(); + CallStatement callStm_1 = new CallStatement() { + public Object execute(final Object instance) { + Number result_1 = ((Entry) store.getValue(ID_2)).inc(); + + return result_1; + } + + public String toString() { + return "a1.inc()"; + } + }; + + StatementTraceNode apply_1 = new StatementTraceNode(callStm_1); + + CallStatement callStm_2 = new CallStatement() { + public Object execute(final Object instance) { + Number result_2 = ((Entry) store.getValue(ID_2)).inc(); + + return result_2; + } + + public String toString() { + return "a1.inc()"; + } + }; + + StatementTraceNode apply_2 = new StatementTraceNode(callStm_2); + + CallStatement callStm_3 = new CallStatement() { + public Object execute(final Object instance) { + Number result_3 = ((Entry) store.getValue(ID_3)).inc(); + + return result_3; + } + + public String toString() { + return "a2.inc()"; + } + }; + + StatementTraceNode apply_3 = new StatementTraceNode(callStm_3); + + CallStatement callStm_4 = new CallStatement() { + public Object execute(final Object instance) { + Number result_4 = ((Entry) store.getValue(ID_3)).inc(); + + return result_4; + } + + public String toString() { + return "a2.inc()"; + } + }; + + StatementTraceNode apply_4 = new StatementTraceNode(callStm_4); + + sequence_2.add(apply_1); + sequence_2.add(apply_2); + sequence_2.add(apply_3); + sequence_2.add(apply_4); + + RepeatTraceNode repeat_1 = new RepeatTraceNode(sequence_2, 1L, 2L); + + sequence_1.add(repeat_1); + + TraceNode.executeTests(sequence_1, Entry.class, testAccumulator, store); + } + + public String toString() { + return "Entry{" + "counter := " + Utils.toString(counter) + "}"; + } +} + +########## From a9ca4b11a4938f63d639410e1bb64e15d04adb86 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Thu, 19 Feb 2015 21:11:55 +0100 Subject: [PATCH 117/323] Updates to test results: All classes must be declared serializable when traces are generated --- .../resources/traces_expansion_specs/SharedObjectBind.result | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/codegen/src/test/resources/traces_expansion_specs/SharedObjectBind.result b/core/codegen/src/test/resources/traces_expansion_specs/SharedObjectBind.result index e78a057439..cf78f2d781 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/SharedObjectBind.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/SharedObjectBind.result @@ -3,7 +3,7 @@ import org.overture.codegen.runtime.*; import java.util.*; -public class Counter { +public class Counter implements java.io.Serializable { private Number n = 0L; public Counter() { From c24aa83e7592b891dc6a0366338c271ecbb359c0 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Thu, 19 Feb 2015 21:12:22 +0100 Subject: [PATCH 118/323] Fix for code generation of traces: All classes must be declared serializable when traces are generated --- .../main/java/org/overture/codegen/vdm2java/JavaFormat.java | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaFormat.java b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaFormat.java index e30353ccfb..aca54b72ce 100644 --- a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaFormat.java +++ b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaFormat.java @@ -651,7 +651,8 @@ public String formatInterfaces(AClassDeclCG classDecl) if(interfaces.isEmpty()) { - if(importTraceSupport(classDecl)) + // All classes must be declared Serializable when traces are being generated. + if(info.getSettings().generateTraces()) { return implementsClause + sep + java.io.Serializable.class.getName(); } @@ -667,7 +668,7 @@ public String formatInterfaces(AClassDeclCG classDecl) sep = ", "; } - if(importTraceSupport(classDecl)) + if(info.getSettings().generateTraces()) { implementsClause += sep + java.io.Serializable.class.getName(); } From 47594a58d2d3616537f37a71c4de974186ae65ba Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Mon, 23 Feb 2015 13:42:41 +0100 Subject: [PATCH 119/323] Rename int type template --- .../resources/IsaTemplates/Types/Basic/{Int.vm => Integer.vm} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename core/cgisa/src/main/resources/IsaTemplates/Types/Basic/{Int.vm => Integer.vm} (100%) diff --git a/core/cgisa/src/main/resources/IsaTemplates/Types/Basic/Int.vm b/core/cgisa/src/main/resources/IsaTemplates/Types/Basic/Integer.vm similarity index 100% rename from core/cgisa/src/main/resources/IsaTemplates/Types/Basic/Int.vm rename to core/cgisa/src/main/resources/IsaTemplates/Types/Basic/Integer.vm From 6abf86f5dca22b1a93ca48abecd83207de723d58 Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Mon, 23 Feb 2015 13:42:58 +0100 Subject: [PATCH 120/323] Add line breaks to template with comments. --- .../src/main/resources/IsaTemplates/Expressions/Seq/Enum.vm | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/core/cgisa/src/main/resources/IsaTemplates/Expressions/Seq/Enum.vm b/core/cgisa/src/main/resources/IsaTemplates/Expressions/Seq/Enum.vm index a9631ed327..80a63137c1 100644 --- a/core/cgisa/src/main/resources/IsaTemplates/Expressions/Seq/Enum.vm +++ b/core/cgisa/src/main/resources/IsaTemplates/Expressions/Seq/Enum.vm @@ -1,3 +1,5 @@ #if ($Isa.isString($node.Type)) -$Isa.transString($node.Members)#else -$Isa.transSeq($node.Members)#end \ No newline at end of file +$Isa.transString($node.Members)## +#else +$Isa.transSeq($node.Members)## +#end \ No newline at end of file From 0ad6bd9f990e551bd812c59e1b17f8bd555f7819 Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Mon, 23 Feb 2015 13:55:22 +0100 Subject: [PATCH 121/323] Make varExp translation context aware. If it's an apply root, it's just the varname. Otherwise it's ^varname^. --- .../cgisa/IsaTranslationUtils.java | 22 +++++++++++++++++++ .../IsaTemplates/Expressions/Variable.vm | 6 ++++- 2 files changed, 27 insertions(+), 1 deletion(-) diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslationUtils.java b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslationUtils.java index a4a2a5a440..bae4e881f7 100644 --- a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslationUtils.java +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslationUtils.java @@ -31,6 +31,7 @@ import org.overture.codegen.cgast.analysis.AnalysisException; import org.overture.codegen.cgast.declarations.AFieldDeclCG; import org.overture.codegen.cgast.declarations.AFormalParamLocalParamCG; +import org.overture.codegen.cgast.expressions.AApplyExpCG; import org.overture.codegen.merging.MergeVisitor; import org.overture.codegen.merging.TemplateCallable; import org.overture.codegen.merging.TemplateStructure; @@ -148,6 +149,14 @@ public String norm(String name) { return name.replaceAll("-", "_"); } + + public String varWrap(String v){ + StringBuilder sb = new StringBuilder(); + sb.append('<'); + sb.append(v); + sb.append('>'); + return sb.toString(); + } // Control flow @@ -162,6 +171,19 @@ public String filter(AFieldDeclCG field) throws AnalysisException } // Checks + + public boolean isRoot(INode node) + { + if (node.parent() instanceof AApplyExpCG) + { + AApplyExpCG par = (AApplyExpCG) node.parent(); + if (par.getRoot() == node) + { + return true; + } + } + return false; + } public boolean isString(STypeCG node) throws AnalysisException { diff --git a/core/cgisa/src/main/resources/IsaTemplates/Expressions/Variable.vm b/core/cgisa/src/main/resources/IsaTemplates/Expressions/Variable.vm index 0aed265d43..17f789fa6a 100644 --- a/core/cgisa/src/main/resources/IsaTemplates/Expressions/Variable.vm +++ b/core/cgisa/src/main/resources/IsaTemplates/Expressions/Variable.vm @@ -1 +1,5 @@ -^$node.Name^ \ No newline at end of file +#if ($Isa.isRoot($node) ) +$node.Name ## +#else ## +^${node.Name}^ ## +#end \ No newline at end of file From b272645657482cb9f18fac7f644f29f117803f33 Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Mon, 23 Feb 2015 13:55:44 +0100 Subject: [PATCH 122/323] Add function application support. --- .../src/main/resources/IsaTemplates/Expressions/Apply.vm | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/core/cgisa/src/main/resources/IsaTemplates/Expressions/Apply.vm b/core/cgisa/src/main/resources/IsaTemplates/Expressions/Apply.vm index 794c646ab6..fb9706537a 100644 --- a/core/cgisa/src/main/resources/IsaTemplates/Expressions/Apply.vm +++ b/core/cgisa/src/main/resources/IsaTemplates/Expressions/Apply.vm @@ -1,6 +1,7 @@ #set( $root = $Isa.trans($node.Root) ) #set( $args = $Isa.transArgs($node.Args) ) -#if ($Isa.isFuncType($node.Root.Type) ) -a func! +#if ($Isa.isFunc($node.Root.Type) ) +${root}(${args})## #else -$root<$args>#end \ No newline at end of file +$root<$args>## +#end \ No newline at end of file From 461dfe5dcf3aaae02f3a9d56b04c77d076b1e340 Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Mon, 23 Feb 2015 13:57:39 +0100 Subject: [PATCH 123/323] Rename test files. --- .../micro/Functions/{Func1Param.vdmpp => FuncDecl1Param.vdmpp} | 0 .../{Func1Param.vdmpp.result => FuncDecl1Param.vdmpp.result} | 0 .../micro/Functions/{Func2Params.vdmpp => FuncDecl2Params.vdmpp} | 0 .../{Func2Params.vdmpp.result => FuncDecl2Params.vdmpp.result} | 0 .../micro/Functions/{FuncNoParam.vdmpp => FuncDeclNoParam.vdmpp} | 0 .../{FuncNoParam.vdmpp.result => FuncDeclNoParam.vdmpp.result} | 0 6 files changed, 0 insertions(+), 0 deletions(-) rename core/cgisa/src/test/resources/micro/Functions/{Func1Param.vdmpp => FuncDecl1Param.vdmpp} (100%) rename core/cgisa/src/test/resources/micro/Functions/{Func1Param.vdmpp.result => FuncDecl1Param.vdmpp.result} (100%) rename core/cgisa/src/test/resources/micro/Functions/{Func2Params.vdmpp => FuncDecl2Params.vdmpp} (100%) rename core/cgisa/src/test/resources/micro/Functions/{Func2Params.vdmpp.result => FuncDecl2Params.vdmpp.result} (100%) rename core/cgisa/src/test/resources/micro/Functions/{FuncNoParam.vdmpp => FuncDeclNoParam.vdmpp} (100%) rename core/cgisa/src/test/resources/micro/Functions/{FuncNoParam.vdmpp.result => FuncDeclNoParam.vdmpp.result} (100%) diff --git a/core/cgisa/src/test/resources/micro/Functions/Func1Param.vdmpp b/core/cgisa/src/test/resources/micro/Functions/FuncDecl1Param.vdmpp similarity index 100% rename from core/cgisa/src/test/resources/micro/Functions/Func1Param.vdmpp rename to core/cgisa/src/test/resources/micro/Functions/FuncDecl1Param.vdmpp diff --git a/core/cgisa/src/test/resources/micro/Functions/Func1Param.vdmpp.result b/core/cgisa/src/test/resources/micro/Functions/FuncDecl1Param.vdmpp.result similarity index 100% rename from core/cgisa/src/test/resources/micro/Functions/Func1Param.vdmpp.result rename to core/cgisa/src/test/resources/micro/Functions/FuncDecl1Param.vdmpp.result diff --git a/core/cgisa/src/test/resources/micro/Functions/Func2Params.vdmpp b/core/cgisa/src/test/resources/micro/Functions/FuncDecl2Params.vdmpp similarity index 100% rename from core/cgisa/src/test/resources/micro/Functions/Func2Params.vdmpp rename to core/cgisa/src/test/resources/micro/Functions/FuncDecl2Params.vdmpp diff --git a/core/cgisa/src/test/resources/micro/Functions/Func2Params.vdmpp.result b/core/cgisa/src/test/resources/micro/Functions/FuncDecl2Params.vdmpp.result similarity index 100% rename from core/cgisa/src/test/resources/micro/Functions/Func2Params.vdmpp.result rename to core/cgisa/src/test/resources/micro/Functions/FuncDecl2Params.vdmpp.result diff --git a/core/cgisa/src/test/resources/micro/Functions/FuncNoParam.vdmpp b/core/cgisa/src/test/resources/micro/Functions/FuncDeclNoParam.vdmpp similarity index 100% rename from core/cgisa/src/test/resources/micro/Functions/FuncNoParam.vdmpp rename to core/cgisa/src/test/resources/micro/Functions/FuncDeclNoParam.vdmpp diff --git a/core/cgisa/src/test/resources/micro/Functions/FuncNoParam.vdmpp.result b/core/cgisa/src/test/resources/micro/Functions/FuncDeclNoParam.vdmpp.result similarity index 100% rename from core/cgisa/src/test/resources/micro/Functions/FuncNoParam.vdmpp.result rename to core/cgisa/src/test/resources/micro/Functions/FuncDeclNoParam.vdmpp.result From f29af251bf2964676db49b9c2e8249e6b8b02a56 Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Mon, 23 Feb 2015 14:09:34 +0100 Subject: [PATCH 124/323] Add translation of function output type Also try to clean up spacing of var exp. --- .../main/resources/IsaTemplates/Declarations/Function.vm | 2 +- .../src/main/resources/IsaTemplates/Expressions/Variable.vm | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/core/cgisa/src/main/resources/IsaTemplates/Declarations/Function.vm b/core/cgisa/src/main/resources/IsaTemplates/Declarations/Function.vm index 0d3c172ecd..2acc890aef 100644 --- a/core/cgisa/src/main/resources/IsaTemplates/Declarations/Function.vm +++ b/core/cgisa/src/main/resources/IsaTemplates/Declarations/Function.vm @@ -1,4 +1,4 @@ cmlefun $node.Name inp $Isa.transParams($node.FormalParams) - out "@type" + out "$Isa.trans($node.MethodType.Result)" is "$Isa.trans($node.Body)" \ No newline at end of file diff --git a/core/cgisa/src/main/resources/IsaTemplates/Expressions/Variable.vm b/core/cgisa/src/main/resources/IsaTemplates/Expressions/Variable.vm index 17f789fa6a..bf92021400 100644 --- a/core/cgisa/src/main/resources/IsaTemplates/Expressions/Variable.vm +++ b/core/cgisa/src/main/resources/IsaTemplates/Expressions/Variable.vm @@ -1,5 +1,5 @@ #if ($Isa.isRoot($node) ) -$node.Name ## -#else ## -^${node.Name}^ ## +${node.Name}## +#else## +^${node.Name}^## #end \ No newline at end of file From cb49491677af8a19b876d39a2cecfe4162ec2667 Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Mon, 23 Feb 2015 14:10:00 +0100 Subject: [PATCH 125/323] Update test results --- .../test/resources/micro/Functions/FuncDecl1Param.vdmpp.result | 2 +- .../test/resources/micro/Functions/FuncDecl2Params.vdmpp.result | 2 +- .../test/resources/micro/Functions/FuncDeclNoParam.vdmpp.result | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/core/cgisa/src/test/resources/micro/Functions/FuncDecl1Param.vdmpp.result b/core/cgisa/src/test/resources/micro/Functions/FuncDecl1Param.vdmpp.result index 1704c291f6..a9d64daca8 100644 --- a/core/cgisa/src/test/resources/micro/Functions/FuncDecl1Param.vdmpp.result +++ b/core/cgisa/src/test/resources/micro/Functions/FuncDecl1Param.vdmpp.result @@ -1 +1 @@ -{"translation":"theory A\n imports utp_cml\nbegin\n\ncmlefun f\n inp x :: \"@nat\"\n out \"@type\"\n is \"^x^\"\n\nend","errors":false} \ No newline at end of file +{"translation":"theory A\n imports utp_cml\nbegin\n\ncmlefun f\n inp x :: \"@nat\"\n out \"@nat\"\n is \"^x^\"\n\nend","errors":false} \ No newline at end of file diff --git a/core/cgisa/src/test/resources/micro/Functions/FuncDecl2Params.vdmpp.result b/core/cgisa/src/test/resources/micro/Functions/FuncDecl2Params.vdmpp.result index 34bd40b2fd..5acd3d04c9 100644 --- a/core/cgisa/src/test/resources/micro/Functions/FuncDecl2Params.vdmpp.result +++ b/core/cgisa/src/test/resources/micro/Functions/FuncDecl2Params.vdmpp.result @@ -1 +1 @@ -{"translation":"theory A\n imports utp_cml\nbegin\n\ncmlefun f\n inp x :: \"@nat\" and y :: \"@nat\"\n out \"@type\"\n is \"^x^\"\n\nend","errors":false} \ No newline at end of file +{"translation":"theory A\n imports utp_cml\nbegin\n\ncmlefun f\n inp x :: \"@nat\" and y :: \"@nat\"\n out \"@nat\"\n is \"^x^\"\n\nend","errors":false} \ No newline at end of file diff --git a/core/cgisa/src/test/resources/micro/Functions/FuncDeclNoParam.vdmpp.result b/core/cgisa/src/test/resources/micro/Functions/FuncDeclNoParam.vdmpp.result index c6c992bfe8..4b4a8e9350 100644 --- a/core/cgisa/src/test/resources/micro/Functions/FuncDeclNoParam.vdmpp.result +++ b/core/cgisa/src/test/resources/micro/Functions/FuncDeclNoParam.vdmpp.result @@ -1 +1 @@ -{"translation":"theory A\n imports utp_cml\nbegin\n\ncmlefun f\n inp \n out \"@type\"\n is \"0\"\n\nend","errors":false} \ No newline at end of file +{"translation":"theory A\n imports utp_cml\nbegin\n\ncmlefun f\n inp \n out \"@nat\"\n is \"0\"\n\nend","errors":false} \ No newline at end of file From 5c046fab041973acc310a0a81f6c555e39cf6342 Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Mon, 23 Feb 2015 14:41:14 +0100 Subject: [PATCH 126/323] Unify parameter list translation methods. --- .../cgisa/IsaTranslationUtils.java | 44 +++++++------------ .../IsaTemplates/Declarations/Function.vm | 2 +- .../IsaTemplates/Expressions/Apply.vm | 2 +- 3 files changed, 17 insertions(+), 31 deletions(-) diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslationUtils.java b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslationUtils.java index bae4e881f7..c57656f7f5 100644 --- a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslationUtils.java +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslationUtils.java @@ -42,8 +42,8 @@ public class IsaTranslationUtils { private static final String TEMPLATE_CALLABLE_NAME = "Isa"; - private static final Object PARAM_SEP = " and "; - private static final Object LIST_SEP = ", "; + private static final String TYPE_PARAM_SEP = " and "; + private static final String LIST_SEP = ", "; private MergeVisitor mergeVisitor; public IsaTranslationUtils(TemplateStructure templateStructure) @@ -67,12 +67,22 @@ public String trans(INode node) throws AnalysisException return writer.toString(); } - public String transParams(List params) + public String transApplyParams(List params) + throws AnalysisException + { + return transParams(params, LIST_SEP); + } + + public String transTypeParams(List params) throws AnalysisException + { + return transParams(params, TYPE_PARAM_SEP); + } + public String transParams(List params, String sep) throws AnalysisException { StringBuilder sb = new StringBuilder(); - Iterator it = params.iterator(); + Iterator it = params.iterator(); while (it.hasNext()) { @@ -81,33 +91,9 @@ public String transParams(List params) sb.append(writer.toString()); if (it.hasNext()) { - sb.append(PARAM_SEP); + sb.append(sep); } - } - - return sb.toString(); - } - - public String transArgs(List args) throws AnalysisException - { - if (args.isEmpty()) - { - return ""; - } - StringBuilder sb = new StringBuilder(); - - Iterator it = args.iterator(); - - while (it.hasNext()) - { - sb.append(trans(it.next())); - if (it.hasNext()) - { - sb.append(PARAM_SEP); - } - } - return sb.toString(); } diff --git a/core/cgisa/src/main/resources/IsaTemplates/Declarations/Function.vm b/core/cgisa/src/main/resources/IsaTemplates/Declarations/Function.vm index 2acc890aef..83ac5fe45a 100644 --- a/core/cgisa/src/main/resources/IsaTemplates/Declarations/Function.vm +++ b/core/cgisa/src/main/resources/IsaTemplates/Declarations/Function.vm @@ -1,4 +1,4 @@ cmlefun $node.Name - inp $Isa.transParams($node.FormalParams) + inp $Isa.transTypeParams($node.FormalParams) out "$Isa.trans($node.MethodType.Result)" is "$Isa.trans($node.Body)" \ No newline at end of file diff --git a/core/cgisa/src/main/resources/IsaTemplates/Expressions/Apply.vm b/core/cgisa/src/main/resources/IsaTemplates/Expressions/Apply.vm index fb9706537a..c51b79f8ce 100644 --- a/core/cgisa/src/main/resources/IsaTemplates/Expressions/Apply.vm +++ b/core/cgisa/src/main/resources/IsaTemplates/Expressions/Apply.vm @@ -1,5 +1,5 @@ #set( $root = $Isa.trans($node.Root) ) -#set( $args = $Isa.transArgs($node.Args) ) +#set( $args = $Isa.transApplyParams($node.Args)) #if ($Isa.isFunc($node.Root.Type) ) ${root}(${args})## #else From e1f22b0194890c9855be0496ea831cb37db07090 Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Mon, 23 Feb 2015 14:41:29 +0100 Subject: [PATCH 127/323] Add tests for function application. --- .../resources/micro/Functions/FuncApply1Param.vdmpp | 11 +++++++++++ .../micro/Functions/FuncApply1Param.vdmpp.result | 1 + .../resources/micro/Functions/FuncApply3Params.vdmpp | 10 ++++++++++ .../micro/Functions/FuncApply3Params.vdmpp.result | 1 + .../resources/micro/Functions/FuncApplyNoParam.vdmpp | 11 +++++++++++ .../micro/Functions/FuncApplyNoParam.vdmpp.result | 1 + 6 files changed, 35 insertions(+) create mode 100644 core/cgisa/src/test/resources/micro/Functions/FuncApply1Param.vdmpp create mode 100644 core/cgisa/src/test/resources/micro/Functions/FuncApply1Param.vdmpp.result create mode 100644 core/cgisa/src/test/resources/micro/Functions/FuncApply3Params.vdmpp create mode 100644 core/cgisa/src/test/resources/micro/Functions/FuncApply3Params.vdmpp.result create mode 100644 core/cgisa/src/test/resources/micro/Functions/FuncApplyNoParam.vdmpp create mode 100644 core/cgisa/src/test/resources/micro/Functions/FuncApplyNoParam.vdmpp.result diff --git a/core/cgisa/src/test/resources/micro/Functions/FuncApply1Param.vdmpp b/core/cgisa/src/test/resources/micro/Functions/FuncApply1Param.vdmpp new file mode 100644 index 0000000000..1f82daf896 --- /dev/null +++ b/core/cgisa/src/test/resources/micro/Functions/FuncApply1Param.vdmpp @@ -0,0 +1,11 @@ +class A + +functions +f : int -> int +f (x) == 0; + +values +x = f(1); + + +end A \ No newline at end of file diff --git a/core/cgisa/src/test/resources/micro/Functions/FuncApply1Param.vdmpp.result b/core/cgisa/src/test/resources/micro/Functions/FuncApply1Param.vdmpp.result new file mode 100644 index 0000000000..1fcb0a7f9c --- /dev/null +++ b/core/cgisa/src/test/resources/micro/Functions/FuncApply1Param.vdmpp.result @@ -0,0 +1 @@ +{"translation":"theory A\n imports utp_cml\nbegin\n\ncmlefun f\n inp x :: \"@int\"\n out \"@int\"\n is \"0\"\n\ndefinition \"x \u003d +|f(1) : @int|+\"\ndeclare x_def [eval,evalp]\n\nend","errors":false} \ No newline at end of file diff --git a/core/cgisa/src/test/resources/micro/Functions/FuncApply3Params.vdmpp b/core/cgisa/src/test/resources/micro/Functions/FuncApply3Params.vdmpp new file mode 100644 index 0000000000..06e445b483 --- /dev/null +++ b/core/cgisa/src/test/resources/micro/Functions/FuncApply3Params.vdmpp @@ -0,0 +1,10 @@ +class A + +functions +f : int * int * int -> int +f (x,y,z) == 0; + +values +x = f(1,2,3); + +end A \ No newline at end of file diff --git a/core/cgisa/src/test/resources/micro/Functions/FuncApply3Params.vdmpp.result b/core/cgisa/src/test/resources/micro/Functions/FuncApply3Params.vdmpp.result new file mode 100644 index 0000000000..0cc2ea78a4 --- /dev/null +++ b/core/cgisa/src/test/resources/micro/Functions/FuncApply3Params.vdmpp.result @@ -0,0 +1 @@ +{"translation":"theory A\n imports utp_cml\nbegin\n\ncmlefun f\n inp x :: \"@int\" and y :: \"@int\" and z :: \"@int\"\n out \"@int\"\n is \"0\"\n\ndefinition \"x \u003d +|f(1, 2, 3) : @int|+\"\ndeclare x_def [eval,evalp]\n\nend","errors":false} \ No newline at end of file diff --git a/core/cgisa/src/test/resources/micro/Functions/FuncApplyNoParam.vdmpp b/core/cgisa/src/test/resources/micro/Functions/FuncApplyNoParam.vdmpp new file mode 100644 index 0000000000..9d2788a3c1 --- /dev/null +++ b/core/cgisa/src/test/resources/micro/Functions/FuncApplyNoParam.vdmpp @@ -0,0 +1,11 @@ +class A + +functions +f : () -> int +f () == 0; + +values +x = f(); + + +end A \ No newline at end of file diff --git a/core/cgisa/src/test/resources/micro/Functions/FuncApplyNoParam.vdmpp.result b/core/cgisa/src/test/resources/micro/Functions/FuncApplyNoParam.vdmpp.result new file mode 100644 index 0000000000..3ed0179787 --- /dev/null +++ b/core/cgisa/src/test/resources/micro/Functions/FuncApplyNoParam.vdmpp.result @@ -0,0 +1 @@ +{"translation":"theory A\n imports utp_cml\nbegin\n\ncmlefun f\n inp \n out \"@int\"\n is \"0\"\n\ndefinition \"x \u003d +|f() : @int|+\"\ndeclare x_def [eval,evalp]\n\nend","errors":false} \ No newline at end of file From 5116f3334919df0822173c560bf42b92952a5216 Mon Sep 17 00:00:00 2001 From: gkanos Date: Mon, 23 Feb 2015 16:31:58 +0100 Subject: [PATCH 128/323] removed and changed some fixme tags. To remove the rest fixme tags into the package, I need info if fixed or not. --- .../java/org/overture/modelcheckers/probsolver/MapTests.java | 2 +- .../modelcheckers/probsolver/ProbConverterTestBase.java | 1 - 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/core/modelcheckers/probsolver/src/test/java/org/overture/modelcheckers/probsolver/MapTests.java b/core/modelcheckers/probsolver/src/test/java/org/overture/modelcheckers/probsolver/MapTests.java index eb85c4eced..a15edffc2e 100644 --- a/core/modelcheckers/probsolver/src/test/java/org/overture/modelcheckers/probsolver/MapTests.java +++ b/core/modelcheckers/probsolver/src/test/java/org/overture/modelcheckers/probsolver/MapTests.java @@ -46,7 +46,7 @@ public static Collection getData() Collection tests = new LinkedList(); - tests.addAll(getTests(new File(root), "Map-0026"));// FIXME + tests.addAll(getTests(new File(root), "Map-0026"));//FIXME:What to fix? return tests; } diff --git a/core/modelcheckers/probsolver/src/test/java/org/overture/modelcheckers/probsolver/ProbConverterTestBase.java b/core/modelcheckers/probsolver/src/test/java/org/overture/modelcheckers/probsolver/ProbConverterTestBase.java index 247bd93c4c..25f2ee7c9e 100644 --- a/core/modelcheckers/probsolver/src/test/java/org/overture/modelcheckers/probsolver/ProbConverterTestBase.java +++ b/core/modelcheckers/probsolver/src/test/java/org/overture/modelcheckers/probsolver/ProbConverterTestBase.java @@ -360,7 +360,6 @@ public String decodeResult(Node node) protected boolean assertEqualResults(String expected, String actual, PrintWriter out) { - // FIXME: check is not sufficient if (expected == null) { assert false : "No result file"; From 3a822f7d21a539741cfadbff6ce931781a17c8d3 Mon Sep 17 00:00:00 2001 From: gkanos Date: Mon, 23 Feb 2015 16:45:21 +0100 Subject: [PATCH 129/323] more FIXME tags removed. --- .../main/java/org/overture/guibuilder/internal/Driver.java | 2 +- .../interpreter/tests/StringBasedInterpreterTest.java | 1 - .../probsolver/visitors/VdmToBExpressionConverter.java | 4 ++-- 3 files changed, 3 insertions(+), 4 deletions(-) diff --git a/core/guibuilder/src/main/java/org/overture/guibuilder/internal/Driver.java b/core/guibuilder/src/main/java/org/overture/guibuilder/internal/Driver.java index 4b1fee0edd..00082ed9ff 100644 --- a/core/guibuilder/src/main/java/org/overture/guibuilder/internal/Driver.java +++ b/core/guibuilder/src/main/java/org/overture/guibuilder/internal/Driver.java @@ -141,7 +141,7 @@ public static void main(String[] args) throws Exception // // contents of directory // for (File file: dir.listFiles(new FilenameFilter(){ // // filter for xml files (checks if the filename contains ".xml" - // // FIXME: ugly + // @Override // public boolean accept(File arg0, String arg1) { // if ( arg1.contains(".xml") ) diff --git a/core/interpreter/src/test/java/org/overture/interpreter/tests/StringBasedInterpreterTest.java b/core/interpreter/src/test/java/org/overture/interpreter/tests/StringBasedInterpreterTest.java index 3cdb57dd1d..723d53d373 100644 --- a/core/interpreter/src/test/java/org/overture/interpreter/tests/StringBasedInterpreterTest.java +++ b/core/interpreter/src/test/java/org/overture/interpreter/tests/StringBasedInterpreterTest.java @@ -64,7 +64,6 @@ public String decodeResult(Node node) protected boolean assertEqualResults(String expected, String actual, PrintWriter out) { - // FIXME: check is not sufficient if (expected == null) { assert false : "No result file"; diff --git a/core/modelcheckers/probsolver/src/main/java/org/overture/modelcheckers/probsolver/visitors/VdmToBExpressionConverter.java b/core/modelcheckers/probsolver/src/main/java/org/overture/modelcheckers/probsolver/visitors/VdmToBExpressionConverter.java index c1c6ccef7f..e652313144 100644 --- a/core/modelcheckers/probsolver/src/main/java/org/overture/modelcheckers/probsolver/visitors/VdmToBExpressionConverter.java +++ b/core/modelcheckers/probsolver/src/main/java/org/overture/modelcheckers/probsolver/visitors/VdmToBExpressionConverter.java @@ -317,7 +317,7 @@ public Node caseANotUnaryExp(ANotUnaryExp node) throws AnalysisException } @Override - public Node caseABooleanConstExp(ABooleanConstExp node)// FIXME: not yet check + public Node caseABooleanConstExp(ABooleanConstExp node) throws AnalysisException { @@ -535,7 +535,7 @@ public Node caseATailUnaryExp(ATailUnaryExp node) throws AnalysisException } @Override - public Node caseAIndicesUnaryExp(AIndicesUnaryExp node)// FIXME: not yet check + public Node caseAIndicesUnaryExp(AIndicesUnaryExp node) throws AnalysisException { LinkedList seqmem = ((ASeqEnumSeqExp) node.getExp()).getMembers(); From c56dc3b8226f4ab40c30811113eb2e570cb15f6b Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Mon, 23 Feb 2015 17:41:57 +0100 Subject: [PATCH 130/323] Add common utilities class (needs better name!) --- .../overturetool/cgisa/IsaCommonUtils.java | 20 +++++++++++++++++++ .../cgisa/IsaTranslationUtils.java | 13 ++++-------- 2 files changed, 24 insertions(+), 9 deletions(-) create mode 100644 core/cgisa/src/main/java/org/overturetool/cgisa/IsaCommonUtils.java diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaCommonUtils.java b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaCommonUtils.java new file mode 100644 index 0000000000..f85a7b5775 --- /dev/null +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaCommonUtils.java @@ -0,0 +1,20 @@ +package org.overturetool.cgisa; + +import org.overture.codegen.cgast.INode; +import org.overture.codegen.cgast.expressions.AApplyExpCG; + +public class IsaCommonUtils +{ + public boolean isRoot(INode node) + { + if (node.parent() instanceof AApplyExpCG) + { + AApplyExpCG par = (AApplyExpCG) node.parent(); + if (par.getRoot() == node) + { + return true; + } + } + return false; + } +} diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslationUtils.java b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslationUtils.java index c57656f7f5..17371cca91 100644 --- a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslationUtils.java +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslationUtils.java @@ -46,10 +46,13 @@ public class IsaTranslationUtils private static final String LIST_SEP = ", "; private MergeVisitor mergeVisitor; + protected IsaCommonUtils isaUtils; + public IsaTranslationUtils(TemplateStructure templateStructure) { TemplateCallable[] templateCallables = new TemplateCallable[] { new TemplateCallable(TEMPLATE_CALLABLE_NAME, this) }; this.mergeVisitor = new MergeVisitor(new IsaTemplateManager(templateStructure), templateCallables); + this.isaUtils = new IsaCommonUtils(); } public MergeVisitor getMergeVisitor() @@ -160,15 +163,7 @@ public String filter(AFieldDeclCG field) throws AnalysisException public boolean isRoot(INode node) { - if (node.parent() instanceof AApplyExpCG) - { - AApplyExpCG par = (AApplyExpCG) node.parent(); - if (par.getRoot() == node) - { - return true; - } - } - return false; + return isaUtils.isRoot(node); } public boolean isString(STypeCG node) throws AnalysisException From 2bd25f60b991bedf458471784bbb47198ece13f5 Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Mon, 23 Feb 2015 17:47:01 +0100 Subject: [PATCH 131/323] Add initial Sort Dependency transformation. --- .../org/overturetool/cgisa/IsaCodeGen.java | 14 +- .../transformations/SortDependencies.java | 135 ++++++++++++++++++ .../micro/Functions/FuncDepSimple.vdmpp | 10 ++ .../Functions/FuncDepSimple.vdmpp.result | 1 + 4 files changed, 157 insertions(+), 3 deletions(-) create mode 100644 core/cgisa/src/main/java/org/overturetool/cgisa/transformations/SortDependencies.java create mode 100644 core/cgisa/src/test/resources/micro/Functions/FuncDepSimple.vdmpp create mode 100644 core/cgisa/src/test/resources/micro/Functions/FuncDepSimple.vdmpp.result diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaCodeGen.java b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaCodeGen.java index 5e3de20424..6fd94d136e 100644 --- a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaCodeGen.java +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaCodeGen.java @@ -39,6 +39,7 @@ import org.overture.codegen.merging.MergeVisitor; import org.overture.codegen.merging.TemplateStructure; import org.overture.codegen.utils.GeneratedModule; +import org.overturetool.cgisa.transformations.SortDependencies; /** * Main facade class for VDM 2 Isabelle CG @@ -77,7 +78,6 @@ List generateIsabelleSyntax(List ast) throws AnalysisException, org.overture.codegen.cgast.analysis.AnalysisException { - // <> // Transform AST into IR List statuses = new LinkedList<>(); @@ -102,14 +102,22 @@ List generateIsabelleSyntax(List ast) MergeVisitor pp = isa.getMergeVisitor(); - StringWriter sw = new StringWriter(); List generated = new ArrayList(); + + for (IRClassDeclStatus status : statuses) + { + SortDependencies sortTrans = new SortDependencies(status.getClassCg().getFunctions()); + generator.applyTransformation(status, sortTrans); + } + for (IRClassDeclStatus status : statuses) { AClassDeclCG irClass = status.getClassCg(); + StringWriter sw = new StringWriter(); + irClass.apply(pp, sw); if (pp.hasMergeErrors()) @@ -128,7 +136,7 @@ List generateIsabelleSyntax(List ast) } } - + // Return syntax return generated; diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/transformations/SortDependencies.java b/core/cgisa/src/main/java/org/overturetool/cgisa/transformations/SortDependencies.java new file mode 100644 index 0000000000..99cf7762db --- /dev/null +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/transformations/SortDependencies.java @@ -0,0 +1,135 @@ +package org.overturetool.cgisa.transformations; + +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.Vector; + +import org.overture.codegen.cgast.analysis.AnalysisException; +import org.overture.codegen.cgast.analysis.DepthFirstAnalysisAdaptor; +import org.overture.codegen.cgast.declarations.AClassDeclCG; +import org.overture.codegen.cgast.declarations.AFuncDeclCG; +import org.overture.codegen.cgast.expressions.SVarExpCG; +import org.overturetool.cgisa.IsaCommonUtils; + +public class SortDependencies extends DepthFirstAnalysisAdaptor +{ + List funcs; + Map> depGraph; + private List sorted; + + protected IsaCommonUtils isaUtils; + + public SortDependencies(List funcs) + { + this.funcs = funcs; + this.isaUtils = new IsaCommonUtils(); + this.depGraph = new HashMap<>(); + this.sorted = new Vector(); + init(); + } + + @Override + public void caseAClassDeclCG(AClassDeclCG node) throws AnalysisException + { + List clonedList = new Vector(); + + for (AFuncDeclCG f : sorted) + { + clonedList.add(f.clone()); + } + node.setFunctions(clonedList); + } + + private void init() + { + for (AFuncDeclCG func : funcs) + { + try + { + List dependencies = findDependencies(func); + if (!dependencies.isEmpty()) + { + depGraph.put(func, dependencies); + } else + { + depGraph.put(func, new Vector()); + } + } catch (AnalysisException e) + { + e.printStackTrace(); + } + } + + sortDeps(); + + } + + private void sortDeps() + { + Set unmarked = depGraph.keySet(); + Set tempMarks = new HashSet<>(); + + while (!unmarked.isEmpty()) + { + AFuncDeclCG n = unmarked.toArray(new AFuncDeclCG[1])[0]; + visit(n, tempMarks, unmarked); + } + } + + private void visit(AFuncDeclCG n, Set tempMarks, + Set unmarked) + { + if (tempMarks.contains(n)) + { + throw new RuntimeException("Cyclic dependency"); + } + if (unmarked.contains(n)) + { + tempMarks.add(n); + + for (AFuncDeclCG d : depGraph.get(n)) + { + visit(d, tempMarks, unmarked); + } + unmarked.remove(n); + tempMarks.remove(n); + sorted.add(n); // we want reverse topological order since its dependencies. + } + } + + private List findDependencies(AFuncDeclCG func) + throws AnalysisException + { + final Set vars = new HashSet(); + + func.getBody().apply(new DepthFirstAnalysisAdaptor() + { + public void defaultInSVarExpCG(SVarExpCG node) + throws AnalysisException + { + if (isaUtils.isRoot(node)) + { + vars.add(node); + } + } + }); + + List deps = new Vector(); + for (SVarExpCG v : vars) + { + for (AFuncDeclCG f : funcs) + { + if (v.getName().equals(f.getName())) + { + deps.add(f); + break; + } + } + } + + return deps; + } +} diff --git a/core/cgisa/src/test/resources/micro/Functions/FuncDepSimple.vdmpp b/core/cgisa/src/test/resources/micro/Functions/FuncDepSimple.vdmpp new file mode 100644 index 0000000000..e31fc22c28 --- /dev/null +++ b/core/cgisa/src/test/resources/micro/Functions/FuncDepSimple.vdmpp @@ -0,0 +1,10 @@ +class A + +functions +f : int -> int +f(x)== g(x); + +g : int -> int +g(x)== 0; + +end A \ No newline at end of file diff --git a/core/cgisa/src/test/resources/micro/Functions/FuncDepSimple.vdmpp.result b/core/cgisa/src/test/resources/micro/Functions/FuncDepSimple.vdmpp.result new file mode 100644 index 0000000000..6d40299395 --- /dev/null +++ b/core/cgisa/src/test/resources/micro/Functions/FuncDepSimple.vdmpp.result @@ -0,0 +1 @@ +{"translation":"theory A\n imports utp_cml\nbegin\n\ncmlefun g\n inp x :: \"@int\"\n out \"@int\"\n is \"0\"\n\ncmlefun f\n inp x :: \"@int\"\n out \"@int\"\n is \"g(^x^)\"\n\nend","errors":false} \ No newline at end of file From b117c2c136a22bd2d76e6084ff20d8bc3b0bb711 Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Mon, 23 Feb 2015 18:05:28 +0100 Subject: [PATCH 132/323] Rename helpers package --- .../java/org/overturetool/cgisa/IsaTranslationUtils.java | 5 ++--- .../cgisa/{helpers => checkers}/IsCharTypeVisitor.java | 2 +- .../cgisa/{helpers => checkers}/IsMethodTypeVisitor.java | 2 +- .../cgisa/{helpers => checkers}/IsSeqOfCharTypeVisitor.java | 2 +- 4 files changed, 5 insertions(+), 6 deletions(-) rename core/cgisa/src/main/java/org/overturetool/cgisa/{helpers => checkers}/IsCharTypeVisitor.java (97%) rename core/cgisa/src/main/java/org/overturetool/cgisa/{helpers => checkers}/IsMethodTypeVisitor.java (97%) rename core/cgisa/src/main/java/org/overturetool/cgisa/{helpers => checkers}/IsSeqOfCharTypeVisitor.java (97%) diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslationUtils.java b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslationUtils.java index 17371cca91..6027251f3f 100644 --- a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslationUtils.java +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslationUtils.java @@ -31,12 +31,11 @@ import org.overture.codegen.cgast.analysis.AnalysisException; import org.overture.codegen.cgast.declarations.AFieldDeclCG; import org.overture.codegen.cgast.declarations.AFormalParamLocalParamCG; -import org.overture.codegen.cgast.expressions.AApplyExpCG; import org.overture.codegen.merging.MergeVisitor; import org.overture.codegen.merging.TemplateCallable; import org.overture.codegen.merging.TemplateStructure; -import org.overturetool.cgisa.helpers.IsMethodTypeVisitor; -import org.overturetool.cgisa.helpers.IsSeqOfCharTypeVisitor; +import org.overturetool.cgisa.checkers.IsMethodTypeVisitor; +import org.overturetool.cgisa.checkers.IsSeqOfCharTypeVisitor; public class IsaTranslationUtils { diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/helpers/IsCharTypeVisitor.java b/core/cgisa/src/main/java/org/overturetool/cgisa/checkers/IsCharTypeVisitor.java similarity index 97% rename from core/cgisa/src/main/java/org/overturetool/cgisa/helpers/IsCharTypeVisitor.java rename to core/cgisa/src/main/java/org/overturetool/cgisa/checkers/IsCharTypeVisitor.java index cf49af8a81..136166317d 100644 --- a/core/cgisa/src/main/java/org/overturetool/cgisa/helpers/IsCharTypeVisitor.java +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/checkers/IsCharTypeVisitor.java @@ -19,7 +19,7 @@ * . * #~% */ -package org.overturetool.cgisa.helpers; +package org.overturetool.cgisa.checkers; import org.overture.codegen.cgast.INode; import org.overture.codegen.cgast.analysis.AnalysisException; diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/helpers/IsMethodTypeVisitor.java b/core/cgisa/src/main/java/org/overturetool/cgisa/checkers/IsMethodTypeVisitor.java similarity index 97% rename from core/cgisa/src/main/java/org/overturetool/cgisa/helpers/IsMethodTypeVisitor.java rename to core/cgisa/src/main/java/org/overturetool/cgisa/checkers/IsMethodTypeVisitor.java index ca55900be8..8507216e52 100644 --- a/core/cgisa/src/main/java/org/overturetool/cgisa/helpers/IsMethodTypeVisitor.java +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/checkers/IsMethodTypeVisitor.java @@ -19,7 +19,7 @@ * . * #~% */ -package org.overturetool.cgisa.helpers; +package org.overturetool.cgisa.checkers; import org.overture.codegen.cgast.INode; import org.overture.codegen.cgast.analysis.AnalysisException; diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/helpers/IsSeqOfCharTypeVisitor.java b/core/cgisa/src/main/java/org/overturetool/cgisa/checkers/IsSeqOfCharTypeVisitor.java similarity index 97% rename from core/cgisa/src/main/java/org/overturetool/cgisa/helpers/IsSeqOfCharTypeVisitor.java rename to core/cgisa/src/main/java/org/overturetool/cgisa/checkers/IsSeqOfCharTypeVisitor.java index dd8b7cb626..3fb502c8f7 100644 --- a/core/cgisa/src/main/java/org/overturetool/cgisa/helpers/IsSeqOfCharTypeVisitor.java +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/checkers/IsSeqOfCharTypeVisitor.java @@ -19,7 +19,7 @@ * . * #~% */ -package org.overturetool.cgisa.helpers; +package org.overturetool.cgisa.checkers; import org.overture.codegen.cgast.INode; import org.overture.codegen.cgast.analysis.AnalysisException; From ac2bf59c54fdab3b7bcf8cd2646c409b033dea7d Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Mon, 23 Feb 2015 18:10:03 +0100 Subject: [PATCH 133/323] Remove utils names. --- .../cgisa/{IsaCommonUtils.java => IsaChecks.java} | 2 +- .../src/main/java/org/overturetool/cgisa/IsaCodeGen.java | 2 +- .../{IsaTranslationUtils.java => IsaTranslations.java} | 8 ++++---- .../cgisa/transformations/SortDependencies.java | 6 +++--- 4 files changed, 9 insertions(+), 9 deletions(-) rename core/cgisa/src/main/java/org/overturetool/cgisa/{IsaCommonUtils.java => IsaChecks.java} (92%) rename core/cgisa/src/main/java/org/overturetool/cgisa/{IsaTranslationUtils.java => IsaTranslations.java} (96%) diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaCommonUtils.java b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaChecks.java similarity index 92% rename from core/cgisa/src/main/java/org/overturetool/cgisa/IsaCommonUtils.java rename to core/cgisa/src/main/java/org/overturetool/cgisa/IsaChecks.java index f85a7b5775..ef0f171e20 100644 --- a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaCommonUtils.java +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaChecks.java @@ -3,7 +3,7 @@ import org.overture.codegen.cgast.INode; import org.overture.codegen.cgast.expressions.AApplyExpCG; -public class IsaCommonUtils +public class IsaChecks { public boolean isRoot(INode node) { diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaCodeGen.java b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaCodeGen.java index 6fd94d136e..d5706e98c2 100644 --- a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaCodeGen.java +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaCodeGen.java @@ -98,7 +98,7 @@ List generateIsabelleSyntax(List ast) TemplateStructure ts = new TemplateStructure("IsaTemplates"); - IsaTranslationUtils isa = new IsaTranslationUtils(ts); + IsaTranslations isa = new IsaTranslations(ts); MergeVisitor pp = isa.getMergeVisitor(); diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslationUtils.java b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslations.java similarity index 96% rename from core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslationUtils.java rename to core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslations.java index 6027251f3f..c161f34bb7 100644 --- a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslationUtils.java +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslations.java @@ -37,7 +37,7 @@ import org.overturetool.cgisa.checkers.IsMethodTypeVisitor; import org.overturetool.cgisa.checkers.IsSeqOfCharTypeVisitor; -public class IsaTranslationUtils +public class IsaTranslations { private static final String TEMPLATE_CALLABLE_NAME = "Isa"; @@ -45,13 +45,13 @@ public class IsaTranslationUtils private static final String LIST_SEP = ", "; private MergeVisitor mergeVisitor; - protected IsaCommonUtils isaUtils; + protected IsaChecks isaUtils; - public IsaTranslationUtils(TemplateStructure templateStructure) + public IsaTranslations(TemplateStructure templateStructure) { TemplateCallable[] templateCallables = new TemplateCallable[] { new TemplateCallable(TEMPLATE_CALLABLE_NAME, this) }; this.mergeVisitor = new MergeVisitor(new IsaTemplateManager(templateStructure), templateCallables); - this.isaUtils = new IsaCommonUtils(); + this.isaUtils = new IsaChecks(); } public MergeVisitor getMergeVisitor() diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/transformations/SortDependencies.java b/core/cgisa/src/main/java/org/overturetool/cgisa/transformations/SortDependencies.java index 99cf7762db..b26d5cfaca 100644 --- a/core/cgisa/src/main/java/org/overturetool/cgisa/transformations/SortDependencies.java +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/transformations/SortDependencies.java @@ -12,7 +12,7 @@ import org.overture.codegen.cgast.declarations.AClassDeclCG; import org.overture.codegen.cgast.declarations.AFuncDeclCG; import org.overture.codegen.cgast.expressions.SVarExpCG; -import org.overturetool.cgisa.IsaCommonUtils; +import org.overturetool.cgisa.IsaChecks; public class SortDependencies extends DepthFirstAnalysisAdaptor { @@ -20,12 +20,12 @@ public class SortDependencies extends DepthFirstAnalysisAdaptor Map> depGraph; private List sorted; - protected IsaCommonUtils isaUtils; + protected IsaChecks isaUtils; public SortDependencies(List funcs) { this.funcs = funcs; - this.isaUtils = new IsaCommonUtils(); + this.isaUtils = new IsaChecks(); this.depGraph = new HashMap<>(); this.sorted = new Vector(); init(); From dbf8c89ca455f44ead7ac218641dc6e0a912289a Mon Sep 17 00:00:00 2001 From: gkanos Date: Tue, 24 Feb 2015 08:35:13 +0100 Subject: [PATCH 134/323] Inline the remaining code of AClassClassDefinitionAssistantInterpreter and remove the assistant class. Also, removed some fixme tags that were empty. --- .../assistant/pattern/PPatternAssistant.java | 110 +----------------- .../InstanceWindowContainerBridge.java | 4 +- .../IInterpreterAssistantFactory.java | 3 +- .../InterpreterAssistantFactory.java | 9 +- ...ssClassDefinitionAssistantInterpreter.java | 41 ------- .../SClassDefinitionAssistantInterpreter.java | 10 +- .../overture/parser/lex/LexTokenReader.java | 2 +- .../pog/contexts/OpPostConditionContext.java | 2 +- .../pog/utility/PogAssistantFactory.java | 1 - .../visitor/TypeCheckerExpVisitor.java | 2 +- 10 files changed, 20 insertions(+), 164 deletions(-) delete mode 100644 core/interpreter/src/main/java/org/overture/interpreter/assistant/definition/AClassClassDefinitionAssistantInterpreter.java diff --git a/core/ast/src/main/java/org/overture/ast/assistant/pattern/PPatternAssistant.java b/core/ast/src/main/java/org/overture/ast/assistant/pattern/PPatternAssistant.java index 244beb23c2..740f7ce5aa 100644 --- a/core/ast/src/main/java/org/overture/ast/assistant/pattern/PPatternAssistant.java +++ b/core/ast/src/main/java/org/overture/ast/assistant/pattern/PPatternAssistant.java @@ -52,115 +52,7 @@ public LexNameList getAllVariableNames(PPattern pattern) return null; } } - - // FIXME Delete commented code - // public static LexNameList getAllVariableNames(AConcatenationPattern pattern) - // throws InvocationAssistantException - // { - // LexNameList list = new LexNameList(); - // - // list.addAll(PPatternAssistant.getAllVariableNames(pattern.getLeft())); - // list.addAll(PPatternAssistant.getAllVariableNames(pattern.getRight())); - // - // return list; - // } - // - // public static LexNameList getAllVariableNames(AIdentifierPattern pattern) - // { - // LexNameList list = new LexNameList(); - // list.add(pattern.getName()); - // return list; - // } - // - // public static LexNameList getAllVariableNames(ARecordPattern pattern) - // throws InvocationAssistantException - // { - // LexNameList list = new LexNameList(); - // - // for (PPattern p : pattern.getPlist()) - // { - // list.addAll(PPatternAssistant.getAllVariableNames(p)); - // } - // - // return list; - // - // } - // - // public static LexNameList getAllVariableNames(ASeqPattern pattern) - // throws InvocationAssistantException - // { - // LexNameList list = new LexNameList(); - // - // for (PPattern p : pattern.getPlist()) - // { - // list.addAll(PPatternAssistant.getAllVariableNames(p)); - // } - // - // return list; - // } - // - // public static LexNameList getAllVariableNames(ASetPattern pattern) - // throws InvocationAssistantException - // { - // LexNameList list = new LexNameList(); - // - // for (PPattern p : pattern.getPlist()) - // { - // list.addAll(PPatternAssistant.getAllVariableNames(p)); - // } - // - // return list; - // } - // - // public static LexNameList getAllVariableNames(ATuplePattern pattern) - // throws InvocationAssistantException - // { - // LexNameList list = new LexNameList(); - // - // for (PPattern p : pattern.getPlist()) - // { - // list.addAll(PPatternAssistant.getAllVariableNames(p)); - // } - // - // return list; - // } - // - // public static LexNameList getAllVariableNames(AUnionPattern pattern) - // throws InvocationAssistantException - // { - // LexNameList list = new LexNameList(); - // - // list.addAll(PPatternAssistant.getAllVariableNames(pattern.getLeft())); - // list.addAll(PPatternAssistant.getAllVariableNames(pattern.getRight())); - // - // return list; - // } - // - // /** - // * This method should only be called by subclasses of PPattern. For other classes call - // * {@link PPatternAssistant#getVariableNames(PPattern)}. - // * - // * @param pattern - // * @return - // * @throws InvocationAssistantException - // */ - // public static LexNameList getAllVariableNames(PPattern pattern) - // throws InvocationAssistantException - // { - // try - // { - // return (LexNameList) invokePreciseMethod(af.createPPatternAssistant(), "getAllVariableNames", pattern); - // } catch (InvocationAssistantNotFoundException ianfe) - // { - // /* - // * Default case is to return a new LexNameList, which corresponds to a InvocationAssistantException with no - // * embedded cause. However, if there is an embedded cause in the exception, then it's something more complex - // * than not being able to find a specific method, so we just re-throw that. - // */ - // return new LexNameList(); - // } - // } - + public LexNameList getVariableNames(PPattern pattern) { return af.createPPatternAssistant().getVariableNamesBaseCase(pattern); diff --git a/core/guibuilder/src/main/java/org/overture/guibuilder/internal/InstanceWindowContainerBridge.java b/core/guibuilder/src/main/java/org/overture/guibuilder/internal/InstanceWindowContainerBridge.java index aa8ddf93d1..bda7ed50ee 100644 --- a/core/guibuilder/src/main/java/org/overture/guibuilder/internal/InstanceWindowContainerBridge.java +++ b/core/guibuilder/src/main/java/org/overture/guibuilder/internal/InstanceWindowContainerBridge.java @@ -210,7 +210,7 @@ private void refreshVisibleContents() } // updates the value of labels - // It's better to use a list with the methods... + //It's better to use a list with the methods... if (methodWidgetsVisible) { for (String id : idMap.keySet()) @@ -240,7 +240,7 @@ private void refreshVisibleContents() */ public void submitOK() { - // Only one constructor is taken into account... + //Only one constructor is taken into account... String className = NamingPolicies.extractClassName(id); String instanceName = NamingPolicies.getInstanceName(className); diff --git a/core/interpreter/src/main/java/org/overture/interpreter/assistant/IInterpreterAssistantFactory.java b/core/interpreter/src/main/java/org/overture/interpreter/assistant/IInterpreterAssistantFactory.java index 3cca74a27a..ea03da228b 100644 --- a/core/interpreter/src/main/java/org/overture/interpreter/assistant/IInterpreterAssistantFactory.java +++ b/core/interpreter/src/main/java/org/overture/interpreter/assistant/IInterpreterAssistantFactory.java @@ -10,7 +10,6 @@ import org.overture.ast.patterns.AIdentifierPattern; import org.overture.ast.statements.PStm; import org.overture.interpreter.assistant.definition.ABusClassDefinitionAssistantInterpreter; -import org.overture.interpreter.assistant.definition.AClassClassDefinitionAssistantInterpreter; import org.overture.interpreter.assistant.definition.ACpuClassDefinitionAssistantInterpreter; import org.overture.interpreter.assistant.definition.AExplicitFunctionDefinitionAssistantInterpreter; import org.overture.interpreter.assistant.definition.AImplicitFunctionDefinitionAssistantInterpreter; @@ -63,7 +62,7 @@ public interface IInterpreterAssistantFactory extends ABusClassDefinitionAssistantInterpreter createABusClassDefinitionAssitant(); - AClassClassDefinitionAssistantInterpreter createAClassClassDefinitionAssistant(); +// AClassClassDefinitionAssistantInterpreter createAClassClassDefinitionAssistant(); // AConcurrentExpressionTraceCoreDefinitionAssistantInterpreter // createAConcurrentExpressionTraceCoreDefinitionAssistant(); diff --git a/core/interpreter/src/main/java/org/overture/interpreter/assistant/InterpreterAssistantFactory.java b/core/interpreter/src/main/java/org/overture/interpreter/assistant/InterpreterAssistantFactory.java index d188d95f69..637512d8d5 100644 --- a/core/interpreter/src/main/java/org/overture/interpreter/assistant/InterpreterAssistantFactory.java +++ b/core/interpreter/src/main/java/org/overture/interpreter/assistant/InterpreterAssistantFactory.java @@ -11,7 +11,6 @@ import org.overture.ast.patterns.AIdentifierPattern; import org.overture.ast.statements.PStm; import org.overture.interpreter.assistant.definition.ABusClassDefinitionAssistantInterpreter; -import org.overture.interpreter.assistant.definition.AClassClassDefinitionAssistantInterpreter; import org.overture.interpreter.assistant.definition.ACpuClassDefinitionAssistantInterpreter; import org.overture.interpreter.assistant.definition.AExplicitFunctionDefinitionAssistantInterpreter; import org.overture.interpreter.assistant.definition.AImplicitFunctionDefinitionAssistantInterpreter; @@ -106,10 +105,10 @@ public ABusClassDefinitionAssistantInterpreter createABusClassDefinitionAssitant return new ABusClassDefinitionAssistantInterpreter(this); } - public AClassClassDefinitionAssistantInterpreter createAClassClassDefinitionAssistant() - { - return new AClassClassDefinitionAssistantInterpreter(this); - } +// public AClassClassDefinitionAssistantInterpreter createAClassClassDefinitionAssistant() +// { +// return new AClassClassDefinitionAssistantInterpreter(this); +// } // public AConcurrentExpressionTraceCoreDefinitionAssistantInterpreter // createAConcurrentExpressionTraceCoreDefinitionAssistant() diff --git a/core/interpreter/src/main/java/org/overture/interpreter/assistant/definition/AClassClassDefinitionAssistantInterpreter.java b/core/interpreter/src/main/java/org/overture/interpreter/assistant/definition/AClassClassDefinitionAssistantInterpreter.java deleted file mode 100644 index 5724edc82a..0000000000 --- a/core/interpreter/src/main/java/org/overture/interpreter/assistant/definition/AClassClassDefinitionAssistantInterpreter.java +++ /dev/null @@ -1,41 +0,0 @@ -package org.overture.interpreter.assistant.definition; - -import java.util.HashMap; - -import org.overture.ast.analysis.AnalysisException; -import org.overture.ast.assistant.IAstAssistant; -import org.overture.ast.definitions.AClassClassDefinition; -import org.overture.ast.definitions.PDefinition; -import org.overture.ast.intf.lex.ILexNameToken; -import org.overture.interpreter.assistant.IInterpreterAssistantFactory; -import org.overture.interpreter.runtime.Context; -import org.overture.interpreter.runtime.VdmRuntimeError; -import org.overture.interpreter.values.ObjectValue; -import org.overture.interpreter.values.ValueList; - -public class AClassClassDefinitionAssistantInterpreter implements IAstAssistant -{ - protected static IInterpreterAssistantFactory af; - - @SuppressWarnings("static-access") - public AClassClassDefinitionAssistantInterpreter( - IInterpreterAssistantFactory af) - { - this.af = af; - } - - //FIXME Assistant only used in 1 place. Inline it. - public ObjectValue newInstance(AClassClassDefinition node, - PDefinition ctorDefinition, ValueList argvals, Context ctxt) - throws AnalysisException - { - if (node.getIsAbstract()) - { - VdmRuntimeError.abort(node.getLocation(), 4000, "Cannot instantiate abstract class " - + node.getName(), ctxt); - } - - return af.createSClassDefinitionAssistant().makeNewInstance(node, ctorDefinition, argvals, ctxt, new HashMap(), false); - } - -} diff --git a/core/interpreter/src/main/java/org/overture/interpreter/assistant/definition/SClassDefinitionAssistantInterpreter.java b/core/interpreter/src/main/java/org/overture/interpreter/assistant/definition/SClassDefinitionAssistantInterpreter.java index f0eff41882..30b9191f47 100644 --- a/core/interpreter/src/main/java/org/overture/interpreter/assistant/definition/SClassDefinitionAssistantInterpreter.java +++ b/core/interpreter/src/main/java/org/overture/interpreter/assistant/definition/SClassDefinitionAssistantInterpreter.java @@ -1,6 +1,7 @@ package org.overture.interpreter.assistant.definition; import java.io.File; +import java.util.HashMap; import java.util.LinkedList; import java.util.List; import java.util.Map; @@ -137,7 +138,14 @@ public ObjectValue newInstance(SClassDefinition node, return af.createABusClassDefinitionAssitant().newInstance((ABusClassDefinition) node, ctorDefinition, argvals, ctxt); } else if (node instanceof AClassClassDefinition) { - return af.createAClassClassDefinitionAssistant().newInstance((AClassClassDefinition) node, ctorDefinition, argvals, ctxt); + if (node.getIsAbstract()) + { + VdmRuntimeError.abort(node.getLocation(), 4000, "Cannot instantiate abstract class " + + node.getName(), ctxt); + } + + return af.createSClassDefinitionAssistant().makeNewInstance(node, ctorDefinition, argvals, ctxt, new HashMap(), false); + //return af.createAClassClassDefinitionAssistant().newInstance((AClassClassDefinition) node, ctorDefinition, argvals, ctxt); } else if (node instanceof ACpuClassDefinition) { return af.createACpuClassDefinitionAssistant().newInstance((ACpuClassDefinition) node, ctorDefinition, argvals, ctxt); diff --git a/core/parser/src/main/java/org/overture/parser/lex/LexTokenReader.java b/core/parser/src/main/java/org/overture/parser/lex/LexTokenReader.java index e5e7f35c3e..4efd088956 100644 --- a/core/parser/src/main/java/org/overture/parser/lex/LexTokenReader.java +++ b/core/parser/src/main/java/org/overture/parser/lex/LexTokenReader.java @@ -301,7 +301,7 @@ private void throwMessage(int number, String msg) throws LexException private void throwMessage(int number, int line, int pos, String msg) throws LexException { - throw new LexException(number, msg, new LexLocation(file, currentModule, line, pos, line, pos, -1, -1));// FIXME + throw new LexException(number, msg, new LexLocation(file, currentModule, line, pos, line, pos, -1, -1));// } /** diff --git a/core/pog/src/main/java/org/overture/pog/contexts/OpPostConditionContext.java b/core/pog/src/main/java/org/overture/pog/contexts/OpPostConditionContext.java index cb05dd777e..a70c923dbb 100644 --- a/core/pog/src/main/java/org/overture/pog/contexts/OpPostConditionContext.java +++ b/core/pog/src/main/java/org/overture/pog/contexts/OpPostConditionContext.java @@ -271,7 +271,7 @@ public PExp getContextNode(PExp stitch) } } catch (AnalysisException e) { - // FIXME consider handling of exceptions inside final context construction + //consider handling of exceptions inside final context construction e.printStackTrace(); } return null; diff --git a/core/pog/src/main/java/org/overture/pog/utility/PogAssistantFactory.java b/core/pog/src/main/java/org/overture/pog/utility/PogAssistantFactory.java index 5449f59df9..52cfe738a2 100644 --- a/core/pog/src/main/java/org/overture/pog/utility/PogAssistantFactory.java +++ b/core/pog/src/main/java/org/overture/pog/utility/PogAssistantFactory.java @@ -10,7 +10,6 @@ import org.overture.pog.visitors.VdmLocaleExtractor; import org.overture.typechecker.assistant.TypeCheckerAssistantFactory; -//FIXME Add assistant Javadoc /** * THe assistant factory for the pog. It provides all the functionality of the overture typechecker (maybe that is what * we parameterize?) PLus any new pog bits! diff --git a/core/typechecker/src/main/java/org/overture/typechecker/visitor/TypeCheckerExpVisitor.java b/core/typechecker/src/main/java/org/overture/typechecker/visitor/TypeCheckerExpVisitor.java index 5adf561238..5ebec9940e 100644 --- a/core/typechecker/src/main/java/org/overture/typechecker/visitor/TypeCheckerExpVisitor.java +++ b/core/typechecker/src/main/java/org/overture/typechecker/visitor/TypeCheckerExpVisitor.java @@ -2690,7 +2690,7 @@ public PType caseAVariableExp(AVariableExp node, TypeCheckInfo question) node.setType(AstFactory.newAUnknownType(node.getLocation())); return node.getType(); } - // FIXME AKM: a little test + //AKM: a little test // if(vardef.getClassDefinition().getName().getName().startsWith("$actionClass")) // node.setName(name.getModifiedName(vardef.getClassDefinition().getName().getName())); } From 87842114495317d443e55ebd79892b23dbb469ee Mon Sep 17 00:00:00 2001 From: gkanos Date: Tue, 24 Feb 2015 09:58:48 +0100 Subject: [PATCH 135/323] Remove some empty FIXME tags. Main Change: Moved the methods from the AApplyExpAssistantTC to the TypeCheckerExpVisitor Class. There was the only place those methods were used. Deleted the AApplyExpAssistant as empty afterwards. --- .../modelcheckers/probsolver/SeqTests.java | 2 +- .../modelcheckers/probsolver/SetTests.java | 2 +- .../ITypeCheckerAssistantFactory.java | 3 +- .../TypeCheckerAssistantFactory.java | 11 +- .../expression/AApplyExpAssistantTC.java | 233 ------------------ .../visitor/TypeCheckerExpVisitor.java | 192 ++++++++++++++- 6 files changed, 195 insertions(+), 248 deletions(-) delete mode 100644 core/typechecker/src/main/java/org/overture/typechecker/assistant/expression/AApplyExpAssistantTC.java diff --git a/core/modelcheckers/probsolver/src/test/java/org/overture/modelcheckers/probsolver/SeqTests.java b/core/modelcheckers/probsolver/src/test/java/org/overture/modelcheckers/probsolver/SeqTests.java index 8928f98ff5..583f447194 100644 --- a/core/modelcheckers/probsolver/src/test/java/org/overture/modelcheckers/probsolver/SeqTests.java +++ b/core/modelcheckers/probsolver/src/test/java/org/overture/modelcheckers/probsolver/SeqTests.java @@ -46,7 +46,7 @@ public static Collection getData() Collection tests = new LinkedList(); - tests.addAll(getTests(new File(root), "Seq-0028"));// FIXME + tests.addAll(getTests(new File(root), "Seq-0028")); return tests; } diff --git a/core/modelcheckers/probsolver/src/test/java/org/overture/modelcheckers/probsolver/SetTests.java b/core/modelcheckers/probsolver/src/test/java/org/overture/modelcheckers/probsolver/SetTests.java index ec9879f9bd..49cc32998c 100644 --- a/core/modelcheckers/probsolver/src/test/java/org/overture/modelcheckers/probsolver/SetTests.java +++ b/core/modelcheckers/probsolver/src/test/java/org/overture/modelcheckers/probsolver/SetTests.java @@ -46,7 +46,7 @@ public static Collection getData() Collection tests = new LinkedList(); - tests.addAll(getTests(new File(root), "Set-0024"));// FIXME + tests.addAll(getTests(new File(root), "Set-0024")); return tests; } diff --git a/core/typechecker/src/main/java/org/overture/typechecker/assistant/ITypeCheckerAssistantFactory.java b/core/typechecker/src/main/java/org/overture/typechecker/assistant/ITypeCheckerAssistantFactory.java index 93bdc3e9c4..df42251f5f 100644 --- a/core/typechecker/src/main/java/org/overture/typechecker/assistant/ITypeCheckerAssistantFactory.java +++ b/core/typechecker/src/main/java/org/overture/typechecker/assistant/ITypeCheckerAssistantFactory.java @@ -71,7 +71,6 @@ import org.overture.typechecker.assistant.definition.PDefinitionSet; import org.overture.typechecker.assistant.definition.PTraceDefinitionAssistantTC; import org.overture.typechecker.assistant.definition.SClassDefinitionAssistantTC; -import org.overture.typechecker.assistant.expression.AApplyExpAssistantTC; import org.overture.typechecker.assistant.expression.ACaseAlternativeAssistantTC; import org.overture.typechecker.assistant.expression.PExpAssistantTC; import org.overture.typechecker.assistant.expression.SBinaryExpAssistantTC; @@ -165,7 +164,7 @@ public interface ITypeCheckerAssistantFactory extends IAstAssistantFactory SClassDefinitionAssistantTC createSClassDefinitionAssistant(); // expression - AApplyExpAssistantTC createAApplyExpAssistant(); + //AApplyExpAssistantTC createAApplyExpAssistant(); ACaseAlternativeAssistantTC createACaseAlternativeAssistant(); diff --git a/core/typechecker/src/main/java/org/overture/typechecker/assistant/TypeCheckerAssistantFactory.java b/core/typechecker/src/main/java/org/overture/typechecker/assistant/TypeCheckerAssistantFactory.java index aa38658ba4..c5730cb96f 100644 --- a/core/typechecker/src/main/java/org/overture/typechecker/assistant/TypeCheckerAssistantFactory.java +++ b/core/typechecker/src/main/java/org/overture/typechecker/assistant/TypeCheckerAssistantFactory.java @@ -71,7 +71,6 @@ import org.overture.typechecker.assistant.definition.PDefinitionSet; import org.overture.typechecker.assistant.definition.PTraceDefinitionAssistantTC; import org.overture.typechecker.assistant.definition.SClassDefinitionAssistantTC; -import org.overture.typechecker.assistant.expression.AApplyExpAssistantTC; import org.overture.typechecker.assistant.expression.ACaseAlternativeAssistantTC; import org.overture.typechecker.assistant.expression.PExpAssistantTC; import org.overture.typechecker.assistant.expression.SBinaryExpAssistantTC; @@ -374,11 +373,11 @@ public SClassDefinitionAssistantTC createSClassDefinitionAssistant() // expression - @Override - public AApplyExpAssistantTC createAApplyExpAssistant() - { - return new AApplyExpAssistantTC(this); - } +// @Override +// public AApplyExpAssistantTC createAApplyExpAssistant() +// { +// return new AApplyExpAssistantTC(this); +// } @Override public ACaseAlternativeAssistantTC createACaseAlternativeAssistant() diff --git a/core/typechecker/src/main/java/org/overture/typechecker/assistant/expression/AApplyExpAssistantTC.java b/core/typechecker/src/main/java/org/overture/typechecker/assistant/expression/AApplyExpAssistantTC.java deleted file mode 100644 index 60d9c9d125..0000000000 --- a/core/typechecker/src/main/java/org/overture/typechecker/assistant/expression/AApplyExpAssistantTC.java +++ /dev/null @@ -1,233 +0,0 @@ -/* - * #%~ - * The VDM Type Checker - * %% - * Copyright (C) 2008 - 2014 Overture - * %% - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as - * published by the Free Software Foundation, either version 3 of the - * License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public - * License along with this program. If not, see - * . - * #~% - */ -package org.overture.typechecker.assistant.expression; - -import java.util.List; - -import org.overture.ast.assistant.IAstAssistant; -import org.overture.ast.definitions.PDefinition; -import org.overture.ast.expressions.AApplyExp; -import org.overture.ast.expressions.AFuncInstatiationExp; -import org.overture.ast.expressions.AVariableExp; -import org.overture.ast.expressions.PExp; -import org.overture.ast.intf.lex.ILexNameToken; -import org.overture.ast.types.AFunctionType; -import org.overture.ast.types.AOperationType; -import org.overture.ast.types.PType; -import org.overture.ast.types.SMapType; -import org.overture.ast.types.SSeqType; -import org.overture.ast.util.Utils; -import org.overture.typechecker.TypeCheckInfo; -import org.overture.typechecker.TypeCheckerErrors; -import org.overture.typechecker.assistant.ITypeCheckerAssistantFactory; - -//FIXME only used in 1 class. move it -public class AApplyExpAssistantTC implements IAstAssistant -{ - protected ITypeCheckerAssistantFactory af; - - public AApplyExpAssistantTC(ITypeCheckerAssistantFactory af) - { - this.af = af; - } - - public PType functionApply(AApplyExp node, boolean isSimple, - AFunctionType ft) - { - List ptypes = ft.getParameters(); - - if (node.getArgs().size() > ptypes.size()) - { - TypeCheckerErrors.concern(isSimple, 3059, "Too many arguments", node.getLocation(), node); - TypeCheckerErrors.detail2(isSimple, "Args", node.getArgs(), "Params", ptypes); - return ft.getResult(); - } else if (node.getArgs().size() < ptypes.size()) - { - TypeCheckerErrors.concern(isSimple, 3060, "Too few arguments", node.getLocation(), node); - TypeCheckerErrors.detail2(isSimple, "Args", node.getArgs(), "Params", ptypes); - return ft.getResult(); - } - - int i = 0; - - for (PType at : node.getArgtypes()) - { - PType pt = ptypes.get(i++); - - if (!af.getTypeComparator().compatible(pt, at)) - { - // TypeCheckerErrors.concern(isSimple, 3061, "Inappropriate type for argument " + i + - // ". (Expected: "+pt+" Actual: "+at+")",node.getLocation(),node); - TypeCheckerErrors.concern(isSimple, 3061, "Inappropriate type for argument " - + i, node.getLocation(), node); - TypeCheckerErrors.detail2(isSimple, "Expect", pt, "Actual", at); - } - } - - return ft.getResult(); - } - - public PType operationApply(AApplyExp node, boolean isSimple, - AOperationType ot) - { - List ptypes = ot.getParameters(); - - if (node.getArgs().size() > ptypes.size()) - { - TypeCheckerErrors.concern(isSimple, 3062, "Too many arguments", node.getLocation(), node); - TypeCheckerErrors.detail2(isSimple, "Args", node.getArgs(), "Params", ptypes); - return ot.getResult(); - } else if (node.getArgs().size() < ptypes.size()) - { - TypeCheckerErrors.concern(isSimple, 3063, "Too few arguments", node.getLocation(), node); - TypeCheckerErrors.detail2(isSimple, "Args", node.getArgs(), "Params", ptypes); - return ot.getResult(); - } - - int i = 0; - - for (PType at : node.getArgtypes()) - { - PType pt = ptypes.get(i++); - - if (!af.getTypeComparator().compatible(pt, at)) - { - // TypeCheckerErrors.concern(isSimple, 3064, "Inappropriate type for argument " + i - // +". (Expected: "+pt+" Actual: "+at+")",node.getLocation(),node); - TypeCheckerErrors.concern(isSimple, 3064, "Inappropriate type for argument " - + i, node.getLocation(), node); - TypeCheckerErrors.detail2(isSimple, "Expect", pt, "Actual", at); - } - } - - return ot.getResult(); - } - - public PType sequenceApply(AApplyExp node, boolean isSimple, SSeqType seq) - { - if (node.getArgs().size() != 1) - { - TypeCheckerErrors.concern(isSimple, 3055, "Sequence selector must have one argument", node.getLocation(), node); - } else if (!af.createPTypeAssistant().isNumeric(node.getArgtypes().get(0))) - { - TypeCheckerErrors.concern(isSimple, 3056, "Sequence application argument must be numeric", node.getLocation(), node); - } else if (seq.getEmpty()) - { - TypeCheckerErrors.concern(isSimple, 3268, "Empty sequence cannot be applied", node.getLocation(), node); - } - - return seq.getSeqof(); - } - - public PType mapApply(AApplyExp node, boolean isSimple, SMapType map) - { - if (node.getArgs().size() != 1) - { - TypeCheckerErrors.concern(isSimple, 3057, "Map application must have one argument", node.getLocation(), node); - } else if (map.getEmpty()) - { - TypeCheckerErrors.concern(isSimple, 3267, "Empty map cannot be applied", node.getLocation(), node); - } - - PType argtype = node.getArgtypes().get(0); - - if (!af.getTypeComparator().compatible(map.getFrom(), argtype)) - { - TypeCheckerErrors.concern(isSimple, 3058, "Map application argument is incompatible type", node.getLocation(), node); - TypeCheckerErrors.detail2(isSimple, "Map domain", map.getFrom(), "Argument", argtype); - } - - return map.getTo(); - } - - public PDefinition getRecursiveDefinition(AApplyExp node, - TypeCheckInfo question) - { - ILexNameToken fname = null; - PExp root = node.getRoot(); - - if (root instanceof AApplyExp) - { - AApplyExp aexp = (AApplyExp) root; - return getRecursiveDefinition(aexp, question); - } else if (root instanceof AVariableExp) - { - AVariableExp var = (AVariableExp) root; - fname = var.getName(); - } else if (root instanceof AFuncInstatiationExp) - { - AFuncInstatiationExp fie = (AFuncInstatiationExp) root; - - if (fie.getExpdef() != null) - { - fname = fie.getExpdef().getName(); - } else if (fie.getImpdef() != null) - { - fname = fie.getImpdef().getName(); - } - } - - if (fname != null) - { - return question.env.findName(fname, question.scope); - } else - { - return null; - } - } - - /** - * Create a measure application string from this apply, turning the root function name into the measure name passed, - * and collapsing curried argument sets into one. - * - * @param node - * @param measure - * @param close - * @return - */ - public String getMeasureApply(AApplyExp node, ILexNameToken measure, - boolean close) - { - String start = null; - PExp root = node.getRoot(); - - if (root instanceof AApplyExp) - { - AApplyExp aexp = (AApplyExp) root; - start = getMeasureApply(aexp, measure, false); - } else if (root instanceof AVariableExp) - { - start = measure.getFullName() + "("; - } else if (root instanceof AFuncInstatiationExp) - { - AFuncInstatiationExp fie = (AFuncInstatiationExp) root; - start = measure.getFullName() + "[" - + Utils.listToString(fie.getActualTypes()) + "]("; - } else - { - start = root.toString() + "("; - } - - return start + Utils.listToString(node.getArgs()) - + (close ? ")" : ", "); - } -} diff --git a/core/typechecker/src/main/java/org/overture/typechecker/visitor/TypeCheckerExpVisitor.java b/core/typechecker/src/main/java/org/overture/typechecker/visitor/TypeCheckerExpVisitor.java index 5ebec9940e..c20ca404d2 100644 --- a/core/typechecker/src/main/java/org/overture/typechecker/visitor/TypeCheckerExpVisitor.java +++ b/core/typechecker/src/main/java/org/overture/typechecker/visitor/TypeCheckerExpVisitor.java @@ -75,6 +75,7 @@ import org.overture.ast.types.SNumericBasicType; import org.overture.ast.types.SSeqType; import org.overture.ast.util.PTypeSet; +import org.overture.ast.util.Utils; import org.overture.config.Release; import org.overture.config.Settings; import org.overture.typechecker.Environment; @@ -124,7 +125,7 @@ public PType caseAApplyExp(AApplyExp node, TypeCheckInfo question) if (inFunction) { - PDefinition called = question.assistantFactory.createAApplyExpAssistant().getRecursiveDefinition(node, question); + PDefinition called = getRecursiveDefinition(node, question); if (called instanceof AExplicitFunctionDefinition) { @@ -175,7 +176,7 @@ public PType caseAApplyExp(AApplyExp node, TypeCheckInfo question) { AFunctionType ft = question.assistantFactory.createPTypeAssistant().getFunction(node.getType()); question.assistantFactory.createPTypeAssistant().typeResolve(ft, null, THIS, question); - results.add(question.assistantFactory.createAApplyExpAssistant().functionApply(node, isSimple, ft)); + results.add(functionApply(node, isSimple, ft, question)); } if (question.assistantFactory.createPTypeAssistant().isOperation(node.getType())) @@ -190,20 +191,20 @@ public PType caseAApplyExp(AApplyExp node, TypeCheckInfo question) results.add(AstFactory.newAUnknownType(node.getLocation())); } else { - results.add(question.assistantFactory.createAApplyExpAssistant().operationApply(node, isSimple, ot)); + results.add(operationApply(node, isSimple, ot, question)); } } if (question.assistantFactory.createPTypeAssistant().isSeq(node.getType())) { SSeqType seq = question.assistantFactory.createPTypeAssistant().getSeq(node.getType()); - results.add(question.assistantFactory.createAApplyExpAssistant().sequenceApply(node, isSimple, seq)); + results.add(sequenceApply(node, isSimple, seq, question)); } if (question.assistantFactory.createPTypeAssistant().isMap(node.getType())) { SMapType map = question.assistantFactory.createPTypeAssistant().getMap(node.getType()); - results.add(question.assistantFactory.createAApplyExpAssistant().mapApply(node, isSimple, map)); + results.add(mapApply(node, isSimple, map, question)); } if (results.isEmpty()) @@ -3287,4 +3288,185 @@ private void checkNumeric(SNumericBinaryExp node, } } + + public PType functionApply(AApplyExp node, boolean isSimple, + AFunctionType ft,TypeCheckInfo question) + { + List ptypes = ft.getParameters(); + + if (node.getArgs().size() > ptypes.size()) + { + TypeCheckerErrors.concern(isSimple, 3059, "Too many arguments", node.getLocation(), node); + TypeCheckerErrors.detail2(isSimple, "Args", node.getArgs(), "Params", ptypes); + return ft.getResult(); + } else if (node.getArgs().size() < ptypes.size()) + { + TypeCheckerErrors.concern(isSimple, 3060, "Too few arguments", node.getLocation(), node); + TypeCheckerErrors.detail2(isSimple, "Args", node.getArgs(), "Params", ptypes); + return ft.getResult(); + } + + int i = 0; + + for (PType at : node.getArgtypes()) + { + PType pt = ptypes.get(i++); + + if (!question.assistantFactory.getTypeComparator().compatible(pt, at)) + { + // TypeCheckerErrors.concern(isSimple, 3061, "Inappropriate type for argument " + i + + // ". (Expected: "+pt+" Actual: "+at+")",node.getLocation(),node); + TypeCheckerErrors.concern(isSimple, 3061, "Inappropriate type for argument " + + i, node.getLocation(), node); + TypeCheckerErrors.detail2(isSimple, "Expect", pt, "Actual", at); + } + } + + return ft.getResult(); + } + + public PType operationApply(AApplyExp node, boolean isSimple, + AOperationType ot, TypeCheckInfo question) + { + List ptypes = ot.getParameters(); + + if (node.getArgs().size() > ptypes.size()) + { + TypeCheckerErrors.concern(isSimple, 3062, "Too many arguments", node.getLocation(), node); + TypeCheckerErrors.detail2(isSimple, "Args", node.getArgs(), "Params", ptypes); + return ot.getResult(); + } else if (node.getArgs().size() < ptypes.size()) + { + TypeCheckerErrors.concern(isSimple, 3063, "Too few arguments", node.getLocation(), node); + TypeCheckerErrors.detail2(isSimple, "Args", node.getArgs(), "Params", ptypes); + return ot.getResult(); + } + + int i = 0; + + for (PType at : node.getArgtypes()) + { + PType pt = ptypes.get(i++); + + if (!question.assistantFactory.getTypeComparator().compatible(pt, at)) + { + // TypeCheckerErrors.concern(isSimple, 3064, "Inappropriate type for argument " + i + // +". (Expected: "+pt+" Actual: "+at+")",node.getLocation(),node); + TypeCheckerErrors.concern(isSimple, 3064, "Inappropriate type for argument " + + i, node.getLocation(), node); + TypeCheckerErrors.detail2(isSimple, "Expect", pt, "Actual", at); + } + } + + return ot.getResult(); + } + + public PType sequenceApply(AApplyExp node, boolean isSimple, SSeqType seq, TypeCheckInfo question) + { + if (node.getArgs().size() != 1) + { + TypeCheckerErrors.concern(isSimple, 3055, "Sequence selector must have one argument", node.getLocation(), node); + } else if (!question.assistantFactory.createPTypeAssistant().isNumeric(node.getArgtypes().get(0))) + { + TypeCheckerErrors.concern(isSimple, 3056, "Sequence application argument must be numeric", node.getLocation(), node); + } else if (seq.getEmpty()) + { + TypeCheckerErrors.concern(isSimple, 3268, "Empty sequence cannot be applied", node.getLocation(), node); + } + + return seq.getSeqof(); + } + + public PType mapApply(AApplyExp node, boolean isSimple, SMapType map, TypeCheckInfo question) + { + if (node.getArgs().size() != 1) + { + TypeCheckerErrors.concern(isSimple, 3057, "Map application must have one argument", node.getLocation(), node); + } else if (map.getEmpty()) + { + TypeCheckerErrors.concern(isSimple, 3267, "Empty map cannot be applied", node.getLocation(), node); + } + + PType argtype = node.getArgtypes().get(0); + + if (!question.assistantFactory.getTypeComparator().compatible(map.getFrom(), argtype)) + { + TypeCheckerErrors.concern(isSimple, 3058, "Map application argument is incompatible type", node.getLocation(), node); + TypeCheckerErrors.detail2(isSimple, "Map domain", map.getFrom(), "Argument", argtype); + } + + return map.getTo(); + } + + public PDefinition getRecursiveDefinition(AApplyExp node, + TypeCheckInfo question) + { + ILexNameToken fname = null; + PExp root = node.getRoot(); + + if (root instanceof AApplyExp) + { + AApplyExp aexp = (AApplyExp) root; + return getRecursiveDefinition(aexp, question); + } else if (root instanceof AVariableExp) + { + AVariableExp var = (AVariableExp) root; + fname = var.getName(); + } else if (root instanceof AFuncInstatiationExp) + { + AFuncInstatiationExp fie = (AFuncInstatiationExp) root; + + if (fie.getExpdef() != null) + { + fname = fie.getExpdef().getName(); + } else if (fie.getImpdef() != null) + { + fname = fie.getImpdef().getName(); + } + } + + if (fname != null) + { + return question.env.findName(fname, question.scope); + } else + { + return null; + } + } + + /** + * Create a measure application string from this apply, turning the root function name into the measure name passed, + * and collapsing curried argument sets into one. + * + * @param node + * @param measure + * @param close + * @return + */ + public String getMeasureApply(AApplyExp node, ILexNameToken measure, + boolean close) + { + String start = null; + PExp root = node.getRoot(); + + if (root instanceof AApplyExp) + { + AApplyExp aexp = (AApplyExp) root; + start = getMeasureApply(aexp, measure, false); + } else if (root instanceof AVariableExp) + { + start = measure.getFullName() + "("; + } else if (root instanceof AFuncInstatiationExp) + { + AFuncInstatiationExp fie = (AFuncInstatiationExp) root; + start = measure.getFullName() + "[" + + Utils.listToString(fie.getActualTypes()) + "]("; + } else + { + start = root.toString() + "("; + } + + return start + Utils.listToString(node.getArgs()) + + (close ? ")" : ", "); + } } From 670abbd2b119ceaf0a3fd1dcbf09296bbd4c3a38 Mon Sep 17 00:00:00 2001 From: gkanos Date: Tue, 24 Feb 2015 10:10:55 +0100 Subject: [PATCH 136/323] Move the methods from AFromModuleImportsAssistantTC to AModuleImportAssistantTC. Delete the AFromModuleImportsAssistantTC. --- .../ITypeCheckerAssistantFactory.java | 3 +- .../TypeCheckerAssistantFactory.java | 11 ++- .../module/AFromModuleImportsAssistantTC.java | 81 ------------------- .../module/AModuleImportsAssistantTC.java | 42 +++++++++- 4 files changed, 46 insertions(+), 91 deletions(-) delete mode 100644 core/typechecker/src/main/java/org/overture/typechecker/assistant/module/AFromModuleImportsAssistantTC.java diff --git a/core/typechecker/src/main/java/org/overture/typechecker/assistant/ITypeCheckerAssistantFactory.java b/core/typechecker/src/main/java/org/overture/typechecker/assistant/ITypeCheckerAssistantFactory.java index df42251f5f..4ddf4b4975 100644 --- a/core/typechecker/src/main/java/org/overture/typechecker/assistant/ITypeCheckerAssistantFactory.java +++ b/core/typechecker/src/main/java/org/overture/typechecker/assistant/ITypeCheckerAssistantFactory.java @@ -74,7 +74,6 @@ import org.overture.typechecker.assistant.expression.ACaseAlternativeAssistantTC; import org.overture.typechecker.assistant.expression.PExpAssistantTC; import org.overture.typechecker.assistant.expression.SBinaryExpAssistantTC; -import org.overture.typechecker.assistant.module.AFromModuleImportsAssistantTC; import org.overture.typechecker.assistant.module.AModuleExportsAssistantTC; import org.overture.typechecker.assistant.module.AModuleImportsAssistantTC; import org.overture.typechecker.assistant.module.AModuleModulesAssistantTC; @@ -174,7 +173,7 @@ public interface ITypeCheckerAssistantFactory extends IAstAssistantFactory // module - AFromModuleImportsAssistantTC createAFromModuleImportsAssistant(); + //AFromModuleImportsAssistantTC createAFromModuleImportsAssistant(); AModuleExportsAssistantTC createAModuleExportsAssistant(); diff --git a/core/typechecker/src/main/java/org/overture/typechecker/assistant/TypeCheckerAssistantFactory.java b/core/typechecker/src/main/java/org/overture/typechecker/assistant/TypeCheckerAssistantFactory.java index c5730cb96f..672a34e962 100644 --- a/core/typechecker/src/main/java/org/overture/typechecker/assistant/TypeCheckerAssistantFactory.java +++ b/core/typechecker/src/main/java/org/overture/typechecker/assistant/TypeCheckerAssistantFactory.java @@ -74,7 +74,6 @@ import org.overture.typechecker.assistant.expression.ACaseAlternativeAssistantTC; import org.overture.typechecker.assistant.expression.PExpAssistantTC; import org.overture.typechecker.assistant.expression.SBinaryExpAssistantTC; -import org.overture.typechecker.assistant.module.AFromModuleImportsAssistantTC; import org.overture.typechecker.assistant.module.AModuleExportsAssistantTC; import org.overture.typechecker.assistant.module.AModuleImportsAssistantTC; import org.overture.typechecker.assistant.module.AModuleModulesAssistantTC; @@ -399,11 +398,11 @@ public SBinaryExpAssistantTC createSBinaryExpAssistant() // module - @Override - public AFromModuleImportsAssistantTC createAFromModuleImportsAssistant() - { - return new AFromModuleImportsAssistantTC(this); - } +// @Override +// public AFromModuleImportsAssistantTC createAFromModuleImportsAssistant() +// { +// return new AFromModuleImportsAssistantTC(this); +// } @Override public AModuleExportsAssistantTC createAModuleExportsAssistant() diff --git a/core/typechecker/src/main/java/org/overture/typechecker/assistant/module/AFromModuleImportsAssistantTC.java b/core/typechecker/src/main/java/org/overture/typechecker/assistant/module/AFromModuleImportsAssistantTC.java deleted file mode 100644 index 872bba5298..0000000000 --- a/core/typechecker/src/main/java/org/overture/typechecker/assistant/module/AFromModuleImportsAssistantTC.java +++ /dev/null @@ -1,81 +0,0 @@ -/* - * #%~ - * The VDM Type Checker - * %% - * Copyright (C) 2008 - 2014 Overture - * %% - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as - * published by the Free Software Foundation, either version 3 of the - * License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public - * License along with this program. If not, see - * . - * #~% - */ -package org.overture.typechecker.assistant.module; - -import java.util.List; -import java.util.Vector; - -import org.overture.ast.analysis.AnalysisException; -import org.overture.ast.assistant.IAstAssistant; -import org.overture.ast.definitions.PDefinition; -import org.overture.ast.modules.AFromModuleImports; -import org.overture.ast.modules.AModuleModules; -import org.overture.ast.modules.PImport; -import org.overture.typechecker.ModuleEnvironment; -import org.overture.typechecker.TypeCheckInfo; -import org.overture.typechecker.assistant.ITypeCheckerAssistantFactory; -import org.overture.typechecker.visitor.TypeCheckVisitor; - -//FIXME only used in 1 class. move it -public class AFromModuleImportsAssistantTC implements IAstAssistant -{ - protected ITypeCheckerAssistantFactory af; - - public AFromModuleImportsAssistantTC(ITypeCheckerAssistantFactory af) - { - this.af = af; - } - - public List getDefinitions(AFromModuleImports ifm, - AModuleModules from) - { - - List defs = new Vector(); - - for (List ofType : ifm.getSignatures()) - { - for (PImport imp : ofType) - { - defs.addAll(af.createPImportAssistant().getDefinitions(imp, from)); - } - } - - return defs; - } - - public void typeCheck(AFromModuleImports ifm, ModuleEnvironment env) - throws AnalysisException - { - TypeCheckVisitor tc = new TypeCheckVisitor(); - TypeCheckInfo question = new TypeCheckInfo(af, env, null, null); - - for (List ofType : ifm.getSignatures()) - { - for (PImport imp : ofType) - { - imp.apply(tc, question); - } - } - - } - -} diff --git a/core/typechecker/src/main/java/org/overture/typechecker/assistant/module/AModuleImportsAssistantTC.java b/core/typechecker/src/main/java/org/overture/typechecker/assistant/module/AModuleImportsAssistantTC.java index af6cbca6dd..6ece427ea7 100644 --- a/core/typechecker/src/main/java/org/overture/typechecker/assistant/module/AModuleImportsAssistantTC.java +++ b/core/typechecker/src/main/java/org/overture/typechecker/assistant/module/AModuleImportsAssistantTC.java @@ -30,9 +30,12 @@ import org.overture.ast.modules.AFromModuleImports; import org.overture.ast.modules.AModuleImports; import org.overture.ast.modules.AModuleModules; +import org.overture.ast.modules.PImport; import org.overture.typechecker.ModuleEnvironment; +import org.overture.typechecker.TypeCheckInfo; import org.overture.typechecker.TypeCheckerErrors; import org.overture.typechecker.assistant.ITypeCheckerAssistantFactory; +import org.overture.typechecker.visitor.TypeCheckVisitor; public class AModuleImportsAssistantTC implements IAstAssistant { @@ -64,7 +67,7 @@ public List getDefinitions(AModuleImports imports, + ifm.getName(), ifm.getName().getLocation(), ifm); } else { - defs.addAll(af.createAFromModuleImportsAssistant().getDefinitions(ifm, from)); + defs.addAll(getDefinitions(ifm, from)); } } @@ -77,7 +80,42 @@ public void typeCheck(AModuleImports imports, ModuleEnvironment env) for (AFromModuleImports ifm : imports.getImports()) { - af.createAFromModuleImportsAssistant().typeCheck(ifm, env); + typeCheck(ifm, env); + } + + } + + public List getDefinitions(AFromModuleImports ifm, + AModuleModules from) + { + + List defs = new Vector(); + + for (List ofType : ifm.getSignatures()) + { + for (PImport imp : ofType) + { + defs.addAll(af.createPImportAssistant().getDefinitions(imp, from)); + } + } + + return defs; + } + + //Move from an old Assistant called AFromModuleImportsAssistantTC + //Overloads the typeCheck method of this class. + public void typeCheck(AFromModuleImports ifm, ModuleEnvironment env) + throws AnalysisException + { + TypeCheckVisitor tc = new TypeCheckVisitor(); + TypeCheckInfo question = new TypeCheckInfo(af, env, null, null); + + for (List ofType : ifm.getSignatures()) + { + for (PImport imp : ofType) + { + imp.apply(tc, question); + } } } From 8888a5f2417b77f6481594f816b62af5038e4439 Mon Sep 17 00:00:00 2001 From: gkanos Date: Tue, 24 Feb 2015 10:53:52 +0100 Subject: [PATCH 137/323] Move the methods from AModuleExportsAssistantTC to AModuleModuleAssistantTC Delete AModuleExportsAsssistantTC as empty. --- .../ITypeCheckerAssistantFactory.java | 3 +- .../TypeCheckerAssistantFactory.java | 11 +-- .../module/AModuleExportsAssistantTC.java | 91 ------------------- .../module/AModuleModulesAssistantTC.java | 55 ++++++++++- 4 files changed, 59 insertions(+), 101 deletions(-) delete mode 100644 core/typechecker/src/main/java/org/overture/typechecker/assistant/module/AModuleExportsAssistantTC.java diff --git a/core/typechecker/src/main/java/org/overture/typechecker/assistant/ITypeCheckerAssistantFactory.java b/core/typechecker/src/main/java/org/overture/typechecker/assistant/ITypeCheckerAssistantFactory.java index 4ddf4b4975..2997cdeda9 100644 --- a/core/typechecker/src/main/java/org/overture/typechecker/assistant/ITypeCheckerAssistantFactory.java +++ b/core/typechecker/src/main/java/org/overture/typechecker/assistant/ITypeCheckerAssistantFactory.java @@ -74,7 +74,6 @@ import org.overture.typechecker.assistant.expression.ACaseAlternativeAssistantTC; import org.overture.typechecker.assistant.expression.PExpAssistantTC; import org.overture.typechecker.assistant.expression.SBinaryExpAssistantTC; -import org.overture.typechecker.assistant.module.AModuleExportsAssistantTC; import org.overture.typechecker.assistant.module.AModuleImportsAssistantTC; import org.overture.typechecker.assistant.module.AModuleModulesAssistantTC; import org.overture.typechecker.assistant.module.PExportAssistantTC; @@ -175,7 +174,7 @@ public interface ITypeCheckerAssistantFactory extends IAstAssistantFactory //AFromModuleImportsAssistantTC createAFromModuleImportsAssistant(); - AModuleExportsAssistantTC createAModuleExportsAssistant(); + //AModuleExportsAssistantTC createAModuleExportsAssistant(); AModuleImportsAssistantTC createAModuleImportsAssistant(); diff --git a/core/typechecker/src/main/java/org/overture/typechecker/assistant/TypeCheckerAssistantFactory.java b/core/typechecker/src/main/java/org/overture/typechecker/assistant/TypeCheckerAssistantFactory.java index 672a34e962..4645efd0fc 100644 --- a/core/typechecker/src/main/java/org/overture/typechecker/assistant/TypeCheckerAssistantFactory.java +++ b/core/typechecker/src/main/java/org/overture/typechecker/assistant/TypeCheckerAssistantFactory.java @@ -74,7 +74,6 @@ import org.overture.typechecker.assistant.expression.ACaseAlternativeAssistantTC; import org.overture.typechecker.assistant.expression.PExpAssistantTC; import org.overture.typechecker.assistant.expression.SBinaryExpAssistantTC; -import org.overture.typechecker.assistant.module.AModuleExportsAssistantTC; import org.overture.typechecker.assistant.module.AModuleImportsAssistantTC; import org.overture.typechecker.assistant.module.AModuleModulesAssistantTC; import org.overture.typechecker.assistant.module.PExportAssistantTC; @@ -404,11 +403,11 @@ public SBinaryExpAssistantTC createSBinaryExpAssistant() // return new AFromModuleImportsAssistantTC(this); // } - @Override - public AModuleExportsAssistantTC createAModuleExportsAssistant() - { - return new AModuleExportsAssistantTC(this); - } +// @Override +// public AModuleExportsAssistantTC createAModuleExportsAssistant() +// { +// return new AModuleExportsAssistantTC(this); +// } @Override public AModuleImportsAssistantTC createAModuleImportsAssistant() diff --git a/core/typechecker/src/main/java/org/overture/typechecker/assistant/module/AModuleExportsAssistantTC.java b/core/typechecker/src/main/java/org/overture/typechecker/assistant/module/AModuleExportsAssistantTC.java deleted file mode 100644 index 83bc6c1600..0000000000 --- a/core/typechecker/src/main/java/org/overture/typechecker/assistant/module/AModuleExportsAssistantTC.java +++ /dev/null @@ -1,91 +0,0 @@ -/* - * #%~ - * The VDM Type Checker - * %% - * Copyright (C) 2008 - 2014 Overture - * %% - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as - * published by the Free Software Foundation, either version 3 of the - * License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public - * License along with this program. If not, see - * . - * #~% - */ -package org.overture.typechecker.assistant.module; - -import java.util.Collection; -import java.util.LinkedList; -import java.util.List; -import java.util.Vector; - -import org.overture.ast.assistant.IAstAssistant; -import org.overture.ast.definitions.PDefinition; -import org.overture.ast.modules.AModuleExports; -import org.overture.ast.modules.PExport; -import org.overture.typechecker.assistant.ITypeCheckerAssistantFactory; - -//FIXME only used in 1 class. move it -public class AModuleExportsAssistantTC implements IAstAssistant -{ - protected ITypeCheckerAssistantFactory af; - - public AModuleExportsAssistantTC(ITypeCheckerAssistantFactory af) - { - this.af = af; - } - - public Collection getDefinitions( - AModuleExports aModuleExports, LinkedList actualDefs) - { - List exportDefs = new Vector(); - - for (List etype : aModuleExports.getExports()) - { - for (PExport exp : etype) - { - exportDefs.addAll(af.createPExportAssistant().getDefinition(exp, actualDefs)); - } - } - - // Mark all exports as used - - for (PDefinition d : exportDefs) - { - af.createPDefinitionAssistant().markUsed(d); - } - - return exportDefs; - } - - public Collection getDefinitions( - AModuleExports aModuleExports) - { - List exportDefs = new Vector(); - - for (List etype : aModuleExports.getExports()) - { - for (PExport exp : etype) - { - exportDefs.addAll(af.createPExportAssistant().getDefinition(exp)); - } - } - - // Mark all exports as used - - for (PDefinition d : exportDefs) - { - af.createPDefinitionAssistant().markUsed(d); - } - - return exportDefs; - } - -} diff --git a/core/typechecker/src/main/java/org/overture/typechecker/assistant/module/AModuleModulesAssistantTC.java b/core/typechecker/src/main/java/org/overture/typechecker/assistant/module/AModuleModulesAssistantTC.java index 58555a8731..d03f787ef7 100644 --- a/core/typechecker/src/main/java/org/overture/typechecker/assistant/module/AModuleModulesAssistantTC.java +++ b/core/typechecker/src/main/java/org/overture/typechecker/assistant/module/AModuleModulesAssistantTC.java @@ -21,13 +21,18 @@ */ package org.overture.typechecker.assistant.module; +import java.util.Collection; +import java.util.LinkedList; import java.util.List; +import java.util.Vector; import org.overture.ast.analysis.AnalysisException; import org.overture.ast.assistant.IAstAssistant; import org.overture.ast.definitions.PDefinition; import org.overture.ast.intf.lex.ILexIdentifierToken; +import org.overture.ast.modules.AModuleExports; import org.overture.ast.modules.AModuleModules; +import org.overture.ast.modules.PExport; import org.overture.typechecker.ModuleEnvironment; import org.overture.typechecker.assistant.ITypeCheckerAssistantFactory; @@ -52,10 +57,10 @@ public void processExports(AModuleModules m) { if (!m.getIsDLModule()) { - m.getExportdefs().addAll(af.createAModuleExportsAssistant().getDefinitions(m.getExports(), m.getDefs())); + m.getExportdefs().addAll(getDefinitions(m.getExports(), m.getDefs())); } else { - m.getExportdefs().addAll(af.createAModuleExportsAssistant().getDefinitions(m.getExports())); + m.getExportdefs().addAll(getDefinitions(m.getExports())); } } } @@ -109,5 +114,51 @@ public void typeCheckImports(AModuleModules m) throws AnalysisException } } + + public Collection getDefinitions( + AModuleExports aModuleExports, LinkedList actualDefs) + { + List exportDefs = new Vector(); + + for (List etype : aModuleExports.getExports()) + { + for (PExport exp : etype) + { + exportDefs.addAll(af.createPExportAssistant().getDefinition(exp, actualDefs)); + } + } + + // Mark all exports as used + + for (PDefinition d : exportDefs) + { + af.createPDefinitionAssistant().markUsed(d); + } + + return exportDefs; + } + + public Collection getDefinitions( + AModuleExports aModuleExports) + { + List exportDefs = new Vector(); + + for (List etype : aModuleExports.getExports()) + { + for (PExport exp : etype) + { + exportDefs.addAll(af.createPExportAssistant().getDefinition(exp)); + } + } + + // Mark all exports as used + + for (PDefinition d : exportDefs) + { + af.createPDefinitionAssistant().markUsed(d); + } + + return exportDefs; + } } From 2ea43363b7c42be6e826cf006841e14dc811b1c8 Mon Sep 17 00:00:00 2001 From: gkanos Date: Tue, 24 Feb 2015 11:05:31 +0100 Subject: [PATCH 138/323] Move the methods from the PExpAssistantTC to PogParamExpVisitor. Deleted the PExpAssistantTC as empty. --- .../pog/visitors/PogParamExpVisitor.java | 19 +++++-- .../ITypeCheckerAssistantFactory.java | 3 +- .../TypeCheckerAssistantFactory.java | 11 ++-- .../assistant/expression/PExpAssistantTC.java | 55 ------------------- 4 files changed, 21 insertions(+), 67 deletions(-) delete mode 100644 core/typechecker/src/main/java/org/overture/typechecker/assistant/expression/PExpAssistantTC.java diff --git a/core/pog/src/main/java/org/overture/pog/visitors/PogParamExpVisitor.java b/core/pog/src/main/java/org/overture/pog/visitors/PogParamExpVisitor.java index 4238c0802b..535d3631fd 100644 --- a/core/pog/src/main/java/org/overture/pog/visitors/PogParamExpVisitor.java +++ b/core/pog/src/main/java/org/overture/pog/visitors/PogParamExpVisitor.java @@ -133,7 +133,7 @@ public IProofObligationList caseAApplyExp(AApplyExp node, && aF.createPTypeAssistant().isFunction(type)) { AFunctionType funcType = aF.createPTypeAssistant().getFunction(type); - ILexNameToken prename = aF.createPExpAssistant().getPreName(root); + ILexNameToken prename = getPreName(root); if (prename == null || !prename.equals(PExpAssistantTC.NO_PRECONDITION)) { @@ -1152,8 +1152,8 @@ public IProofObligationList caseACompBinaryExp(ACompBinaryExp node, if (aF.createPTypeAssistant().isFunction(lType)) { - ILexNameToken pref1 = aF.createPExpAssistant().getPreName(lExp); - ILexNameToken pref2 = aF.createPExpAssistant().getPreName(rExp); + ILexNameToken pref1 = getPreName(lExp); + ILexNameToken pref2 = getPreName(rExp); if (pref1 == null || !pref1.equals(PExpAssistantTC.NO_PRECONDITION)) { @@ -1378,7 +1378,7 @@ public IProofObligationList caseAStarStarBinaryExp(AStarStarBinaryExp node, if (aF.createPTypeAssistant().isFunction(lType)) { - ILexNameToken preName = aF.createPExpAssistant().getPreName(lExp); + ILexNameToken preName = getPreName(lExp); if (preName == null || !preName.equals(PExpAssistantTC.NO_PRECONDITION)) { @@ -1874,5 +1874,16 @@ public IProofObligationList createNewReturnValue(Object node, { return new ProofObligationList(); } + + public ILexNameToken getPreName(PExp expression) + { + try + { + return expression.apply(aF.getPreNameFinder()); + } catch (AnalysisException e) + { + return null; + } + } } diff --git a/core/typechecker/src/main/java/org/overture/typechecker/assistant/ITypeCheckerAssistantFactory.java b/core/typechecker/src/main/java/org/overture/typechecker/assistant/ITypeCheckerAssistantFactory.java index 2997cdeda9..27f2f07f9a 100644 --- a/core/typechecker/src/main/java/org/overture/typechecker/assistant/ITypeCheckerAssistantFactory.java +++ b/core/typechecker/src/main/java/org/overture/typechecker/assistant/ITypeCheckerAssistantFactory.java @@ -72,7 +72,6 @@ import org.overture.typechecker.assistant.definition.PTraceDefinitionAssistantTC; import org.overture.typechecker.assistant.definition.SClassDefinitionAssistantTC; import org.overture.typechecker.assistant.expression.ACaseAlternativeAssistantTC; -import org.overture.typechecker.assistant.expression.PExpAssistantTC; import org.overture.typechecker.assistant.expression.SBinaryExpAssistantTC; import org.overture.typechecker.assistant.module.AModuleImportsAssistantTC; import org.overture.typechecker.assistant.module.AModuleModulesAssistantTC; @@ -166,7 +165,7 @@ public interface ITypeCheckerAssistantFactory extends IAstAssistantFactory ACaseAlternativeAssistantTC createACaseAlternativeAssistant(); - PExpAssistantTC createPExpAssistant(); + //PExpAssistantTC createPExpAssistant(); SBinaryExpAssistantTC createSBinaryExpAssistant(); diff --git a/core/typechecker/src/main/java/org/overture/typechecker/assistant/TypeCheckerAssistantFactory.java b/core/typechecker/src/main/java/org/overture/typechecker/assistant/TypeCheckerAssistantFactory.java index 4645efd0fc..bfaa7c4a3d 100644 --- a/core/typechecker/src/main/java/org/overture/typechecker/assistant/TypeCheckerAssistantFactory.java +++ b/core/typechecker/src/main/java/org/overture/typechecker/assistant/TypeCheckerAssistantFactory.java @@ -72,7 +72,6 @@ import org.overture.typechecker.assistant.definition.PTraceDefinitionAssistantTC; import org.overture.typechecker.assistant.definition.SClassDefinitionAssistantTC; import org.overture.typechecker.assistant.expression.ACaseAlternativeAssistantTC; -import org.overture.typechecker.assistant.expression.PExpAssistantTC; import org.overture.typechecker.assistant.expression.SBinaryExpAssistantTC; import org.overture.typechecker.assistant.module.AModuleImportsAssistantTC; import org.overture.typechecker.assistant.module.AModuleModulesAssistantTC; @@ -383,11 +382,11 @@ public ACaseAlternativeAssistantTC createACaseAlternativeAssistant() return new ACaseAlternativeAssistantTC(this); } - @Override - public PExpAssistantTC createPExpAssistant() - { - return new PExpAssistantTC(this); - } +// @Override +// public PExpAssistantTC createPExpAssistant() +// { +// return new PExpAssistantTC(this); +// } @Override public SBinaryExpAssistantTC createSBinaryExpAssistant() diff --git a/core/typechecker/src/main/java/org/overture/typechecker/assistant/expression/PExpAssistantTC.java b/core/typechecker/src/main/java/org/overture/typechecker/assistant/expression/PExpAssistantTC.java deleted file mode 100644 index 0252214415..0000000000 --- a/core/typechecker/src/main/java/org/overture/typechecker/assistant/expression/PExpAssistantTC.java +++ /dev/null @@ -1,55 +0,0 @@ -/* - * #%~ - * The VDM Type Checker - * %% - * Copyright (C) 2008 - 2014 Overture - * %% - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as - * published by the Free Software Foundation, either version 3 of the - * License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public - * License along with this program. If not, see - * . - * #~% - */ -package org.overture.typechecker.assistant.expression; - -import org.overture.ast.analysis.AnalysisException; -import org.overture.ast.assistant.IAstAssistant; -import org.overture.ast.expressions.PExp; -import org.overture.ast.intf.lex.ILexNameToken; -import org.overture.ast.lex.LexNameToken; -import org.overture.typechecker.assistant.ITypeCheckerAssistantFactory; - -public class PExpAssistantTC implements IAstAssistant -{ - protected ITypeCheckerAssistantFactory af; - // A LexNameToken to indicate that a function has no precondition name, rather than - // that it is not a pure function (indicated by null). - public final static LexNameToken NO_PRECONDITION = new LexNameToken("", "", null); - - public PExpAssistantTC(ITypeCheckerAssistantFactory af) - { - this.af = af; - } - - //FIXME only used in 1 class. move it - public ILexNameToken getPreName(PExp expression) - { - try - { - return expression.apply(af.getPreNameFinder()); - } catch (AnalysisException e) - { - return null; - } - } - -} From d29574d0b3d04a05a01d573a7e805360d502a8e6 Mon Sep 17 00:00:00 2001 From: gkanos Date: Tue, 24 Feb 2015 11:23:54 +0100 Subject: [PATCH 139/323] follow up on the previous commit. Forgotten file and a minor change to the PogParamexpression. --- .../assistant/expression/PExpAssistantInterpreter.java | 5 ++--- .../org/overture/pog/visitors/PogParamExpVisitor.java | 9 +++++---- 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/core/interpreter/src/main/java/org/overture/interpreter/assistant/expression/PExpAssistantInterpreter.java b/core/interpreter/src/main/java/org/overture/interpreter/assistant/expression/PExpAssistantInterpreter.java index ff046ebb36..0b2cdb14fa 100644 --- a/core/interpreter/src/main/java/org/overture/interpreter/assistant/expression/PExpAssistantInterpreter.java +++ b/core/interpreter/src/main/java/org/overture/interpreter/assistant/expression/PExpAssistantInterpreter.java @@ -11,16 +11,15 @@ import org.overture.interpreter.assistant.IInterpreterAssistantFactory; import org.overture.interpreter.runtime.ObjectContext; import org.overture.interpreter.values.ValueList; -import org.overture.typechecker.assistant.expression.PExpAssistantTC; -public class PExpAssistantInterpreter extends PExpAssistantTC implements IAstAssistant +public class PExpAssistantInterpreter implements IAstAssistant { protected static IInterpreterAssistantFactory af; @SuppressWarnings("static-access") public PExpAssistantInterpreter(IInterpreterAssistantFactory af) { - super(af); + //super(af); this.af = af; } diff --git a/core/pog/src/main/java/org/overture/pog/visitors/PogParamExpVisitor.java b/core/pog/src/main/java/org/overture/pog/visitors/PogParamExpVisitor.java index 535d3631fd..5ecf5ecf41 100644 --- a/core/pog/src/main/java/org/overture/pog/visitors/PogParamExpVisitor.java +++ b/core/pog/src/main/java/org/overture/pog/visitors/PogParamExpVisitor.java @@ -63,7 +63,6 @@ import org.overture.pog.pub.IPogAssistantFactory; import org.overture.pog.pub.IProofObligationList; import org.overture.pog.utility.PogAssistantFactory; -import org.overture.typechecker.assistant.expression.PExpAssistantTC; public class PogParamExpVisitor extends QuestionAnswerAdaptor @@ -71,6 +70,8 @@ public class PogParamExpVisitor rootVisitor; final private QuestionAnswerAdaptor mainVisitor; + + public final static LexNameToken NO_PRECONDITION = new LexNameToken("", "", null); final private IPogAssistantFactory aF; @@ -135,7 +136,7 @@ public IProofObligationList caseAApplyExp(AApplyExp node, AFunctionType funcType = aF.createPTypeAssistant().getFunction(type); ILexNameToken prename = getPreName(root); if (prename == null - || !prename.equals(PExpAssistantTC.NO_PRECONDITION)) + || !prename.equals(NO_PRECONDITION)) { obligations.add(new FunctionApplyObligation(node.getRoot(), node.getArgs(), prename, question, aF)); } @@ -1155,7 +1156,7 @@ public IProofObligationList caseACompBinaryExp(ACompBinaryExp node, ILexNameToken pref1 = getPreName(lExp); ILexNameToken pref2 = getPreName(rExp); - if (pref1 == null || !pref1.equals(PExpAssistantTC.NO_PRECONDITION)) + if (pref1 == null || !pref1.equals(NO_PRECONDITION)) { obligations.add(new FuncComposeObligation(node, pref1, pref2, question, aF));// gkanos:add on more // argument for the @@ -1380,7 +1381,7 @@ public IProofObligationList caseAStarStarBinaryExp(AStarStarBinaryExp node, { ILexNameToken preName = getPreName(lExp); if (preName == null - || !preName.equals(PExpAssistantTC.NO_PRECONDITION)) + || !preName.equals(NO_PRECONDITION)) { obligations.add(new org.overture.pog.obligation.FuncIterationObligation(node, preName, question, aF)); } From 2c2ee3e24c361ab656c3ec8f492d94d30183ddf4 Mon Sep 17 00:00:00 2001 From: gkanos Date: Tue, 24 Feb 2015 11:36:31 +0100 Subject: [PATCH 140/323] Move methods from PExportAssistantTC to AModuleModuleAssistantTC. Delete PExportAssistantTC. --- .../ITypeCheckerAssistantFactory.java | 3 +- .../TypeCheckerAssistantFactory.java | 11 ++-- .../module/AModuleModulesAssistantTC.java | 28 +++++++- .../assistant/module/PExportAssistantTC.java | 66 ------------------- 4 files changed, 32 insertions(+), 76 deletions(-) delete mode 100644 core/typechecker/src/main/java/org/overture/typechecker/assistant/module/PExportAssistantTC.java diff --git a/core/typechecker/src/main/java/org/overture/typechecker/assistant/ITypeCheckerAssistantFactory.java b/core/typechecker/src/main/java/org/overture/typechecker/assistant/ITypeCheckerAssistantFactory.java index 27f2f07f9a..146426df03 100644 --- a/core/typechecker/src/main/java/org/overture/typechecker/assistant/ITypeCheckerAssistantFactory.java +++ b/core/typechecker/src/main/java/org/overture/typechecker/assistant/ITypeCheckerAssistantFactory.java @@ -75,7 +75,6 @@ import org.overture.typechecker.assistant.expression.SBinaryExpAssistantTC; import org.overture.typechecker.assistant.module.AModuleImportsAssistantTC; import org.overture.typechecker.assistant.module.AModuleModulesAssistantTC; -import org.overture.typechecker.assistant.module.PExportAssistantTC; import org.overture.typechecker.assistant.module.PImportAssistantTC; import org.overture.typechecker.assistant.pattern.AMapletPatternMapletAssistantTC; import org.overture.typechecker.assistant.pattern.APatternTypePairAssistant; @@ -179,7 +178,7 @@ public interface ITypeCheckerAssistantFactory extends IAstAssistantFactory AModuleModulesAssistantTC createAModuleModulesAssistant(); - PExportAssistantTC createPExportAssistant(); + //PExportAssistantTC createPExportAssistant(); PImportAssistantTC createPImportAssistant(); diff --git a/core/typechecker/src/main/java/org/overture/typechecker/assistant/TypeCheckerAssistantFactory.java b/core/typechecker/src/main/java/org/overture/typechecker/assistant/TypeCheckerAssistantFactory.java index bfaa7c4a3d..c74bca5d30 100644 --- a/core/typechecker/src/main/java/org/overture/typechecker/assistant/TypeCheckerAssistantFactory.java +++ b/core/typechecker/src/main/java/org/overture/typechecker/assistant/TypeCheckerAssistantFactory.java @@ -75,7 +75,6 @@ import org.overture.typechecker.assistant.expression.SBinaryExpAssistantTC; import org.overture.typechecker.assistant.module.AModuleImportsAssistantTC; import org.overture.typechecker.assistant.module.AModuleModulesAssistantTC; -import org.overture.typechecker.assistant.module.PExportAssistantTC; import org.overture.typechecker.assistant.module.PImportAssistantTC; import org.overture.typechecker.assistant.pattern.AMapletPatternMapletAssistantTC; import org.overture.typechecker.assistant.pattern.APatternTypePairAssistant; @@ -422,11 +421,11 @@ public AModuleModulesAssistantTC createAModuleModulesAssistant() - @Override - public PExportAssistantTC createPExportAssistant() - { - return new PExportAssistantTC(this); - } +// @Override +// public PExportAssistantTC createPExportAssistant() +// { +// return new PExportAssistantTC(this); +// } @Override public PImportAssistantTC createPImportAssistant() diff --git a/core/typechecker/src/main/java/org/overture/typechecker/assistant/module/AModuleModulesAssistantTC.java b/core/typechecker/src/main/java/org/overture/typechecker/assistant/module/AModuleModulesAssistantTC.java index d03f787ef7..9f4904fdcb 100644 --- a/core/typechecker/src/main/java/org/overture/typechecker/assistant/module/AModuleModulesAssistantTC.java +++ b/core/typechecker/src/main/java/org/overture/typechecker/assistant/module/AModuleModulesAssistantTC.java @@ -124,7 +124,7 @@ public Collection getDefinitions( { for (PExport exp : etype) { - exportDefs.addAll(af.createPExportAssistant().getDefinition(exp, actualDefs)); + exportDefs.addAll(getDefinition(exp, actualDefs)); } } @@ -147,7 +147,7 @@ public Collection getDefinitions( { for (PExport exp : etype) { - exportDefs.addAll(af.createPExportAssistant().getDefinition(exp)); + exportDefs.addAll(getDefinition(exp)); } } @@ -160,5 +160,29 @@ public Collection getDefinitions( return exportDefs; } + + public Collection getDefinition(PExport exp, + LinkedList actualDefs) + { + try + { + return exp.apply(af.getExportDefinitionFinder(), actualDefs); + } catch (AnalysisException e) + { + return null; + } + + } + + public Collection getDefinition(PExport exp) + { + try + { + return exp.apply(af.getExportDefinitionListFinder()); + } catch (AnalysisException e) + { + return null; + } + } } diff --git a/core/typechecker/src/main/java/org/overture/typechecker/assistant/module/PExportAssistantTC.java b/core/typechecker/src/main/java/org/overture/typechecker/assistant/module/PExportAssistantTC.java deleted file mode 100644 index 415975f600..0000000000 --- a/core/typechecker/src/main/java/org/overture/typechecker/assistant/module/PExportAssistantTC.java +++ /dev/null @@ -1,66 +0,0 @@ -/* - * #%~ - * The VDM Type Checker - * %% - * Copyright (C) 2008 - 2014 Overture - * %% - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as - * published by the Free Software Foundation, either version 3 of the - * License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public - * License along with this program. If not, see - * . - * #~% - */ -package org.overture.typechecker.assistant.module; - -import java.util.Collection; -import java.util.LinkedList; - -import org.overture.ast.analysis.AnalysisException; -import org.overture.ast.assistant.IAstAssistant; -import org.overture.ast.definitions.PDefinition; -import org.overture.ast.modules.PExport; -import org.overture.typechecker.assistant.ITypeCheckerAssistantFactory; - -//FIXME only used in 1 class. move it -public class PExportAssistantTC implements IAstAssistant -{ - protected ITypeCheckerAssistantFactory af; - - public PExportAssistantTC(ITypeCheckerAssistantFactory af) - { - this.af = af; - } - - public Collection getDefinition(PExport exp, - LinkedList actualDefs) - { - try - { - return exp.apply(af.getExportDefinitionFinder(), actualDefs); - } catch (AnalysisException e) - { - return null; - } - - } - - public Collection getDefinition(PExport exp) - { - try - { - return exp.apply(af.getExportDefinitionListFinder()); - } catch (AnalysisException e) - { - return null; - } - } -} From 6354ab630450abc4026504cdfd4b5a646c8db4ab Mon Sep 17 00:00:00 2001 From: gkanos Date: Tue, 24 Feb 2015 12:22:14 +0100 Subject: [PATCH 141/323] Move the method from the PPatternAssistantTC to the TypeCheckerStmVisitor. Delete PPatternAssistantTC as empty. --- .../ITypeCheckerAssistantFactory.java | 3 +- .../TypeCheckerAssistantFactory.java | 11 ++--- .../pattern/PPatternBindAssistantTC.java | 48 ------------------- .../visitor/TypeCheckerStmVisitor.java | 13 +++-- 4 files changed, 16 insertions(+), 59 deletions(-) delete mode 100644 core/typechecker/src/main/java/org/overture/typechecker/assistant/pattern/PPatternBindAssistantTC.java diff --git a/core/typechecker/src/main/java/org/overture/typechecker/assistant/ITypeCheckerAssistantFactory.java b/core/typechecker/src/main/java/org/overture/typechecker/assistant/ITypeCheckerAssistantFactory.java index 146426df03..782e23f75a 100644 --- a/core/typechecker/src/main/java/org/overture/typechecker/assistant/ITypeCheckerAssistantFactory.java +++ b/core/typechecker/src/main/java/org/overture/typechecker/assistant/ITypeCheckerAssistantFactory.java @@ -83,7 +83,6 @@ import org.overture.typechecker.assistant.pattern.PBindAssistantTC; import org.overture.typechecker.assistant.pattern.PMultipleBindAssistantTC; import org.overture.typechecker.assistant.pattern.PPatternAssistantTC; -import org.overture.typechecker.assistant.pattern.PPatternBindAssistantTC; import org.overture.typechecker.assistant.pattern.PPatternListAssistantTC; import org.overture.typechecker.assistant.pattern.PatternListTC; import org.overture.typechecker.assistant.statement.ABlockSimpleBlockStmAssistantTC; @@ -221,7 +220,7 @@ public interface ITypeCheckerAssistantFactory extends IAstAssistantFactory PPatternAssistantTC createPPatternAssistant(); - PPatternBindAssistantTC createPPatternBindAssistant(); + //PPatternBindAssistantTC createPPatternBindAssistant(); PPatternListAssistantTC createPPatternListAssistant(); diff --git a/core/typechecker/src/main/java/org/overture/typechecker/assistant/TypeCheckerAssistantFactory.java b/core/typechecker/src/main/java/org/overture/typechecker/assistant/TypeCheckerAssistantFactory.java index c74bca5d30..f82a030e47 100644 --- a/core/typechecker/src/main/java/org/overture/typechecker/assistant/TypeCheckerAssistantFactory.java +++ b/core/typechecker/src/main/java/org/overture/typechecker/assistant/TypeCheckerAssistantFactory.java @@ -83,7 +83,6 @@ import org.overture.typechecker.assistant.pattern.PBindAssistantTC; import org.overture.typechecker.assistant.pattern.PMultipleBindAssistantTC; import org.overture.typechecker.assistant.pattern.PPatternAssistantTC; -import org.overture.typechecker.assistant.pattern.PPatternBindAssistantTC; import org.overture.typechecker.assistant.pattern.PPatternListAssistantTC; import org.overture.typechecker.assistant.pattern.PatternListTC; import org.overture.typechecker.assistant.statement.ABlockSimpleBlockStmAssistantTC; @@ -549,11 +548,11 @@ public PPatternAssistantTC createPPatternAssistant() return new PPatternAssistantTC(this); } - @Override - public PPatternBindAssistantTC createPPatternBindAssistant() - { - return new PPatternBindAssistantTC(this); - } +// @Override +// public PPatternBindAssistantTC createPPatternBindAssistant() +// { +// return new PPatternBindAssistantTC(this); +// } @Override public PPatternListAssistantTC createPPatternListAssistant() diff --git a/core/typechecker/src/main/java/org/overture/typechecker/assistant/pattern/PPatternBindAssistantTC.java b/core/typechecker/src/main/java/org/overture/typechecker/assistant/pattern/PPatternBindAssistantTC.java deleted file mode 100644 index 550b245ad0..0000000000 --- a/core/typechecker/src/main/java/org/overture/typechecker/assistant/pattern/PPatternBindAssistantTC.java +++ /dev/null @@ -1,48 +0,0 @@ -/* - * #%~ - * The VDM Type Checker - * %% - * Copyright (C) 2008 - 2014 Overture - * %% - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as - * published by the Free Software Foundation, either version 3 of the - * License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public - * License along with this program. If not, see - * . - * #~% - */ -package org.overture.typechecker.assistant.pattern; - -import java.util.List; - -import org.overture.ast.assistant.IAstAssistant; -import org.overture.ast.definitions.PDefinition; -import org.overture.ast.patterns.ADefPatternBind; -import org.overture.typechecker.assistant.ITypeCheckerAssistantFactory; - -public class PPatternBindAssistantTC implements IAstAssistant -{ - protected ITypeCheckerAssistantFactory af; - - public PPatternBindAssistantTC(ITypeCheckerAssistantFactory af) - { - this.af = af; - } - -//FIXME only used in 1 class. move it. - public List getDefinitions(ADefPatternBind patternBind) - { - assert patternBind.getDefs() != null : "PatternBind must be type checked before getDefinitions"; - - return patternBind.getDefs(); - } - -} diff --git a/core/typechecker/src/main/java/org/overture/typechecker/visitor/TypeCheckerStmVisitor.java b/core/typechecker/src/main/java/org/overture/typechecker/visitor/TypeCheckerStmVisitor.java index 3838ffbb49..a1bdc7d3cd 100644 --- a/core/typechecker/src/main/java/org/overture/typechecker/visitor/TypeCheckerStmVisitor.java +++ b/core/typechecker/src/main/java/org/overture/typechecker/visitor/TypeCheckerStmVisitor.java @@ -200,7 +200,7 @@ public PType caseAForPatternBindStm(AForPatternBindStm node, { node.setSeqType(question.assistantFactory.createPTypeAssistant().getSeq(stype)); node.getPatternBind().apply(THIS, new TypeCheckInfo(question.assistantFactory, question.env, question.scope)); - List defs = question.assistantFactory.createPPatternBindAssistant().getDefinitions(node.getPatternBind()); + List defs = getDefinitions(node.getPatternBind()); question.assistantFactory.createPDefinitionListAssistant().typeCheck(defs, THIS, new TypeCheckInfo(question.assistantFactory, question.env, question.scope)); local = new FlatCheckedEnvironment(question.assistantFactory, defs, question.env, question.scope); } else @@ -946,7 +946,7 @@ public PType caseATrapStm(ATrapStm node, TypeCheckInfo question) node.setType(ptype); node.getPatternBind().apply(THIS, question); // TODO: PatternBind stuff - List defs = question.assistantFactory.createPPatternBindAssistant().getDefinitions(node.getPatternBind()); + List defs = getDefinitions(node.getPatternBind()); question.assistantFactory.createPDefinitionListAssistant().typeCheck(defs, THIS, question); Environment local = new FlatCheckedEnvironment(question.assistantFactory, defs, question.env, question.scope); rtypes.add(node.getWith().apply(THIS, new TypeCheckInfo(question.assistantFactory, local, question.scope, question.qualifiers))); @@ -1278,7 +1278,7 @@ public PType caseATixeStmtAlternative(ATixeStmtAlternative node, // THIS, question); // DefinitionList defs = patternBind.getDefinitions(); node.getPatternBind().apply(THIS, new TypeCheckInfo(question.assistantFactory, question.env, question.scope)); - List defs = question.assistantFactory.createPPatternBindAssistant().getDefinitions(node.getPatternBind()); + List defs = getDefinitions(node.getPatternBind()); question.assistantFactory.createPDefinitionListAssistant().typeCheck(defs, THIS, question); Environment local = new FlatCheckedEnvironment(question.assistantFactory, defs, question.env, question.scope); node.getStatement().apply(THIS, new TypeCheckInfo(question.assistantFactory, local, question.scope, question.qualifiers)); @@ -1336,5 +1336,12 @@ public PType caseADefPatternBind(ADefPatternBind node, } return null; } + + public List getDefinitions(ADefPatternBind patternBind) + { + assert patternBind.getDefs() != null : "PatternBind must be type checked before getDefinitions"; + + return patternBind.getDefs(); + } } From 37926649cbaa4f27d5ee32eadce19c266e4bda17 Mon Sep 17 00:00:00 2001 From: gkanos Date: Tue, 24 Feb 2015 12:53:21 +0100 Subject: [PATCH 142/323] Move the method from the ALocalDefinitionAssistantTC to DefinitionTypeResolver. Delete the ALocalDefinitionAssistantTC as empty. --- .../ITypeCheckerAssistantFactory.java | 3 +- .../TypeCheckerAssistantFactory.java | 11 +++-- .../ALocalDefinitionAssistantTC.java | 45 ------------------- .../utilities/DefinitionTypeResolver.java | 9 +++- 4 files changed, 14 insertions(+), 54 deletions(-) delete mode 100644 core/typechecker/src/main/java/org/overture/typechecker/assistant/definition/ALocalDefinitionAssistantTC.java diff --git a/core/typechecker/src/main/java/org/overture/typechecker/assistant/ITypeCheckerAssistantFactory.java b/core/typechecker/src/main/java/org/overture/typechecker/assistant/ITypeCheckerAssistantFactory.java index 782e23f75a..3250c5fa99 100644 --- a/core/typechecker/src/main/java/org/overture/typechecker/assistant/ITypeCheckerAssistantFactory.java +++ b/core/typechecker/src/main/java/org/overture/typechecker/assistant/ITypeCheckerAssistantFactory.java @@ -61,7 +61,6 @@ import org.overture.typechecker.assistant.definition.AImplicitFunctionDefinitionAssistantTC; import org.overture.typechecker.assistant.definition.AImplicitOperationDefinitionAssistantTC; import org.overture.typechecker.assistant.definition.AInstanceVariableDefinitionAssistantTC; -import org.overture.typechecker.assistant.definition.ALocalDefinitionAssistantTC; import org.overture.typechecker.assistant.definition.AStateDefinitionAssistantTC; import org.overture.typechecker.assistant.definition.AThreadDefinitionAssistantTC; import org.overture.typechecker.assistant.definition.ATypeDefinitionAssistantTC; @@ -134,7 +133,7 @@ public interface ITypeCheckerAssistantFactory extends IAstAssistantFactory AInstanceVariableDefinitionAssistantTC createAInstanceVariableDefinitionAssistant(); - ALocalDefinitionAssistantTC createALocalDefinitionAssistant(); + //ALocalDefinitionAssistantTC createALocalDefinitionAssistant(); AStateDefinitionAssistantTC createAStateDefinitionAssistant(); diff --git a/core/typechecker/src/main/java/org/overture/typechecker/assistant/TypeCheckerAssistantFactory.java b/core/typechecker/src/main/java/org/overture/typechecker/assistant/TypeCheckerAssistantFactory.java index f82a030e47..1db851016f 100644 --- a/core/typechecker/src/main/java/org/overture/typechecker/assistant/TypeCheckerAssistantFactory.java +++ b/core/typechecker/src/main/java/org/overture/typechecker/assistant/TypeCheckerAssistantFactory.java @@ -61,7 +61,6 @@ import org.overture.typechecker.assistant.definition.AImplicitFunctionDefinitionAssistantTC; import org.overture.typechecker.assistant.definition.AImplicitOperationDefinitionAssistantTC; import org.overture.typechecker.assistant.definition.AInstanceVariableDefinitionAssistantTC; -import org.overture.typechecker.assistant.definition.ALocalDefinitionAssistantTC; import org.overture.typechecker.assistant.definition.AStateDefinitionAssistantTC; import org.overture.typechecker.assistant.definition.AThreadDefinitionAssistantTC; import org.overture.typechecker.assistant.definition.ATypeDefinitionAssistantTC; @@ -294,11 +293,11 @@ public AInstanceVariableDefinitionAssistantTC createAInstanceVariableDefinitionA return new AInstanceVariableDefinitionAssistantTC(this); } - @Override - public ALocalDefinitionAssistantTC createALocalDefinitionAssistant() - { - return new ALocalDefinitionAssistantTC(this); - } +// @Override +// public ALocalDefinitionAssistantTC createALocalDefinitionAssistant() +// { +// return new ALocalDefinitionAssistantTC(this); +// } @Override public AStateDefinitionAssistantTC createAStateDefinitionAssistant() diff --git a/core/typechecker/src/main/java/org/overture/typechecker/assistant/definition/ALocalDefinitionAssistantTC.java b/core/typechecker/src/main/java/org/overture/typechecker/assistant/definition/ALocalDefinitionAssistantTC.java deleted file mode 100644 index 267f5007e9..0000000000 --- a/core/typechecker/src/main/java/org/overture/typechecker/assistant/definition/ALocalDefinitionAssistantTC.java +++ /dev/null @@ -1,45 +0,0 @@ -/* - * #%~ - * The VDM Type Checker - * %% - * Copyright (C) 2008 - 2014 Overture - * %% - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as - * published by the Free Software Foundation, either version 3 of the - * License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public - * License along with this program. If not, see - * . - * #~% - */ -package org.overture.typechecker.assistant.definition; - -import org.overture.ast.assistant.IAstAssistant; -import org.overture.ast.definitions.ALocalDefinition; -import org.overture.typechecker.assistant.ITypeCheckerAssistantFactory; - -public class ALocalDefinitionAssistantTC implements IAstAssistant -{ - - protected ITypeCheckerAssistantFactory af; - - public ALocalDefinitionAssistantTC(ITypeCheckerAssistantFactory af) - { - this.af = af; - } - - //FIXME only used in 1 place. move - public void setValueDefinition(ALocalDefinition ld) - { - ld.setValueDefinition(true); - - } - -} diff --git a/core/typechecker/src/main/java/org/overture/typechecker/utilities/DefinitionTypeResolver.java b/core/typechecker/src/main/java/org/overture/typechecker/utilities/DefinitionTypeResolver.java index c8c7a10c19..327a060e30 100644 --- a/core/typechecker/src/main/java/org/overture/typechecker/utilities/DefinitionTypeResolver.java +++ b/core/typechecker/src/main/java/org/overture/typechecker/utilities/DefinitionTypeResolver.java @@ -406,7 +406,7 @@ public void updateDefs(AValueDefinition node, TypeCheckInfo question) } ALocalDefinition ld = (ALocalDefinition) d; - af.createALocalDefinitionAssistant().setValueDefinition(ld); + setValueDefinition(ld); } node.setDefs(newdefs); @@ -430,5 +430,12 @@ public void defaultPDefinition(PDefinition node, NewQuestion question) { return; } + + public void setValueDefinition(ALocalDefinition ld) + { + ld.setValueDefinition(true); + + } + } From 0ac8879b923a0d502b97c7116a830af011b1f6a8 Mon Sep 17 00:00:00 2001 From: gkanos Date: Tue, 24 Feb 2015 14:19:37 +0100 Subject: [PATCH 143/323] Move the method from the AinstanceVariableDefinitionAssistant to PDefinitionListAssistantTC. Remove the AInstanceVariableDefinitionAssistantTC. --- .../ITypeCheckerAssistantFactory.java | 3 +- .../TypeCheckerAssistantFactory.java | 11 ++-- ...InstanceVariableDefinitionAssistantTC.java | 51 ------------------- .../PDefinitionListAssistantTC.java | 14 ++++- 4 files changed, 19 insertions(+), 60 deletions(-) delete mode 100644 core/typechecker/src/main/java/org/overture/typechecker/assistant/definition/AInstanceVariableDefinitionAssistantTC.java diff --git a/core/typechecker/src/main/java/org/overture/typechecker/assistant/ITypeCheckerAssistantFactory.java b/core/typechecker/src/main/java/org/overture/typechecker/assistant/ITypeCheckerAssistantFactory.java index 3250c5fa99..2fb7310bae 100644 --- a/core/typechecker/src/main/java/org/overture/typechecker/assistant/ITypeCheckerAssistantFactory.java +++ b/core/typechecker/src/main/java/org/overture/typechecker/assistant/ITypeCheckerAssistantFactory.java @@ -60,7 +60,6 @@ import org.overture.typechecker.assistant.definition.AExplicitOperationDefinitionAssistantTC; import org.overture.typechecker.assistant.definition.AImplicitFunctionDefinitionAssistantTC; import org.overture.typechecker.assistant.definition.AImplicitOperationDefinitionAssistantTC; -import org.overture.typechecker.assistant.definition.AInstanceVariableDefinitionAssistantTC; import org.overture.typechecker.assistant.definition.AStateDefinitionAssistantTC; import org.overture.typechecker.assistant.definition.AThreadDefinitionAssistantTC; import org.overture.typechecker.assistant.definition.ATypeDefinitionAssistantTC; @@ -131,7 +130,7 @@ public interface ITypeCheckerAssistantFactory extends IAstAssistantFactory // AImportedDefinitionAssistantTC createAImportedDefinitionAssistant(); - AInstanceVariableDefinitionAssistantTC createAInstanceVariableDefinitionAssistant(); + //AInstanceVariableDefinitionAssistantTC createAInstanceVariableDefinitionAssistant(); //ALocalDefinitionAssistantTC createALocalDefinitionAssistant(); diff --git a/core/typechecker/src/main/java/org/overture/typechecker/assistant/TypeCheckerAssistantFactory.java b/core/typechecker/src/main/java/org/overture/typechecker/assistant/TypeCheckerAssistantFactory.java index 1db851016f..2456b7d294 100644 --- a/core/typechecker/src/main/java/org/overture/typechecker/assistant/TypeCheckerAssistantFactory.java +++ b/core/typechecker/src/main/java/org/overture/typechecker/assistant/TypeCheckerAssistantFactory.java @@ -60,7 +60,6 @@ import org.overture.typechecker.assistant.definition.AExplicitOperationDefinitionAssistantTC; import org.overture.typechecker.assistant.definition.AImplicitFunctionDefinitionAssistantTC; import org.overture.typechecker.assistant.definition.AImplicitOperationDefinitionAssistantTC; -import org.overture.typechecker.assistant.definition.AInstanceVariableDefinitionAssistantTC; import org.overture.typechecker.assistant.definition.AStateDefinitionAssistantTC; import org.overture.typechecker.assistant.definition.AThreadDefinitionAssistantTC; import org.overture.typechecker.assistant.definition.ATypeDefinitionAssistantTC; @@ -287,11 +286,11 @@ public AImplicitOperationDefinitionAssistantTC createAImplicitOperationDefinitio // return new AImportedDefinitionAssistantTC(this); // } - @Override - public AInstanceVariableDefinitionAssistantTC createAInstanceVariableDefinitionAssistant() - { - return new AInstanceVariableDefinitionAssistantTC(this); - } +// @Override +// public AInstanceVariableDefinitionAssistantTC createAInstanceVariableDefinitionAssistant() +// { +// return new AInstanceVariableDefinitionAssistantTC(this); +// } // @Override // public ALocalDefinitionAssistantTC createALocalDefinitionAssistant() diff --git a/core/typechecker/src/main/java/org/overture/typechecker/assistant/definition/AInstanceVariableDefinitionAssistantTC.java b/core/typechecker/src/main/java/org/overture/typechecker/assistant/definition/AInstanceVariableDefinitionAssistantTC.java deleted file mode 100644 index 2c0dd87da7..0000000000 --- a/core/typechecker/src/main/java/org/overture/typechecker/assistant/definition/AInstanceVariableDefinitionAssistantTC.java +++ /dev/null @@ -1,51 +0,0 @@ -/* - * #%~ - * The VDM Type Checker - * %% - * Copyright (C) 2008 - 2014 Overture - * %% - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as - * published by the Free Software Foundation, either version 3 of the - * License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public - * License along with this program. If not, see - * . - * #~% - */ -package org.overture.typechecker.assistant.definition; - -import org.overture.ast.assistant.IAstAssistant; -import org.overture.ast.definitions.AInstanceVariableDefinition; -import org.overture.typechecker.TypeCheckerErrors; -import org.overture.typechecker.assistant.ITypeCheckerAssistantFactory; - -public class AInstanceVariableDefinitionAssistantTC implements IAstAssistant -{ - protected ITypeCheckerAssistantFactory af; - - public AInstanceVariableDefinitionAssistantTC( - ITypeCheckerAssistantFactory af) - { - this.af = af; - } - - //FIXME only used in 1 place. move it - public void initializedCheck(AInstanceVariableDefinition ivd) - { - if (!ivd.getInitialized() - && !af.createPAccessSpecifierAssistant().isStatic(ivd.getAccess())) - { - TypeCheckerErrors.warning(5001, "Instance variable '" - + ivd.getName() + "' is not initialized", ivd.getLocation(), ivd); - } - - } - -} diff --git a/core/typechecker/src/main/java/org/overture/typechecker/assistant/definition/PDefinitionListAssistantTC.java b/core/typechecker/src/main/java/org/overture/typechecker/assistant/definition/PDefinitionListAssistantTC.java index ea85d69514..ae5b9af9d0 100644 --- a/core/typechecker/src/main/java/org/overture/typechecker/assistant/definition/PDefinitionListAssistantTC.java +++ b/core/typechecker/src/main/java/org/overture/typechecker/assistant/definition/PDefinitionListAssistantTC.java @@ -41,6 +41,7 @@ import org.overture.ast.types.PType; import org.overture.typechecker.Environment; import org.overture.typechecker.TypeCheckInfo; +import org.overture.typechecker.TypeCheckerErrors; import org.overture.typechecker.assistant.ITypeCheckerAssistantFactory; public class PDefinitionListAssistantTC implements IAstAssistant @@ -207,7 +208,7 @@ public void initializedCheck(LinkedList definitions) if (d instanceof AInstanceVariableDefinition) { AInstanceVariableDefinition ivd = (AInstanceVariableDefinition) d; - af.createAInstanceVariableDefinitionAssistant().initializedCheck(ivd); + initializedCheck(ivd); } } } @@ -263,4 +264,15 @@ public void removeDuplicates(List definitions) definitions.addAll(fixed); } } + + public void initializedCheck(AInstanceVariableDefinition ivd) + { + if (!ivd.getInitialized() + && !af.createPAccessSpecifierAssistant().isStatic(ivd.getAccess())) + { + TypeCheckerErrors.warning(5001, "Instance variable '" + + ivd.getName() + "' is not initialized", ivd.getLocation(), ivd); + } + + } } From 36c50e7ecbac66b0d7f1a72b63a3c0617f700097 Mon Sep 17 00:00:00 2001 From: gkanos Date: Tue, 24 Feb 2015 15:44:38 +0100 Subject: [PATCH 144/323] Move the method from ATixeStmtAlternativeAssistantInterpreter to StatementEvaluator. Deleted the ATixeStmtAlternativeAssistantInterpreter as empty. --- .../IInterpreterAssistantFactory.java | 3 +- .../InterpreterAssistantFactory.java | 9 +-- ...xeStmtAlternativeAssistantInterpreter.java | 75 ------------------- .../interpreter/eval/StatementEvaluator.java | 48 +++++++++++- 4 files changed, 52 insertions(+), 83 deletions(-) delete mode 100644 core/interpreter/src/main/java/org/overture/interpreter/assistant/statement/ATixeStmtAlternativeAssistantInterpreter.java diff --git a/core/interpreter/src/main/java/org/overture/interpreter/assistant/IInterpreterAssistantFactory.java b/core/interpreter/src/main/java/org/overture/interpreter/assistant/IInterpreterAssistantFactory.java index ea03da228b..8cf0d5c39a 100644 --- a/core/interpreter/src/main/java/org/overture/interpreter/assistant/IInterpreterAssistantFactory.java +++ b/core/interpreter/src/main/java/org/overture/interpreter/assistant/IInterpreterAssistantFactory.java @@ -35,7 +35,6 @@ import org.overture.interpreter.assistant.pattern.PPatternListAssistantInterpreter; import org.overture.interpreter.assistant.statement.ACaseAlternativeStmAssistantInterpreter; import org.overture.interpreter.assistant.statement.AStartStmAssistantInterpreter; -import org.overture.interpreter.assistant.statement.ATixeStmtAlternativeAssistantInterpreter; import org.overture.interpreter.assistant.statement.PStmAssistantInterpreter; import org.overture.interpreter.assistant.type.PTypeAssistantInterpreter; import org.overture.interpreter.assistant.type.PTypeListAssistant; @@ -318,7 +317,7 @@ public interface IInterpreterAssistantFactory extends // ATixeStmAssistantInterpreter createATixeStmAssistant(); - ATixeStmtAlternativeAssistantInterpreter createATixeStmtAlternativeAssistant(); + //ATixeStmtAlternativeAssistantInterpreter createATixeStmtAlternativeAssistant(); // ATrapStmAssistantInterpreter createATrapStmAssistant(); diff --git a/core/interpreter/src/main/java/org/overture/interpreter/assistant/InterpreterAssistantFactory.java b/core/interpreter/src/main/java/org/overture/interpreter/assistant/InterpreterAssistantFactory.java index 637512d8d5..f7099008fa 100644 --- a/core/interpreter/src/main/java/org/overture/interpreter/assistant/InterpreterAssistantFactory.java +++ b/core/interpreter/src/main/java/org/overture/interpreter/assistant/InterpreterAssistantFactory.java @@ -36,7 +36,6 @@ import org.overture.interpreter.assistant.pattern.PPatternListAssistantInterpreter; import org.overture.interpreter.assistant.statement.ACaseAlternativeStmAssistantInterpreter; import org.overture.interpreter.assistant.statement.AStartStmAssistantInterpreter; -import org.overture.interpreter.assistant.statement.ATixeStmtAlternativeAssistantInterpreter; import org.overture.interpreter.assistant.statement.PStmAssistantInterpreter; import org.overture.interpreter.assistant.type.PTypeAssistantInterpreter; import org.overture.interpreter.assistant.type.PTypeListAssistant; @@ -730,10 +729,10 @@ public AStartStmAssistantInterpreter createAStartStmAssistant() // return new ATixeStmAssistantInterpreter(this); // } // - public ATixeStmtAlternativeAssistantInterpreter createATixeStmtAlternativeAssistant() - { - return new ATixeStmtAlternativeAssistantInterpreter(this); - } +// public ATixeStmtAlternativeAssistantInterpreter createATixeStmtAlternativeAssistant() +// { +// return new ATixeStmtAlternativeAssistantInterpreter(this); +// } // // public ATrapStmAssistantInterpreter createATrapStmAssistant() diff --git a/core/interpreter/src/main/java/org/overture/interpreter/assistant/statement/ATixeStmtAlternativeAssistantInterpreter.java b/core/interpreter/src/main/java/org/overture/interpreter/assistant/statement/ATixeStmtAlternativeAssistantInterpreter.java deleted file mode 100644 index 2de7bef7a6..0000000000 --- a/core/interpreter/src/main/java/org/overture/interpreter/assistant/statement/ATixeStmtAlternativeAssistantInterpreter.java +++ /dev/null @@ -1,75 +0,0 @@ -package org.overture.interpreter.assistant.statement; - -import org.overture.ast.analysis.AnalysisException; -import org.overture.ast.assistant.IAstAssistant; -import org.overture.ast.intf.lex.ILexLocation; -import org.overture.ast.patterns.ASetBind; -import org.overture.ast.patterns.ATypeBind; -import org.overture.ast.statements.ATixeStmtAlternative; -import org.overture.interpreter.assistant.IInterpreterAssistantFactory; -import org.overture.interpreter.runtime.Context; -import org.overture.interpreter.runtime.PatternMatchException; -import org.overture.interpreter.runtime.ValueException; -import org.overture.interpreter.runtime.VdmRuntime; -import org.overture.interpreter.runtime.VdmRuntimeError; -import org.overture.interpreter.values.Value; -import org.overture.interpreter.values.ValueSet; - -public class ATixeStmtAlternativeAssistantInterpreter implements IAstAssistant -{ - protected static IInterpreterAssistantFactory af; - - @SuppressWarnings("static-access") - public ATixeStmtAlternativeAssistantInterpreter( - IInterpreterAssistantFactory af) - { - this.af = af; - } - - //FIXME only used once. inline it - public Value eval(ATixeStmtAlternative node, ILexLocation location, - Value exval, Context ctxt) throws AnalysisException - { - Context evalContext = null; - - try - { - if (node.getPatternBind().getPattern() != null) - { - evalContext = new Context(af, location, "tixe pattern", ctxt); - evalContext.putList(af.createPPatternAssistant().getNamedValues(node.getPatternBind().getPattern(), exval, ctxt)); - } else if (node.getPatternBind().getBind() instanceof ASetBind) - { - ASetBind setbind = (ASetBind) node.getPatternBind().getBind(); - ValueSet set = setbind.getSet().apply(VdmRuntime.getStatementEvaluator(), ctxt).setValue(ctxt); - - if (set.contains(exval)) - { - evalContext = new Context(af, location, "tixe set", ctxt); - evalContext.putList(af.createPPatternAssistant().getNamedValues(setbind.getPattern(), exval, ctxt)); - } else - { - VdmRuntimeError.abort(setbind.getLocation(), 4049, "Value " - + exval + " is not in set bind", ctxt); - } - } else - { - ATypeBind typebind = (ATypeBind) node.getPatternBind().getBind(); - // Note we always perform DTC checks here... - Value converted = exval.convertValueTo(typebind.getType(), ctxt); - evalContext = new Context(af, location, "tixe type", ctxt); - evalContext.putList(af.createPPatternAssistant().getNamedValues(typebind.getPattern(), converted, ctxt)); - } - } catch (ValueException ve) // Type bind convert failure - { - evalContext = null; - } catch (PatternMatchException e) - { - evalContext = null; - } - - return evalContext == null ? null - : node.getStatement().apply(VdmRuntime.getStatementEvaluator(), evalContext); - } - -} diff --git a/core/interpreter/src/main/java/org/overture/interpreter/eval/StatementEvaluator.java b/core/interpreter/src/main/java/org/overture/interpreter/eval/StatementEvaluator.java index 276696c796..32b0d8535b 100644 --- a/core/interpreter/src/main/java/org/overture/interpreter/eval/StatementEvaluator.java +++ b/core/interpreter/src/main/java/org/overture/interpreter/eval/StatementEvaluator.java @@ -896,7 +896,8 @@ public Value caseATixeStm(ATixeStm node, Context ctxt) { for (ATixeStmtAlternative tsa : node.getTraps()) { - rv = ctxt.assistantFactory.createATixeStmtAlternativeAssistant().eval(tsa, node.getLocation(), exval, ctxt); + rv = //ctxt.assistantFactory.createATixeStmtAlternativeAssistant(). + eval(tsa, node.getLocation(), exval, ctxt); if (rv != null) // Statement was executed { @@ -1384,5 +1385,50 @@ private Value evalBlock(SSimpleBlockStm node, Context ctxt) return new VoidValue(); } + + public Value eval(ATixeStmtAlternative node, ILexLocation location, + Value exval, Context ctxt) throws AnalysisException + { + Context evalContext = null; + + try + { + if (node.getPatternBind().getPattern() != null) + { + evalContext = new Context(ctxt.assistantFactory, location, "tixe pattern", ctxt); + evalContext.putList(ctxt.assistantFactory.createPPatternAssistant().getNamedValues(node.getPatternBind().getPattern(), exval, ctxt)); + } else if (node.getPatternBind().getBind() instanceof ASetBind) + { + ASetBind setbind = (ASetBind) node.getPatternBind().getBind(); + ValueSet set = setbind.getSet().apply(VdmRuntime.getStatementEvaluator(), ctxt).setValue(ctxt); + + if (set.contains(exval)) + { + evalContext = new Context(ctxt.assistantFactory, location, "tixe set", ctxt); + evalContext.putList(ctxt.assistantFactory.createPPatternAssistant().getNamedValues(setbind.getPattern(), exval, ctxt)); + } else + { + VdmRuntimeError.abort(setbind.getLocation(), 4049, "Value " + + exval + " is not in set bind", ctxt); + } + } else + { + ATypeBind typebind = (ATypeBind) node.getPatternBind().getBind(); + // Note we always perform DTC checks here... + Value converted = exval.convertValueTo(typebind.getType(), ctxt); + evalContext = new Context(ctxt.assistantFactory, location, "tixe type", ctxt); + evalContext.putList(ctxt.assistantFactory.createPPatternAssistant().getNamedValues(typebind.getPattern(), converted, ctxt)); + } + } catch (ValueException ve) // Type bind convert failure + { + evalContext = null; + } catch (PatternMatchException e) + { + evalContext = null; + } + + return evalContext == null ? null + : node.getStatement().apply(VdmRuntime.getStatementEvaluator(), evalContext); + } } From e88aca800dd87f128a3691a6ffc262b7b0d106ba Mon Sep 17 00:00:00 2001 From: gkanos Date: Wed, 25 Feb 2015 09:06:54 +0100 Subject: [PATCH 145/323] Fix me tags that was not left overs. --- .../overture/modelcheckers/probsolver/MapTests.java | 2 +- .../typechecker/utilities/PTypeFunctionChecker.java | 1 - .../utilities/type/TypeEqualityChecker.java | 12 ++++-------- 3 files changed, 5 insertions(+), 10 deletions(-) diff --git a/core/modelcheckers/probsolver/src/test/java/org/overture/modelcheckers/probsolver/MapTests.java b/core/modelcheckers/probsolver/src/test/java/org/overture/modelcheckers/probsolver/MapTests.java index a15edffc2e..1f979ed683 100644 --- a/core/modelcheckers/probsolver/src/test/java/org/overture/modelcheckers/probsolver/MapTests.java +++ b/core/modelcheckers/probsolver/src/test/java/org/overture/modelcheckers/probsolver/MapTests.java @@ -46,7 +46,7 @@ public static Collection getData() Collection tests = new LinkedList(); - tests.addAll(getTests(new File(root), "Map-0026"));//FIXME:What to fix? + tests.addAll(getTests(new File(root), "Map-0026")); return tests; } diff --git a/core/typechecker/src/main/java/org/overture/typechecker/utilities/PTypeFunctionChecker.java b/core/typechecker/src/main/java/org/overture/typechecker/utilities/PTypeFunctionChecker.java index ca82de0c63..9e683337e2 100644 --- a/core/typechecker/src/main/java/org/overture/typechecker/utilities/PTypeFunctionChecker.java +++ b/core/typechecker/src/main/java/org/overture/typechecker/utilities/PTypeFunctionChecker.java @@ -74,7 +74,6 @@ public Boolean defaultSInvariantType(SInvariantType node) } return ((ANamedInvariantType) node).getType().apply(THIS); // PTypeAssistantTC.isFunction(type.getType()); } - // FIXME:Added code from gkanos in order to return a value; I returned the default one. else { return false; diff --git a/core/typechecker/src/main/java/org/overture/typechecker/utilities/type/TypeEqualityChecker.java b/core/typechecker/src/main/java/org/overture/typechecker/utilities/type/TypeEqualityChecker.java index adfed3e859..672766ae85 100644 --- a/core/typechecker/src/main/java/org/overture/typechecker/utilities/type/TypeEqualityChecker.java +++ b/core/typechecker/src/main/java/org/overture/typechecker/utilities/type/TypeEqualityChecker.java @@ -98,10 +98,8 @@ public Boolean caseAFunctionType(AFunctionType type, Object other) } AFunctionType fo = (AFunctionType) other; - return type.getPartial() == fo.getPartial() && // FIXME:The Below statement doesn't work correct. I cannot Apply - // with this syntax. - type.getResult().apply(this, fo.getResult()) && // type.getParameters().apply(this,fo.getParameters())); - // PTypeAssistantTC.equals(type.getResult(),fo.getResult()) && + return type.getPartial() == fo.getPartial() && + type.getResult().apply(this, fo.getResult()) && af.createPTypeAssistant().equals(type.getParameters(), fo.getParameters()); } @@ -152,7 +150,7 @@ public Boolean defaultSMapType(SMapType type, Object other) // return PTypeAssistantTC.equals(type.getFrom(),mt.getFrom()) && PTypeAssistantTC.equals(type.getTo(), // mt.getTo()); return type.getFrom().apply(this, mt.getFrom()) - && type.getTo().apply(this, mt.getTo()); // FIXME:The same problem here. THIS doesn't seem to work. + && type.getTo().apply(this, mt.getTo()); } return false; @@ -172,9 +170,7 @@ public Boolean caseAOperationType(AOperationType type, Object other) AOperationType oother = (AOperationType) other; return type.getResult().apply(this, oother.getResult()) && af.createPTypeAssistant().equals(type.getParameters(), oother.getParameters()); - // FIXME:The above statement cannot be changed to apply form. - // PTypeAssistantTC.equals(type.getResult(),oother.getResult()) && - // PTypeAssistantTC.equals(type.getParameters(), oother.getParameters())); + } @Override From c27b27f094cf70cb364c066d618c856fc7499bbf Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Thu, 26 Feb 2015 13:55:33 +0100 Subject: [PATCH 146/323] Improved the output of the Java code generator when it encounters unexpected errors --- .../ide/plugins/codegen/commands/Vdm2JavaCommand.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaCommand.java b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaCommand.java index 72f32135df..926c977494 100644 --- a/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaCommand.java +++ b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaCommand.java @@ -473,12 +473,12 @@ private void outputQuotes(IVdmProject vdmProject, File outputFolder, private void handleUnexpectedException(Exception ex) { - String errorMessage = "Unexpected exception caught when attempting to code generate VDM model."; + String errorMessage = + "Unexpected problem encountered when attempting to code generate the VDM model.\n" + + "The details of this problem have been reported in the Error Log."; Activator.log(errorMessage, ex); - - CodeGenConsole.GetInstance().println(errorMessage); - CodeGenConsole.GetInstance().println(ex.getMessage()); + CodeGenConsole.GetInstance().printErrorln(errorMessage); ex.printStackTrace(); } From 98ee1103fd7ce3dc97e38b644d4befd88ee8b48e Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Thu, 26 Feb 2015 13:53:43 +0100 Subject: [PATCH 147/323] [maven-release-plugin] prepare for next development iteration --- core/ast/pom.xml | 2 +- core/codegen-runtime/pom.xml | 2 +- core/codegen/pom.xml | 2 +- core/combinatorialtesting/ctruntime/pom.xml | 2 +- core/combinatorialtesting/ctutils/pom.xml | 2 +- core/combinatorialtesting/pom.xml | 2 +- core/commandline/pom.xml | 2 +- core/guibuilder/pom.xml | 2 +- core/interpreter/pom.xml | 2 +- core/modelcheckers/pom.xml | 2 +- core/modelcheckers/probsolver/pom.xml | 2 +- core/modelcheckers/probsolverintegration/pom.xml | 2 +- core/parser/pom.xml | 2 +- core/pog/pom.xml | 2 +- core/pom.xml | 2 +- core/prettyprinting/npp/pom.xml | 2 +- core/prettyprinting/pom.xml | 2 +- core/prettyprinting/prettyprinter/pom.xml | 2 +- core/testframework/pom.xml | 2 +- core/testing/exsupport/pom.xml | 2 +- core/testing/extests/pom.xml | 2 +- core/testing/framework/pom.xml | 2 +- core/testing/pom.xml | 2 +- core/testing/tests/pom.xml | 2 +- core/typechecker/pom.xml | 2 +- core/vdmjc/pom.xml | 2 +- externals/documentation/pom.xml | 2 +- externals/examples/pom.xml | 2 +- externals/pom.xml | 2 +- pom.xml | 4 ++-- 30 files changed, 31 insertions(+), 31 deletions(-) diff --git a/core/ast/pom.xml b/core/ast/pom.xml index b7eb5cf946..196e55a482 100644 --- a/core/ast/pom.xml +++ b/core/ast/pom.xml @@ -4,7 +4,7 @@ org.overturetool core - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/core/codegen-runtime/pom.xml b/core/codegen-runtime/pom.xml index a7385e8cf2..e2c998a53f 100644 --- a/core/codegen-runtime/pom.xml +++ b/core/codegen-runtime/pom.xml @@ -4,7 +4,7 @@ org.overturetool core - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/core/codegen/pom.xml b/core/codegen/pom.xml index 7eef63c03a..2a3ce708cc 100644 --- a/core/codegen/pom.xml +++ b/core/codegen/pom.xml @@ -4,7 +4,7 @@ org.overturetool core - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/core/combinatorialtesting/ctruntime/pom.xml b/core/combinatorialtesting/ctruntime/pom.xml index c298804a73..7434e84874 100644 --- a/core/combinatorialtesting/ctruntime/pom.xml +++ b/core/combinatorialtesting/ctruntime/pom.xml @@ -4,7 +4,7 @@ org.overturetool.core combinatorialtesting - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/core/combinatorialtesting/ctutils/pom.xml b/core/combinatorialtesting/ctutils/pom.xml index 9cc9f4ef21..a2e99c9531 100644 --- a/core/combinatorialtesting/ctutils/pom.xml +++ b/core/combinatorialtesting/ctutils/pom.xml @@ -4,7 +4,7 @@ org.overturetool.core combinatorialtesting - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/core/combinatorialtesting/pom.xml b/core/combinatorialtesting/pom.xml index 5a07c129a3..54c9a7912c 100644 --- a/core/combinatorialtesting/pom.xml +++ b/core/combinatorialtesting/pom.xml @@ -4,7 +4,7 @@ core org.overturetool - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/core/commandline/pom.xml b/core/commandline/pom.xml index 215e92ad17..70f309d376 100644 --- a/core/commandline/pom.xml +++ b/core/commandline/pom.xml @@ -4,7 +4,7 @@ org.overturetool core - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/core/guibuilder/pom.xml b/core/guibuilder/pom.xml index ee8e36d670..905189b2fc 100644 --- a/core/guibuilder/pom.xml +++ b/core/guibuilder/pom.xml @@ -4,7 +4,7 @@ org.overturetool core - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/core/interpreter/pom.xml b/core/interpreter/pom.xml index 71f845f80d..efe21ca7f8 100644 --- a/core/interpreter/pom.xml +++ b/core/interpreter/pom.xml @@ -4,7 +4,7 @@ org.overturetool core - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/core/modelcheckers/pom.xml b/core/modelcheckers/pom.xml index 1213a0baf7..1b5d47cfdc 100644 --- a/core/modelcheckers/pom.xml +++ b/core/modelcheckers/pom.xml @@ -4,7 +4,7 @@ org.overturetool core - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/core/modelcheckers/probsolver/pom.xml b/core/modelcheckers/probsolver/pom.xml index 6b8980f532..b2447e83aa 100644 --- a/core/modelcheckers/probsolver/pom.xml +++ b/core/modelcheckers/probsolver/pom.xml @@ -4,7 +4,7 @@ org.overturetool.core modelcheckers - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/core/modelcheckers/probsolverintegration/pom.xml b/core/modelcheckers/probsolverintegration/pom.xml index 6d27874be3..221ef2fb0e 100644 --- a/core/modelcheckers/probsolverintegration/pom.xml +++ b/core/modelcheckers/probsolverintegration/pom.xml @@ -4,7 +4,7 @@ org.overturetool.core modelcheckers - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/core/parser/pom.xml b/core/parser/pom.xml index aed18c08cd..58dc06d503 100644 --- a/core/parser/pom.xml +++ b/core/parser/pom.xml @@ -4,7 +4,7 @@ org.overturetool core - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/core/pog/pom.xml b/core/pog/pom.xml index c377954970..a62efa5d45 100644 --- a/core/pog/pom.xml +++ b/core/pog/pom.xml @@ -4,7 +4,7 @@ org.overturetool core - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/core/pom.xml b/core/pom.xml index 12d1dbd2eb..9951317e59 100644 --- a/core/pom.xml +++ b/core/pom.xml @@ -4,7 +4,7 @@ org.overturetool root - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/core/prettyprinting/npp/pom.xml b/core/prettyprinting/npp/pom.xml index f5af905ec1..90a94a4b08 100644 --- a/core/prettyprinting/npp/pom.xml +++ b/core/prettyprinting/npp/pom.xml @@ -4,7 +4,7 @@ org.overturetool.core prettyprinting - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/core/prettyprinting/pom.xml b/core/prettyprinting/pom.xml index 8d2beb21fe..e442073170 100644 --- a/core/prettyprinting/pom.xml +++ b/core/prettyprinting/pom.xml @@ -4,7 +4,7 @@ org.overturetool core - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/core/prettyprinting/prettyprinter/pom.xml b/core/prettyprinting/prettyprinter/pom.xml index 819e34ed88..0b24703368 100644 --- a/core/prettyprinting/prettyprinter/pom.xml +++ b/core/prettyprinting/prettyprinter/pom.xml @@ -4,7 +4,7 @@ org.overturetool.core prettyprinting - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/core/testframework/pom.xml b/core/testframework/pom.xml index fcb6ad3770..226aa73404 100644 --- a/core/testframework/pom.xml +++ b/core/testframework/pom.xml @@ -4,7 +4,7 @@ org.overturetool core - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/core/testing/exsupport/pom.xml b/core/testing/exsupport/pom.xml index f859a3449a..24e9921476 100644 --- a/core/testing/exsupport/pom.xml +++ b/core/testing/exsupport/pom.xml @@ -4,7 +4,7 @@ org.overturetool.core testing - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/core/testing/extests/pom.xml b/core/testing/extests/pom.xml index b1691df297..28adfc1f3e 100644 --- a/core/testing/extests/pom.xml +++ b/core/testing/extests/pom.xml @@ -4,7 +4,7 @@ org.overturetool.core testing - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/core/testing/framework/pom.xml b/core/testing/framework/pom.xml index 4799aad591..52787a950e 100644 --- a/core/testing/framework/pom.xml +++ b/core/testing/framework/pom.xml @@ -4,7 +4,7 @@ org.overturetool.core testing - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/core/testing/pom.xml b/core/testing/pom.xml index fdcd45eeb4..91fb7b4ac2 100644 --- a/core/testing/pom.xml +++ b/core/testing/pom.xml @@ -4,7 +4,7 @@ org.overturetool core - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/core/testing/tests/pom.xml b/core/testing/tests/pom.xml index d09890b45d..4c7d34d55b 100644 --- a/core/testing/tests/pom.xml +++ b/core/testing/tests/pom.xml @@ -4,7 +4,7 @@ org.overturetool.core testing - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/core/typechecker/pom.xml b/core/typechecker/pom.xml index e1f25210bd..6a08344408 100644 --- a/core/typechecker/pom.xml +++ b/core/typechecker/pom.xml @@ -4,7 +4,7 @@ org.overturetool core - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/core/vdmjc/pom.xml b/core/vdmjc/pom.xml index 37deb29acd..69545523d6 100644 --- a/core/vdmjc/pom.xml +++ b/core/vdmjc/pom.xml @@ -4,7 +4,7 @@ core org.overturetool - 2.2.2 + 2.2.3-SNAPSHOT org.overturetool.core diff --git a/externals/documentation/pom.xml b/externals/documentation/pom.xml index 97fa0b26d2..499d552f7b 100644 --- a/externals/documentation/pom.xml +++ b/externals/documentation/pom.xml @@ -4,7 +4,7 @@ org.overturetool externals - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/externals/examples/pom.xml b/externals/examples/pom.xml index 9da1424a57..d6834c48e8 100644 --- a/externals/examples/pom.xml +++ b/externals/examples/pom.xml @@ -4,7 +4,7 @@ org.overturetool externals - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/externals/pom.xml b/externals/pom.xml index f23978a0a9..80435003b0 100644 --- a/externals/pom.xml +++ b/externals/pom.xml @@ -4,7 +4,7 @@ org.overturetool root - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/pom.xml b/pom.xml index 06337f2cf6..1c35bd2a77 100644 --- a/pom.xml +++ b/pom.xml @@ -13,7 +13,7 @@ org.overturetool root - 2.2.2 + 2.2.3-SNAPSHOT The Overture Tool Platform root @@ -302,7 +302,7 @@ git@github.com:overturetool/overture.git scm:git:git://github.com/overturetool/overture.git scm:git:git@github.com:overturetool/overture.git - Release/2.2.2 + HEAD From d384663ae8d80fb98f5ee57effe6f7da9bd9b494 Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Thu, 26 Feb 2015 19:07:33 +0100 Subject: [PATCH 148/323] Bump ide/ to version 2.2.3-SNAPSHOT --- ide/builders/pom.xml | 2 +- ide/builders/vdmj/META-INF/MANIFEST.MF | 2 +- ide/builders/vdmj/pom.xml | 2 +- ide/core/META-INF/MANIFEST.MF | 2 +- ide/core/pom.xml | 2 +- ide/debug/META-INF/MANIFEST.MF | 2 +- ide/debug/pom.xml | 2 +- ide/features/core/feature.xml | 2 +- ide/features/core/pom.xml | 2 +- ide/features/pom.xml | 2 +- ide/features/rcp/feature.xml | 2 +- ide/features/rcp/pom.xml | 2 +- ide/help/META-INF/MANIFEST.MF | 2 +- ide/help/pom.xml | 2 +- ide/parsers/pom.xml | 2 +- ide/parsers/vdmj/META-INF/MANIFEST.MF | 2 +- ide/parsers/vdmj/pom.xml | 2 +- ide/platform/META-INF/MANIFEST.MF | 2 +- ide/platform/pom.xml | 2 +- ide/plugins/codegen/META-INF/MANIFEST.MF | 2 +- ide/plugins/codegen/pom.xml | 2 +- ide/plugins/combinatorialtesting/META-INF/MANIFEST.MF | 2 +- ide/plugins/combinatorialtesting/pom.xml | 2 +- ide/plugins/coverageeditor/META-INF/MANIFEST.MF | 2 +- ide/plugins/coverageeditor/pom.xml | 2 +- ide/plugins/csk/META-INF/MANIFEST.MF | 2 +- ide/plugins/csk/pom.xml | 2 +- ide/plugins/developerutils/META-INF/MANIFEST.MF | 2 +- ide/plugins/developerutils/pom.xml | 2 +- ide/plugins/externaleditor/META-INF/MANIFEST.MF | 2 +- ide/plugins/externaleditor/pom.xml | 2 +- ide/plugins/features/codegen/feature.xml | 2 +- ide/plugins/features/codegen/pom.xml | 2 +- ide/plugins/features/combinatorialtesting/feature.xml | 2 +- ide/plugins/features/combinatorialtesting/pom.xml | 2 +- ide/plugins/features/coverageeditor/feature.xml | 2 +- ide/plugins/features/coverageeditor/pom.xml | 2 +- ide/plugins/features/csk/feature.xml | 2 +- ide/plugins/features/csk/pom.xml | 2 +- ide/plugins/features/developerutils/feature.xml | 2 +- ide/plugins/features/developerutils/pom.xml | 2 +- ide/plugins/features/guibuilder/feature.xml | 2 +- ide/plugins/features/guibuilder/pom.xml | 2 +- ide/plugins/features/latex/feature.xml | 2 +- ide/plugins/features/latex/pom.xml | 2 +- ide/plugins/features/pom.xml | 2 +- ide/plugins/features/poviewer/feature.xml | 2 +- ide/plugins/features/poviewer/pom.xml | 2 +- ide/plugins/features/probruntime/feature.xml | 2 +- ide/plugins/features/probruntime/pom.xml | 2 +- ide/plugins/features/quickinterpreter/feature.xml | 2 +- ide/plugins/features/quickinterpreter/pom.xml | 2 +- ide/plugins/features/rttraceviewer/feature.xml | 2 +- ide/plugins/features/rttraceviewer/pom.xml | 2 +- ide/plugins/features/uml2/feature.xml | 2 +- ide/plugins/features/uml2/pom.xml | 2 +- ide/plugins/guibuilder/META-INF/MANIFEST.MF | 2 +- ide/plugins/guibuilder/pom.xml | 2 +- ide/plugins/latex/META-INF/MANIFEST.MF | 2 +- ide/plugins/latex/pom.xml | 2 +- ide/plugins/pom.xml | 2 +- ide/plugins/poviewer/META-INF/MANIFEST.MF | 2 +- ide/plugins/poviewer/pom.xml | 2 +- ide/plugins/prob-runtime/core/META-INF/MANIFEST.MF | 2 +- ide/plugins/prob-runtime/core/pom.xml | 2 +- ide/plugins/prob-runtime/linux.x86/META-INF/MANIFEST.MF | 2 +- ide/plugins/prob-runtime/linux.x86/pom.xml | 2 +- ide/plugins/prob-runtime/linux.x86_64/META-INF/MANIFEST.MF | 2 +- ide/plugins/prob-runtime/linux.x86_64/pom.xml | 2 +- ide/plugins/prob-runtime/macosx.x86_64/META-INF/MANIFEST.MF | 2 +- ide/plugins/prob-runtime/macosx.x86_64/pom.xml | 2 +- ide/plugins/prob-runtime/pom.xml | 2 +- ide/plugins/prob-runtime/win32.win32/META-INF/MANIFEST.MF | 2 +- ide/plugins/prob-runtime/win32.win32/pom.xml | 2 +- ide/plugins/quickinterpreter/META-INF/MANIFEST.MF | 2 +- ide/plugins/quickinterpreter/pom.xml | 2 +- ide/plugins/rttraceviewer/META-INF/MANIFEST.MF | 2 +- ide/plugins/rttraceviewer/pom.xml | 2 +- ide/plugins/uml2.tests/META-INF/MANIFEST.MF | 2 +- ide/plugins/uml2.tests/pom.xml | 2 +- ide/plugins/uml2/META-INF/MANIFEST.MF | 2 +- ide/plugins/uml2/pom.xml | 2 +- ide/pom.xml | 5 ++--- ide/product/overture.product | 2 +- ide/product/pom.xml | 2 +- ide/tests/pom.xml | 2 +- ide/tests/ui/META-INF/MANIFEST.MF | 2 +- ide/tests/ui/pom.xml | 2 +- ide/ui/META-INF/MANIFEST.MF | 2 +- ide/ui/pom.xml | 2 +- ide/vdmpp/core/META-INF/MANIFEST.MF | 2 +- ide/vdmpp/core/pom.xml | 2 +- ide/vdmpp/debug/META-INF/MANIFEST.MF | 2 +- ide/vdmpp/debug/pom.xml | 2 +- ide/vdmpp/pom.xml | 2 +- ide/vdmpp/ui/META-INF/MANIFEST.MF | 2 +- ide/vdmpp/ui/pom.xml | 2 +- ide/vdmrt/core/META-INF/MANIFEST.MF | 2 +- ide/vdmrt/core/pom.xml | 2 +- ide/vdmrt/debug/META-INF/MANIFEST.MF | 2 +- ide/vdmrt/debug/pom.xml | 2 +- ide/vdmrt/pom.xml | 2 +- ide/vdmrt/ui/META-INF/MANIFEST.MF | 2 +- ide/vdmrt/ui/pom.xml | 2 +- ide/vdmsl/core/META-INF/MANIFEST.MF | 2 +- ide/vdmsl/core/pom.xml | 2 +- ide/vdmsl/debug/META-INF/MANIFEST.MF | 2 +- ide/vdmsl/debug/pom.xml | 2 +- ide/vdmsl/pom.xml | 2 +- ide/vdmsl/ui/META-INF/MANIFEST.MF | 2 +- ide/vdmsl/ui/pom.xml | 2 +- 111 files changed, 112 insertions(+), 113 deletions(-) diff --git a/ide/builders/pom.xml b/ide/builders/pom.xml index 63fb61f2ce..ab3450d404 100644 --- a/ide/builders/pom.xml +++ b/ide/builders/pom.xml @@ -5,7 +5,7 @@ org.overturetool ide - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/builders/vdmj/META-INF/MANIFEST.MF b/ide/builders/vdmj/META-INF/MANIFEST.MF index ab1b11ea4d..7dc4c22e90 100644 --- a/ide/builders/vdmj/META-INF/MANIFEST.MF +++ b/ide/builders/vdmj/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.2 +Bundle-Version: 2.2.3.qualifier Eclipse-BuddyPolicy: registered Eclipse-BundleShape: dir Bundle-Localization: plugin diff --git a/ide/builders/vdmj/pom.xml b/ide/builders/vdmj/pom.xml index f16b05858f..078f8b6985 100644 --- a/ide/builders/vdmj/pom.xml +++ b/ide/builders/vdmj/pom.xml @@ -4,7 +4,7 @@ org.overturetool.ide org.overture.ide.builders - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/core/META-INF/MANIFEST.MF b/ide/core/META-INF/MANIFEST.MF index 5661135d34..7dec713e2f 100644 --- a/ide/core/META-INF/MANIFEST.MF +++ b/ide/core/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.2 +Bundle-Version: 2.2.3.qualifier Eclipse-BuddyPolicy: registered Eclipse-BundleShape: dir Bundle-Localization: plugin diff --git a/ide/core/pom.xml b/ide/core/pom.xml index 611ddbab99..dcccf1fe5c 100644 --- a/ide/core/pom.xml +++ b/ide/core/pom.xml @@ -5,7 +5,7 @@ org.overturetool ide - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/debug/META-INF/MANIFEST.MF b/ide/debug/META-INF/MANIFEST.MF index 20b83b6ec6..4f47467b28 100644 --- a/ide/debug/META-INF/MANIFEST.MF +++ b/ide/debug/META-INF/MANIFEST.MF @@ -1,6 +1,6 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture -Bundle-Version: 2.2.2 +Bundle-Version: 2.2.3.qualifier Eclipse-BuddyPolicy: registered Eclipse-BundleShape: dir Bundle-Localization: plugin diff --git a/ide/debug/pom.xml b/ide/debug/pom.xml index d33ce6605d..e6fe5fd056 100644 --- a/ide/debug/pom.xml +++ b/ide/debug/pom.xml @@ -5,7 +5,7 @@ org.overturetool ide - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/features/core/feature.xml b/ide/features/core/feature.xml index 93f9693d66..bf1961bf55 100644 --- a/ide/features/core/feature.xml +++ b/ide/features/core/feature.xml @@ -2,7 +2,7 @@ diff --git a/ide/features/core/pom.xml b/ide/features/core/pom.xml index 0fcdfe5b45..cbbd6b3b5d 100644 --- a/ide/features/core/pom.xml +++ b/ide/features/core/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide features - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/features/pom.xml b/ide/features/pom.xml index 8e78cd4009..ca9cbeef0d 100644 --- a/ide/features/pom.xml +++ b/ide/features/pom.xml @@ -5,7 +5,7 @@ org.overturetool ide - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/features/rcp/feature.xml b/ide/features/rcp/feature.xml index 9a5a333c3b..047a34efd0 100644 --- a/ide/features/rcp/feature.xml +++ b/ide/features/rcp/feature.xml @@ -2,7 +2,7 @@ + version="2.2.3.qualifier"> %description diff --git a/ide/features/rcp/pom.xml b/ide/features/rcp/pom.xml index be9e2b65d4..f1092bb0c5 100644 --- a/ide/features/rcp/pom.xml +++ b/ide/features/rcp/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide features - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/help/META-INF/MANIFEST.MF b/ide/help/META-INF/MANIFEST.MF index 7b0198faa3..716d6003d2 100644 --- a/ide/help/META-INF/MANIFEST.MF +++ b/ide/help/META-INF/MANIFEST.MF @@ -1,6 +1,6 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture -Bundle-Version: 2.2.2 +Bundle-Version: 2.2.3.qualifier Eclipse-BuddyPolicy: registered Eclipse-BundleShape: dir Bundle-Localization: plugin diff --git a/ide/help/pom.xml b/ide/help/pom.xml index af0a77c6fb..7540946221 100644 --- a/ide/help/pom.xml +++ b/ide/help/pom.xml @@ -5,7 +5,7 @@ org.overturetool ide - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/parsers/pom.xml b/ide/parsers/pom.xml index 0bb7b6c976..c23e6d5048 100644 --- a/ide/parsers/pom.xml +++ b/ide/parsers/pom.xml @@ -5,7 +5,7 @@ org.overturetool ide - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/parsers/vdmj/META-INF/MANIFEST.MF b/ide/parsers/vdmj/META-INF/MANIFEST.MF index a4387d3d9c..8be8e927fb 100644 --- a/ide/parsers/vdmj/META-INF/MANIFEST.MF +++ b/ide/parsers/vdmj/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.2 +Bundle-Version: 2.2.3.qualifier Eclipse-BuddyPolicy: registered Bundle-Localization: plugin Bundle-Name: org.overture.ide.parsers.vdmj diff --git a/ide/parsers/vdmj/pom.xml b/ide/parsers/vdmj/pom.xml index 8367e3ce11..32c3e37e4b 100644 --- a/ide/parsers/vdmj/pom.xml +++ b/ide/parsers/vdmj/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide org.overture.ide.parsers - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/platform/META-INF/MANIFEST.MF b/ide/platform/META-INF/MANIFEST.MF index 714967b0a4..d5bee844ee 100644 --- a/ide/platform/META-INF/MANIFEST.MF +++ b/ide/platform/META-INF/MANIFEST.MF @@ -2,7 +2,7 @@ Manifest-Version: 1.0 Bundle-ManifestVersion: 2 Bundle-Name: org.overture.ide.platform Bundle-SymbolicName: org.overture.ide.platform;singleton:=true -Bundle-Version: 2.2.2 +Bundle-Version: 2.2.3.qualifier Bundle-Localization: plugin Require-Bundle: org.eclipse.core.runtime, org.eclipse.ui, diff --git a/ide/platform/pom.xml b/ide/platform/pom.xml index e5b80cd368..59062d8cad 100644 --- a/ide/platform/pom.xml +++ b/ide/platform/pom.xml @@ -5,7 +5,7 @@ org.overturetool ide - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/plugins/codegen/META-INF/MANIFEST.MF b/ide/plugins/codegen/META-INF/MANIFEST.MF index fd5065243a..a85ac6ea4b 100644 --- a/ide/plugins/codegen/META-INF/MANIFEST.MF +++ b/ide/plugins/codegen/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.2 +Bundle-Version: 2.2.3.qualifier Eclipse-BuddyPolicy: registered Bundle-Name: Code Generator Bundle-ManifestVersion: 2 diff --git a/ide/plugins/codegen/pom.xml b/ide/plugins/codegen/pom.xml index 61638f7664..8e45a04d2b 100644 --- a/ide/plugins/codegen/pom.xml +++ b/ide/plugins/codegen/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide org.overture.ide.plugins - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/plugins/combinatorialtesting/META-INF/MANIFEST.MF b/ide/plugins/combinatorialtesting/META-INF/MANIFEST.MF index fe77506e7b..5639a98d9f 100644 --- a/ide/plugins/combinatorialtesting/META-INF/MANIFEST.MF +++ b/ide/plugins/combinatorialtesting/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.2 +Bundle-Version: 2.2.3.qualifier Eclipse-BuddyPolicy: registered Eclipse-BundleShape: dir Bundle-Localization: plugin diff --git a/ide/plugins/combinatorialtesting/pom.xml b/ide/plugins/combinatorialtesting/pom.xml index a7b743723a..d3725214d9 100644 --- a/ide/plugins/combinatorialtesting/pom.xml +++ b/ide/plugins/combinatorialtesting/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide org.overture.ide.plugins - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/plugins/coverageeditor/META-INF/MANIFEST.MF b/ide/plugins/coverageeditor/META-INF/MANIFEST.MF index a23aba0b6f..be0332fc49 100644 --- a/ide/plugins/coverageeditor/META-INF/MANIFEST.MF +++ b/ide/plugins/coverageeditor/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.2 +Bundle-Version: 2.2.3.qualifier Eclipse-BuddyPolicy: registered Bundle-Localization: plugin Bundle-Name: org.overture.ide.plugins.coverageeditor diff --git a/ide/plugins/coverageeditor/pom.xml b/ide/plugins/coverageeditor/pom.xml index 81fdc83175..2948efec9b 100644 --- a/ide/plugins/coverageeditor/pom.xml +++ b/ide/plugins/coverageeditor/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide org.overture.ide.plugins - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/plugins/csk/META-INF/MANIFEST.MF b/ide/plugins/csk/META-INF/MANIFEST.MF index a17e91e2a6..a70eb94587 100644 --- a/ide/plugins/csk/META-INF/MANIFEST.MF +++ b/ide/plugins/csk/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.2 +Bundle-Version: 2.2.3.qualifier Eclipse-BuddyPolicy: registered Bundle-Localization: plugin Bundle-Name: org.overture.ide.plugins.csk diff --git a/ide/plugins/csk/pom.xml b/ide/plugins/csk/pom.xml index 47215b75cf..c45e5b2bcd 100644 --- a/ide/plugins/csk/pom.xml +++ b/ide/plugins/csk/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide org.overture.ide.plugins - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/plugins/developerutils/META-INF/MANIFEST.MF b/ide/plugins/developerutils/META-INF/MANIFEST.MF index b8f031d046..b147f6eda3 100644 --- a/ide/plugins/developerutils/META-INF/MANIFEST.MF +++ b/ide/plugins/developerutils/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.2 +Bundle-Version: 2.2.3.qualifier Eclipse-BuddyPolicy: registered Bundle-Localization: plugin Bundle-Name: Developer Utilities for Overture diff --git a/ide/plugins/developerutils/pom.xml b/ide/plugins/developerutils/pom.xml index 80d94f4bc6..54d799bdbb 100644 --- a/ide/plugins/developerutils/pom.xml +++ b/ide/plugins/developerutils/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide org.overture.ide.plugins - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/plugins/externaleditor/META-INF/MANIFEST.MF b/ide/plugins/externaleditor/META-INF/MANIFEST.MF index 4b42f397e0..561cdd79b8 100644 --- a/ide/plugins/externaleditor/META-INF/MANIFEST.MF +++ b/ide/plugins/externaleditor/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.2 +Bundle-Version: 2.2.3.qualifier Eclipse-BuddyPolicy: registered Bundle-Localization: plugin Bundle-Name: org.overture.ide.plugins.externaleditor diff --git a/ide/plugins/externaleditor/pom.xml b/ide/plugins/externaleditor/pom.xml index 8bace15f06..c1fcc3acc5 100644 --- a/ide/plugins/externaleditor/pom.xml +++ b/ide/plugins/externaleditor/pom.xml @@ -4,7 +4,7 @@ org.overturetool.ide org.overture.ide.plugins - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/plugins/features/codegen/feature.xml b/ide/plugins/features/codegen/feature.xml index 40e0b95a1e..e758786ad1 100644 --- a/ide/plugins/features/codegen/feature.xml +++ b/ide/plugins/features/codegen/feature.xml @@ -2,7 +2,7 @@ + version="2.2.3.qualifier"> %description diff --git a/ide/plugins/features/codegen/pom.xml b/ide/plugins/features/codegen/pom.xml index f518fe50a4..a3038d9b09 100644 --- a/ide/plugins/features/codegen/pom.xml +++ b/ide/plugins/features/codegen/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide.plugins org.overture.ide.plugins.features - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/plugins/features/combinatorialtesting/feature.xml b/ide/plugins/features/combinatorialtesting/feature.xml index 2f678e6ca1..f59147ebc2 100644 --- a/ide/plugins/features/combinatorialtesting/feature.xml +++ b/ide/plugins/features/combinatorialtesting/feature.xml @@ -2,7 +2,7 @@ + version="2.2.3.qualifier"> %description diff --git a/ide/plugins/features/combinatorialtesting/pom.xml b/ide/plugins/features/combinatorialtesting/pom.xml index 96931aedaf..bcb356d3f7 100644 --- a/ide/plugins/features/combinatorialtesting/pom.xml +++ b/ide/plugins/features/combinatorialtesting/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide.plugins org.overture.ide.plugins.features - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/plugins/features/coverageeditor/feature.xml b/ide/plugins/features/coverageeditor/feature.xml index 113422d83a..0b558bff3e 100644 --- a/ide/plugins/features/coverageeditor/feature.xml +++ b/ide/plugins/features/coverageeditor/feature.xml @@ -2,7 +2,7 @@ + version="2.2.3.qualifier"> %description diff --git a/ide/plugins/features/coverageeditor/pom.xml b/ide/plugins/features/coverageeditor/pom.xml index a3c0329a96..7fc99f6748 100644 --- a/ide/plugins/features/coverageeditor/pom.xml +++ b/ide/plugins/features/coverageeditor/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide.plugins org.overture.ide.plugins.features - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/plugins/features/csk/feature.xml b/ide/plugins/features/csk/feature.xml index 2019088f6b..8a7b3e4900 100644 --- a/ide/plugins/features/csk/feature.xml +++ b/ide/plugins/features/csk/feature.xml @@ -2,7 +2,7 @@ + version="2.2.3.qualifier"> %description diff --git a/ide/plugins/features/csk/pom.xml b/ide/plugins/features/csk/pom.xml index 8fa7b8eb7c..aa28c0ae37 100644 --- a/ide/plugins/features/csk/pom.xml +++ b/ide/plugins/features/csk/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide.plugins org.overture.ide.plugins.features - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/plugins/features/developerutils/feature.xml b/ide/plugins/features/developerutils/feature.xml index 3c12b3ecdb..44f6231a7d 100644 --- a/ide/plugins/features/developerutils/feature.xml +++ b/ide/plugins/features/developerutils/feature.xml @@ -2,7 +2,7 @@ + version="2.2.3.qualifier"> %description diff --git a/ide/plugins/features/developerutils/pom.xml b/ide/plugins/features/developerutils/pom.xml index 20b3fc56aa..3067534697 100644 --- a/ide/plugins/features/developerutils/pom.xml +++ b/ide/plugins/features/developerutils/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide.plugins org.overture.ide.plugins.features - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/plugins/features/guibuilder/feature.xml b/ide/plugins/features/guibuilder/feature.xml index 23122ced4a..9c190f4044 100644 --- a/ide/plugins/features/guibuilder/feature.xml +++ b/ide/plugins/features/guibuilder/feature.xml @@ -2,7 +2,7 @@ + version="2.2.3.qualifier"> %description diff --git a/ide/plugins/features/guibuilder/pom.xml b/ide/plugins/features/guibuilder/pom.xml index a6b5e43c59..d03312a201 100644 --- a/ide/plugins/features/guibuilder/pom.xml +++ b/ide/plugins/features/guibuilder/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide.plugins org.overture.ide.plugins.features - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/plugins/features/latex/feature.xml b/ide/plugins/features/latex/feature.xml index c70c4b83cd..b859700acf 100644 --- a/ide/plugins/features/latex/feature.xml +++ b/ide/plugins/features/latex/feature.xml @@ -2,7 +2,7 @@ + version="2.2.3.qualifier"> %description diff --git a/ide/plugins/features/latex/pom.xml b/ide/plugins/features/latex/pom.xml index 4507e9e2c1..c9d9a2a553 100644 --- a/ide/plugins/features/latex/pom.xml +++ b/ide/plugins/features/latex/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide.plugins org.overture.ide.plugins.features - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/plugins/features/pom.xml b/ide/plugins/features/pom.xml index c8762f2d1d..b5ea48a30e 100644 --- a/ide/plugins/features/pom.xml +++ b/ide/plugins/features/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide org.overture.ide.plugins - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/plugins/features/poviewer/feature.xml b/ide/plugins/features/poviewer/feature.xml index b465b49670..567feb0d98 100644 --- a/ide/plugins/features/poviewer/feature.xml +++ b/ide/plugins/features/poviewer/feature.xml @@ -2,7 +2,7 @@ + version="2.2.3.qualifier"> %description diff --git a/ide/plugins/features/poviewer/pom.xml b/ide/plugins/features/poviewer/pom.xml index 113e280eba..b209409431 100644 --- a/ide/plugins/features/poviewer/pom.xml +++ b/ide/plugins/features/poviewer/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide.plugins org.overture.ide.plugins.features - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/plugins/features/probruntime/feature.xml b/ide/plugins/features/probruntime/feature.xml index 2f2128226d..94355db3e5 100644 --- a/ide/plugins/features/probruntime/feature.xml +++ b/ide/plugins/features/probruntime/feature.xml @@ -2,7 +2,7 @@ diff --git a/ide/plugins/features/probruntime/pom.xml b/ide/plugins/features/probruntime/pom.xml index b907745d9e..9de8b7a6e1 100644 --- a/ide/plugins/features/probruntime/pom.xml +++ b/ide/plugins/features/probruntime/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide.plugins org.overture.ide.plugins.features - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/plugins/features/quickinterpreter/feature.xml b/ide/plugins/features/quickinterpreter/feature.xml index f4b39a3a93..9d5b15d94d 100644 --- a/ide/plugins/features/quickinterpreter/feature.xml +++ b/ide/plugins/features/quickinterpreter/feature.xml @@ -2,7 +2,7 @@ + version="2.2.3.qualifier"> %description diff --git a/ide/plugins/features/quickinterpreter/pom.xml b/ide/plugins/features/quickinterpreter/pom.xml index e3e60a7505..d9627ce571 100644 --- a/ide/plugins/features/quickinterpreter/pom.xml +++ b/ide/plugins/features/quickinterpreter/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide.plugins org.overture.ide.plugins.features - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/plugins/features/rttraceviewer/feature.xml b/ide/plugins/features/rttraceviewer/feature.xml index 4e86afc93f..7653b3570c 100644 --- a/ide/plugins/features/rttraceviewer/feature.xml +++ b/ide/plugins/features/rttraceviewer/feature.xml @@ -2,7 +2,7 @@ + version="2.2.3.qualifier"> %description diff --git a/ide/plugins/features/rttraceviewer/pom.xml b/ide/plugins/features/rttraceviewer/pom.xml index 095f483d0a..c317a5b78e 100644 --- a/ide/plugins/features/rttraceviewer/pom.xml +++ b/ide/plugins/features/rttraceviewer/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide.plugins org.overture.ide.plugins.features - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/plugins/features/uml2/feature.xml b/ide/plugins/features/uml2/feature.xml index 09b2f8138c..ac642f4c3a 100644 --- a/ide/plugins/features/uml2/feature.xml +++ b/ide/plugins/features/uml2/feature.xml @@ -2,7 +2,7 @@ + version="2.2.3.qualifier"> %description diff --git a/ide/plugins/features/uml2/pom.xml b/ide/plugins/features/uml2/pom.xml index c8429130f1..fd5f7b01d2 100644 --- a/ide/plugins/features/uml2/pom.xml +++ b/ide/plugins/features/uml2/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide.plugins org.overture.ide.plugins.features - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/plugins/guibuilder/META-INF/MANIFEST.MF b/ide/plugins/guibuilder/META-INF/MANIFEST.MF index 6ee88a6859..358a5be3c2 100644 --- a/ide/plugins/guibuilder/META-INF/MANIFEST.MF +++ b/ide/plugins/guibuilder/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.2 +Bundle-Version: 2.2.3.qualifier Eclipse-BuddyPolicy: registered Eclipse-BundleShape: dir Bundle-Localization: plugin diff --git a/ide/plugins/guibuilder/pom.xml b/ide/plugins/guibuilder/pom.xml index d068eacca2..472a605392 100644 --- a/ide/plugins/guibuilder/pom.xml +++ b/ide/plugins/guibuilder/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide org.overture.ide.plugins - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/plugins/latex/META-INF/MANIFEST.MF b/ide/plugins/latex/META-INF/MANIFEST.MF index 7ea536f5ab..592050f109 100644 --- a/ide/plugins/latex/META-INF/MANIFEST.MF +++ b/ide/plugins/latex/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.2 +Bundle-Version: 2.2.3.qualifier Eclipse-BuddyPolicy: registered Bundle-Localization: plugin Bundle-Name: org.overture.ide.plugins.latex diff --git a/ide/plugins/latex/pom.xml b/ide/plugins/latex/pom.xml index ac6bc4155a..da1f98c79b 100644 --- a/ide/plugins/latex/pom.xml +++ b/ide/plugins/latex/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide org.overture.ide.plugins - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/plugins/pom.xml b/ide/plugins/pom.xml index 6353a258e4..4e15a24bac 100644 --- a/ide/plugins/pom.xml +++ b/ide/plugins/pom.xml @@ -5,7 +5,7 @@ org.overturetool ide - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/plugins/poviewer/META-INF/MANIFEST.MF b/ide/plugins/poviewer/META-INF/MANIFEST.MF index 7c4c3d826b..48204bcfe8 100644 --- a/ide/plugins/poviewer/META-INF/MANIFEST.MF +++ b/ide/plugins/poviewer/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.2 +Bundle-Version: 2.2.3.qualifier Eclipse-BuddyPolicy: registered Eclipse-BundleShape: dir Bundle-Localization: plugin diff --git a/ide/plugins/poviewer/pom.xml b/ide/plugins/poviewer/pom.xml index 543903e2f6..3bf2620b9b 100644 --- a/ide/plugins/poviewer/pom.xml +++ b/ide/plugins/poviewer/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide org.overture.ide.plugins - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/plugins/prob-runtime/core/META-INF/MANIFEST.MF b/ide/plugins/prob-runtime/core/META-INF/MANIFEST.MF index 23b5f360fc..5e420c38ee 100644 --- a/ide/plugins/prob-runtime/core/META-INF/MANIFEST.MF +++ b/ide/plugins/prob-runtime/core/META-INF/MANIFEST.MF @@ -1,6 +1,6 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture -Bundle-Version: 2.2.2 +Bundle-Version: 2.2.3.qualifier Eclipse-BuddyPolicy: registered Eclipse-BundleShape: dir Bundle-Name: ProB Runtime diff --git a/ide/plugins/prob-runtime/core/pom.xml b/ide/plugins/prob-runtime/core/pom.xml index bc2c45dc06..7e4c475d30 100644 --- a/ide/plugins/prob-runtime/core/pom.xml +++ b/ide/plugins/prob-runtime/core/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide.plugins org.overture.ide.plugins.probruntime - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/plugins/prob-runtime/linux.x86/META-INF/MANIFEST.MF b/ide/plugins/prob-runtime/linux.x86/META-INF/MANIFEST.MF index 45efc3bfc8..a36bb64b36 100644 --- a/ide/plugins/prob-runtime/linux.x86/META-INF/MANIFEST.MF +++ b/ide/plugins/prob-runtime/linux.x86/META-INF/MANIFEST.MF @@ -3,7 +3,7 @@ Eclipse-BundleShape: dir Bundle-ManifestVersion: 2 Bundle-Name: org.overture.ide.plugins.probruntime Bundle-SymbolicName: org.overture.ide.plugins.probruntime.linux.x86;singleton:=true -Bundle-Version: 2.2.2 +Bundle-Version: 2.2.3.qualifier Fragment-Host: org.overture.ide.plugins.probruntime.core Bundle-RequiredExecutionEnvironment: JavaSE-1.7 diff --git a/ide/plugins/prob-runtime/linux.x86/pom.xml b/ide/plugins/prob-runtime/linux.x86/pom.xml index ac985fda09..7f5898d889 100644 --- a/ide/plugins/prob-runtime/linux.x86/pom.xml +++ b/ide/plugins/prob-runtime/linux.x86/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide.plugins org.overture.ide.plugins.probruntime - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/plugins/prob-runtime/linux.x86_64/META-INF/MANIFEST.MF b/ide/plugins/prob-runtime/linux.x86_64/META-INF/MANIFEST.MF index 264a9fdf94..d6be88606a 100644 --- a/ide/plugins/prob-runtime/linux.x86_64/META-INF/MANIFEST.MF +++ b/ide/plugins/prob-runtime/linux.x86_64/META-INF/MANIFEST.MF @@ -3,7 +3,7 @@ Eclipse-BundleShape: dir Bundle-ManifestVersion: 2 Bundle-Name: org.overture.ide.plugins.probruntime Bundle-SymbolicName: org.overture.ide.plugins.probruntime.linux.x86_64;singleton:=true -Bundle-Version: 2.2.2 +Bundle-Version: 2.2.3.qualifier Fragment-Host: org.overture.ide.plugins.probruntime.core Bundle-RequiredExecutionEnvironment: JavaSE-1.7 diff --git a/ide/plugins/prob-runtime/linux.x86_64/pom.xml b/ide/plugins/prob-runtime/linux.x86_64/pom.xml index b66a0f5765..edef534fc0 100644 --- a/ide/plugins/prob-runtime/linux.x86_64/pom.xml +++ b/ide/plugins/prob-runtime/linux.x86_64/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide.plugins org.overture.ide.plugins.probruntime - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/plugins/prob-runtime/macosx.x86_64/META-INF/MANIFEST.MF b/ide/plugins/prob-runtime/macosx.x86_64/META-INF/MANIFEST.MF index 20a5681fd1..15a05f63bb 100644 --- a/ide/plugins/prob-runtime/macosx.x86_64/META-INF/MANIFEST.MF +++ b/ide/plugins/prob-runtime/macosx.x86_64/META-INF/MANIFEST.MF @@ -3,7 +3,7 @@ Eclipse-BundleShape: dir Bundle-ManifestVersion: 2 Bundle-Name: org.overture.ide.plugins.probruntime Bundle-SymbolicName: org.overture.ide.plugins.probruntime.macosx.x86_64;singleton:=true -Bundle-Version: 2.2.2 +Bundle-Version: 2.2.3.qualifier Fragment-Host: org.overture.ide.plugins.probruntime.core Bundle-RequiredExecutionEnvironment: JavaSE-1.7 diff --git a/ide/plugins/prob-runtime/macosx.x86_64/pom.xml b/ide/plugins/prob-runtime/macosx.x86_64/pom.xml index ad477ea5b3..6a9aee0c33 100644 --- a/ide/plugins/prob-runtime/macosx.x86_64/pom.xml +++ b/ide/plugins/prob-runtime/macosx.x86_64/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide.plugins org.overture.ide.plugins.probruntime - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/plugins/prob-runtime/pom.xml b/ide/plugins/prob-runtime/pom.xml index d98174d180..dcf1b1baca 100644 --- a/ide/plugins/prob-runtime/pom.xml +++ b/ide/plugins/prob-runtime/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide org.overture.ide.plugins - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/plugins/prob-runtime/win32.win32/META-INF/MANIFEST.MF b/ide/plugins/prob-runtime/win32.win32/META-INF/MANIFEST.MF index c7cf64842d..dfc701d514 100644 --- a/ide/plugins/prob-runtime/win32.win32/META-INF/MANIFEST.MF +++ b/ide/plugins/prob-runtime/win32.win32/META-INF/MANIFEST.MF @@ -3,7 +3,7 @@ Eclipse-BundleShape: dir Bundle-ManifestVersion: 2 Bundle-Name: org.overture.ide.plugins.probruntime Bundle-SymbolicName: org.overture.ide.plugins.probruntime.win32.win32;singleton:=true -Bundle-Version: 2.2.2 +Bundle-Version: 2.2.3.qualifier Fragment-Host: org.overture.ide.plugins.probruntime.core Bundle-RequiredExecutionEnvironment: JavaSE-1.7 diff --git a/ide/plugins/prob-runtime/win32.win32/pom.xml b/ide/plugins/prob-runtime/win32.win32/pom.xml index 70db2768ec..ba2ad2b470 100644 --- a/ide/plugins/prob-runtime/win32.win32/pom.xml +++ b/ide/plugins/prob-runtime/win32.win32/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide.plugins org.overture.ide.plugins.probruntime - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/plugins/quickinterpreter/META-INF/MANIFEST.MF b/ide/plugins/quickinterpreter/META-INF/MANIFEST.MF index e8f6d61371..741c4aa89e 100644 --- a/ide/plugins/quickinterpreter/META-INF/MANIFEST.MF +++ b/ide/plugins/quickinterpreter/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.2 +Bundle-Version: 2.2.3.qualifier Eclipse-BuddyPolicy: registered Bundle-Localization: plugin Bundle-Name: org.overture.ide.plugins.quickinterpreter diff --git a/ide/plugins/quickinterpreter/pom.xml b/ide/plugins/quickinterpreter/pom.xml index 38099b5e9a..39bc4f8dd6 100644 --- a/ide/plugins/quickinterpreter/pom.xml +++ b/ide/plugins/quickinterpreter/pom.xml @@ -4,7 +4,7 @@ org.overturetool.ide org.overture.ide.plugins - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/plugins/rttraceviewer/META-INF/MANIFEST.MF b/ide/plugins/rttraceviewer/META-INF/MANIFEST.MF index b95dd2874a..39ac82df50 100644 --- a/ide/plugins/rttraceviewer/META-INF/MANIFEST.MF +++ b/ide/plugins/rttraceviewer/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.2 +Bundle-Version: 2.2.3.qualifier Eclipse-BuddyPolicy: registered Bundle-Localization: plugin Bundle-Name: org.overture.ide.plugins.rttraceviewer diff --git a/ide/plugins/rttraceviewer/pom.xml b/ide/plugins/rttraceviewer/pom.xml index 2b3d43f302..46554d7417 100644 --- a/ide/plugins/rttraceviewer/pom.xml +++ b/ide/plugins/rttraceviewer/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide org.overture.ide.plugins - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/plugins/uml2.tests/META-INF/MANIFEST.MF b/ide/plugins/uml2.tests/META-INF/MANIFEST.MF index cac406c981..68468e1d4a 100644 --- a/ide/plugins/uml2.tests/META-INF/MANIFEST.MF +++ b/ide/plugins/uml2.tests/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.2 +Bundle-Version: 2.2.3.qualifier Eclipse-BuddyPolicy: registered Bundle-Localization: plugin Bundle-Name: org.overture.ide.plugins.uml2.tests diff --git a/ide/plugins/uml2.tests/pom.xml b/ide/plugins/uml2.tests/pom.xml index 627699af59..47307902c7 100644 --- a/ide/plugins/uml2.tests/pom.xml +++ b/ide/plugins/uml2.tests/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide org.overture.ide.plugins - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/plugins/uml2/META-INF/MANIFEST.MF b/ide/plugins/uml2/META-INF/MANIFEST.MF index ef4d8c1414..383e7331d9 100644 --- a/ide/plugins/uml2/META-INF/MANIFEST.MF +++ b/ide/plugins/uml2/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.2 +Bundle-Version: 2.2.3.qualifier Eclipse-BuddyPolicy: registered Bundle-Name: UML2 Translator Bundle-ManifestVersion: 2 diff --git a/ide/plugins/uml2/pom.xml b/ide/plugins/uml2/pom.xml index 35195c8701..d60aa6fe16 100644 --- a/ide/plugins/uml2/pom.xml +++ b/ide/plugins/uml2/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide org.overture.ide.plugins - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/pom.xml b/ide/pom.xml index 0cfb839f2f..61fe2f3944 100644 --- a/ide/pom.xml +++ b/ide/pom.xml @@ -5,11 +5,10 @@ org.overturetool root - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml - -pom + pom ide Overture IDE Top-level Super POM for all IDE (Eclipse) artifacts. diff --git a/ide/product/overture.product b/ide/product/overture.product index 7bac60d75f..5bd784d424 100644 --- a/ide/product/overture.product +++ b/ide/product/overture.product @@ -1,7 +1,7 @@ - + diff --git a/ide/product/pom.xml b/ide/product/pom.xml index fa3df286db..f25bd39d34 100644 --- a/ide/product/pom.xml +++ b/ide/product/pom.xml @@ -5,7 +5,7 @@ org.overturetool ide - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/tests/pom.xml b/ide/tests/pom.xml index 7409061785..04faaf3abf 100644 --- a/ide/tests/pom.xml +++ b/ide/tests/pom.xml @@ -5,7 +5,7 @@ org.overturetool ide - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/tests/ui/META-INF/MANIFEST.MF b/ide/tests/ui/META-INF/MANIFEST.MF index a8648cf0ac..488bac8ed7 100644 --- a/ide/tests/ui/META-INF/MANIFEST.MF +++ b/ide/tests/ui/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.2 +Bundle-Version: 2.2.3.qualifier Eclipse-BuddyPolicy: registered Bundle-Localization: plugin Bundle-Name: org.overture.ide.tests.ui diff --git a/ide/tests/ui/pom.xml b/ide/tests/ui/pom.xml index 4a27a37c7a..6e5bf8b5a4 100644 --- a/ide/tests/ui/pom.xml +++ b/ide/tests/ui/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide org.overture.ide.tests - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/ui/META-INF/MANIFEST.MF b/ide/ui/META-INF/MANIFEST.MF index d154a1e394..10804aaa9a 100644 --- a/ide/ui/META-INF/MANIFEST.MF +++ b/ide/ui/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.2 +Bundle-Version: 2.2.3.qualifier Eclipse-BuddyPolicy: registered Bundle-Localization: plugin Bundle-Name: org.overture.ide.ui diff --git a/ide/ui/pom.xml b/ide/ui/pom.xml index 3dde557224..cb3ee16fad 100644 --- a/ide/ui/pom.xml +++ b/ide/ui/pom.xml @@ -5,7 +5,7 @@ org.overturetool ide - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/vdmpp/core/META-INF/MANIFEST.MF b/ide/vdmpp/core/META-INF/MANIFEST.MF index 051b1a39e1..47c64269c3 100644 --- a/ide/vdmpp/core/META-INF/MANIFEST.MF +++ b/ide/vdmpp/core/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.2 +Bundle-Version: 2.2.3.qualifier Eclipse-BuddyPolicy: registered Bundle-Localization: plugin Bundle-Name: org.overture.ide.vdmpp.core diff --git a/ide/vdmpp/core/pom.xml b/ide/vdmpp/core/pom.xml index 8b57f42923..1d65e87fbe 100644 --- a/ide/vdmpp/core/pom.xml +++ b/ide/vdmpp/core/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide org.overture.ide.vdmpp - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/vdmpp/debug/META-INF/MANIFEST.MF b/ide/vdmpp/debug/META-INF/MANIFEST.MF index ba09194c80..ae76e56694 100644 --- a/ide/vdmpp/debug/META-INF/MANIFEST.MF +++ b/ide/vdmpp/debug/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.2 +Bundle-Version: 2.2.3.qualifier Eclipse-BuddyPolicy: registered Bundle-Localization: plugin Bundle-Name: org.overture.ide.vdmpp.debug diff --git a/ide/vdmpp/debug/pom.xml b/ide/vdmpp/debug/pom.xml index 30f2a142b4..54ff78b0d5 100644 --- a/ide/vdmpp/debug/pom.xml +++ b/ide/vdmpp/debug/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide org.overture.ide.vdmpp - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/vdmpp/pom.xml b/ide/vdmpp/pom.xml index 9553e58f09..48da05bfcf 100644 --- a/ide/vdmpp/pom.xml +++ b/ide/vdmpp/pom.xml @@ -4,7 +4,7 @@ org.overturetool ide - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/vdmpp/ui/META-INF/MANIFEST.MF b/ide/vdmpp/ui/META-INF/MANIFEST.MF index 696332288b..e8b2cb1b54 100644 --- a/ide/vdmpp/ui/META-INF/MANIFEST.MF +++ b/ide/vdmpp/ui/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.2 +Bundle-Version: 2.2.3.qualifier Eclipse-BuddyPolicy: registered Bundle-Localization: plugin Bundle-Name: org.overture.ide.vdmpp.ui diff --git a/ide/vdmpp/ui/pom.xml b/ide/vdmpp/ui/pom.xml index c3d713876f..d4976669b3 100644 --- a/ide/vdmpp/ui/pom.xml +++ b/ide/vdmpp/ui/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide org.overture.ide.vdmpp - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/vdmrt/core/META-INF/MANIFEST.MF b/ide/vdmrt/core/META-INF/MANIFEST.MF index aaf80d16df..a2d6710aa0 100644 --- a/ide/vdmrt/core/META-INF/MANIFEST.MF +++ b/ide/vdmrt/core/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.2 +Bundle-Version: 2.2.3.qualifier Eclipse-BuddyPolicy: registered Bundle-Localization: plugin Bundle-Name: org.overture.ide.vdmrt.core diff --git a/ide/vdmrt/core/pom.xml b/ide/vdmrt/core/pom.xml index bcf105d9c8..ebe78dc261 100644 --- a/ide/vdmrt/core/pom.xml +++ b/ide/vdmrt/core/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide org.overture.ide.vdmrt - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/vdmrt/debug/META-INF/MANIFEST.MF b/ide/vdmrt/debug/META-INF/MANIFEST.MF index 5b91408079..27291dded6 100644 --- a/ide/vdmrt/debug/META-INF/MANIFEST.MF +++ b/ide/vdmrt/debug/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.2 +Bundle-Version: 2.2.3.qualifier Eclipse-BuddyPolicy: registered Bundle-Localization: plugin Bundle-Name: org.overture.ide.vdmrt.debug diff --git a/ide/vdmrt/debug/pom.xml b/ide/vdmrt/debug/pom.xml index 5195945841..a13e21b195 100644 --- a/ide/vdmrt/debug/pom.xml +++ b/ide/vdmrt/debug/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide org.overture.ide.vdmrt - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/vdmrt/pom.xml b/ide/vdmrt/pom.xml index 257f139117..32c57f9075 100644 --- a/ide/vdmrt/pom.xml +++ b/ide/vdmrt/pom.xml @@ -5,7 +5,7 @@ org.overturetool ide - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/vdmrt/ui/META-INF/MANIFEST.MF b/ide/vdmrt/ui/META-INF/MANIFEST.MF index 9ac4c3e7e7..99a6a37e7b 100644 --- a/ide/vdmrt/ui/META-INF/MANIFEST.MF +++ b/ide/vdmrt/ui/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.2 +Bundle-Version: 2.2.3.qualifier Eclipse-BuddyPolicy: registered Bundle-Localization: plugin Bundle-Name: org.overture.ide.vdmrt.ui diff --git a/ide/vdmrt/ui/pom.xml b/ide/vdmrt/ui/pom.xml index 1032205d34..065835bbf6 100644 --- a/ide/vdmrt/ui/pom.xml +++ b/ide/vdmrt/ui/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide org.overture.ide.vdmrt - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/vdmsl/core/META-INF/MANIFEST.MF b/ide/vdmsl/core/META-INF/MANIFEST.MF index f6878bd5ea..d8ca583480 100644 --- a/ide/vdmsl/core/META-INF/MANIFEST.MF +++ b/ide/vdmsl/core/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.2 +Bundle-Version: 2.2.3.qualifier Eclipse-BuddyPolicy: registered Bundle-Localization: plugin Bundle-Name: org.overture.ide.vdmsl.core diff --git a/ide/vdmsl/core/pom.xml b/ide/vdmsl/core/pom.xml index be6b30be86..11f5f12236 100644 --- a/ide/vdmsl/core/pom.xml +++ b/ide/vdmsl/core/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide org.overture.ide.vdmsl - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/vdmsl/debug/META-INF/MANIFEST.MF b/ide/vdmsl/debug/META-INF/MANIFEST.MF index ef536928c3..71b5545f2d 100644 --- a/ide/vdmsl/debug/META-INF/MANIFEST.MF +++ b/ide/vdmsl/debug/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.2 +Bundle-Version: 2.2.3.qualifier Eclipse-BuddyPolicy: registered Bundle-Localization: plugin Bundle-Name: org.overture.ide.vdmsl.debug diff --git a/ide/vdmsl/debug/pom.xml b/ide/vdmsl/debug/pom.xml index 692669c612..c583af22de 100644 --- a/ide/vdmsl/debug/pom.xml +++ b/ide/vdmsl/debug/pom.xml @@ -4,7 +4,7 @@ org.overturetool.ide org.overture.ide.vdmsl - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/vdmsl/pom.xml b/ide/vdmsl/pom.xml index e440893681..92972216e4 100644 --- a/ide/vdmsl/pom.xml +++ b/ide/vdmsl/pom.xml @@ -5,7 +5,7 @@ org.overturetool ide - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml diff --git a/ide/vdmsl/ui/META-INF/MANIFEST.MF b/ide/vdmsl/ui/META-INF/MANIFEST.MF index ea3b5ddb8d..063ae37bad 100644 --- a/ide/vdmsl/ui/META-INF/MANIFEST.MF +++ b/ide/vdmsl/ui/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.2 +Bundle-Version: 2.2.3.qualifier Eclipse-BuddyPolicy: registered Bundle-Localization: plugin Bundle-Name: org.overture.ide.vdmsl.ui diff --git a/ide/vdmsl/ui/pom.xml b/ide/vdmsl/ui/pom.xml index 3c9208fdb3..57ce2cc914 100644 --- a/ide/vdmsl/ui/pom.xml +++ b/ide/vdmsl/ui/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide org.overture.ide.vdmsl - 2.2.2 + 2.2.3-SNAPSHOT ../pom.xml From 3835ad752fedb7f489fa06f4c81d21fa70d3edcf Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Thu, 26 Feb 2015 19:28:01 +0100 Subject: [PATCH 149/323] Updated the AboutCommand to reflect the most recent work on the Java code generator --- .../codegen/commands/AboutCommand.java | 4 ++++ .../codegen/textfiles/AboutMessage.txt | 21 ++++++++++--------- 2 files changed, 15 insertions(+), 10 deletions(-) diff --git a/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/AboutCommand.java b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/AboutCommand.java index 850a2aab70..cae7db51c4 100644 --- a/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/AboutCommand.java +++ b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/AboutCommand.java @@ -32,6 +32,7 @@ import org.eclipse.ui.handlers.HandlerUtil; import org.overture.codegen.utils.GeneralUtils; import org.overture.ide.plugins.codegen.Activator; +import org.overture.ide.plugins.codegen.util.PluginVdm2JavaUtil; public class AboutCommand extends AbstractHandler { @@ -46,6 +47,9 @@ public Object execute(ExecutionEvent event) throws ExecutionException Shell shell = HandlerUtil.getActiveWorkbenchWindow(event).getShell(); String title = "VDM++ to Java Code Generator"; String about = GeneralUtils.readFromInputStream(fileStream).toString(); + about = String.format(about, PluginVdm2JavaUtil.CODEGEN_RUNTIME_BIN_FILE_NAME, + PluginVdm2JavaUtil.CODEGEN_RUNTIME_SOURCES_FILE_NAME, + PluginVdm2JavaUtil.CODEGEN_RUNTIME_LIB_FOLDER_NAME); MessageDialog.openInformation(shell, title, about); diff --git a/ide/plugins/codegen/textfiles/AboutMessage.txt b/ide/plugins/codegen/textfiles/AboutMessage.txt index c6a715e568..f025d0159c 100644 --- a/ide/plugins/codegen/textfiles/AboutMessage.txt +++ b/ide/plugins/codegen/textfiles/AboutMessage.txt @@ -1,16 +1,17 @@ -The Java to VDM++ code generator indicates to the user if a construct -cannot be generated by highlighting it in the editor using a marker -(similar to the way warnings are shown) and outputs messages -about it in the console. Generated code is output in the generated/java -folder. +The output of the VDM++ to Java code generator can be imported directly +into Eclipse as an Eclipse project. The generated code is output in the +generated/java project folder. -Code generation runtime: +The Java code generator indicates to the user if a construct cannot be +generated by highlighting it in the editor using a marker and also +outputs messages about it in the console. -The generated Java code depends on a runtime/library to represent VDM -collections, VDM types etc. The source code for the runtime can be found -in the Overture Github repository at: +Code generation runtime library: -https://github.com/overturetool/overture/tree/development/core/codegen-runtime +The generated Java code depends on a runtime library to represent +constructs such as VDM collections and VDM types in the generated Java +code. The binaries and sources are available in the %s and +%s files in the %s project folder. Please report bugs, problems, and other issues with the tool at https://github.com/overturetool/overture/issues \ No newline at end of file From 745a334040dc8202901686d2623176f36078502f Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Thu, 26 Feb 2015 19:38:00 +0100 Subject: [PATCH 150/323] Updated a codegen test to avoid serialisation of a class during test execution --- .../resources/complex_expressions/RecursiveNamedTypeMapApply | 2 +- .../complex_expressions/RecursiveNamedTypeMapApply.result | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/core/codegen/src/test/resources/complex_expressions/RecursiveNamedTypeMapApply b/core/codegen/src/test/resources/complex_expressions/RecursiveNamedTypeMapApply index d091965049..3e211d7143 100644 --- a/core/codegen/src/test/resources/complex_expressions/RecursiveNamedTypeMapApply +++ b/core/codegen/src/test/resources/complex_expressions/RecursiveNamedTypeMapApply @@ -19,6 +19,6 @@ public static Run : () ==> ? Run () == let e = new Entry() in - return e.app(mk_token(1), mk_token(1)); + return = e.app(mk_token(1), mk_token(1)); end Entry \ No newline at end of file diff --git a/core/codegen/src/test/resources/complex_expressions/RecursiveNamedTypeMapApply.result b/core/codegen/src/test/resources/complex_expressions/RecursiveNamedTypeMapApply.result index 37ff63b7e3..1eb09e0822 100644 --- a/core/codegen/src/test/resources/complex_expressions/RecursiveNamedTypeMapApply.result +++ b/core/codegen/src/test/resources/complex_expressions/RecursiveNamedTypeMapApply.result @@ -17,7 +17,8 @@ public class Entry { public static Object Run() { Entry e = new Entry(); - return ((Object) e.app(new Token(1L), new Token(1L))); + return Utils.equals(quotes.A.getInstance(), + e.app(new Token(1L), new Token(1L))); } public String toString() { From c98571e3f443526417247ea22cd1593a9978c701 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Thu, 26 Feb 2015 20:31:20 +0100 Subject: [PATCH 151/323] Updated IR settings to take traces into account --- .../java/org/overture/codegen/ir/IRSettings.java | 12 ++++++++++++ .../org/overture/codegen/visitor/DeclVisitorCG.java | 5 +++++ 2 files changed, 17 insertions(+) diff --git a/core/codegen/src/main/java/org/overture/codegen/ir/IRSettings.java b/core/codegen/src/main/java/org/overture/codegen/ir/IRSettings.java index fd74f8a4d5..f9e77ba955 100644 --- a/core/codegen/src/main/java/org/overture/codegen/ir/IRSettings.java +++ b/core/codegen/src/main/java/org/overture/codegen/ir/IRSettings.java @@ -29,6 +29,7 @@ public class IRSettings private boolean generatePreCondChecks; private boolean generatePostConds; private boolean generatePostCondChecks; + private boolean generateTraces; public IRSettings() { @@ -93,4 +94,15 @@ public void setGeneratePostCondChecks(boolean generatePostCondChecks) { this.generatePostCondChecks = generatePostCondChecks; } + + public boolean generateTraces() + { + return generateTraces; + } + + public void setGenerateTraces(boolean generateTraces) + { + this.generateTraces = generateTraces; + } } + diff --git a/core/codegen/src/main/java/org/overture/codegen/visitor/DeclVisitorCG.java b/core/codegen/src/main/java/org/overture/codegen/visitor/DeclVisitorCG.java index 97dd934fe5..83904cd93a 100644 --- a/core/codegen/src/main/java/org/overture/codegen/visitor/DeclVisitorCG.java +++ b/core/codegen/src/main/java/org/overture/codegen/visitor/DeclVisitorCG.java @@ -100,6 +100,11 @@ public SDeclCG caseATraceDefinitionTerm(ATraceDefinitionTerm node, public SDeclCG caseANamedTraceDefinition(ANamedTraceDefinition node, IRInfo question) throws AnalysisException { + if(!question.getSettings().generateTraces()) + { + return null; + } + ANamedTraceDeclCG namedTraceDecl = new ANamedTraceDeclCG(); for(ClonableString cloStr : node.getPathname()) From fbe2c48afca9d0919edc8360be029102f2bc9e5e Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Thu, 26 Feb 2015 20:36:11 +0100 Subject: [PATCH 152/323] Comprehensions and quantifiers can also exist in the context of a trace in the IR --- .../org/overture/codegen/assistant/ExpAssistantCG.java | 8 +++++--- .../java/org/overture/codegen/visitor/ExpVisitorCG.java | 8 ++++---- 2 files changed, 9 insertions(+), 7 deletions(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/assistant/ExpAssistantCG.java b/core/codegen/src/main/java/org/overture/codegen/assistant/ExpAssistantCG.java index 3bd50e81dd..4296d58093 100644 --- a/core/codegen/src/main/java/org/overture/codegen/assistant/ExpAssistantCG.java +++ b/core/codegen/src/main/java/org/overture/codegen/assistant/ExpAssistantCG.java @@ -29,6 +29,7 @@ import org.overture.ast.analysis.AnalysisException; import org.overture.ast.definitions.AAssignmentDefinition; import org.overture.ast.definitions.AInstanceVariableDefinition; +import org.overture.ast.definitions.ANamedTraceDefinition; import org.overture.ast.definitions.AValueDefinition; import org.overture.ast.definitions.PDefinition; import org.overture.ast.definitions.SFunctionDefinition; @@ -349,7 +350,7 @@ public AHeaderLetBeStCG consHeader(ASetMultipleBindCG binding, return header; } - public boolean existsOutsideOpOrFunc(PExp exp) + public boolean existsOutsideMethodOrTrace(PExp exp) { // The transformation of the 'and' and 'or' logical expressions also assumes that the // expressions exist within a statement. However, in case it does not, the transformation @@ -357,14 +358,15 @@ public boolean existsOutsideOpOrFunc(PExp exp) // still be used (say) in instance variable assignment. return exp.getAncestor(SOperationDefinition.class) == null - && exp.getAncestor(SFunctionDefinition.class) == null; + && exp.getAncestor(SFunctionDefinition.class) == null + && exp.getAncestor(ANamedTraceDefinition.class) == null; } public SExpCG handleQuantifier(PExp node, List bindings, PExp predicate, SQuantifierExpCG quantifier, IRInfo question, String nodeStr) throws AnalysisException { - if (question.getExpAssistant().existsOutsideOpOrFunc(node)) + if (question.getExpAssistant().existsOutsideMethodOrTrace(node)) { question.addUnsupportedNode(node, String.format("Generation of a %s is only supported within operations/functions", nodeStr)); return null; diff --git a/core/codegen/src/main/java/org/overture/codegen/visitor/ExpVisitorCG.java b/core/codegen/src/main/java/org/overture/codegen/visitor/ExpVisitorCG.java index 9c35a3e452..30cf4b54dd 100644 --- a/core/codegen/src/main/java/org/overture/codegen/visitor/ExpVisitorCG.java +++ b/core/codegen/src/main/java/org/overture/codegen/visitor/ExpVisitorCG.java @@ -502,7 +502,7 @@ public SExpCG caseAExists1Exp(AExists1Exp node, IRInfo question) public SExpCG caseASetCompSetExp(ASetCompSetExp node, IRInfo question) throws AnalysisException { - if (question.getExpAssistant().existsOutsideOpOrFunc(node)) + if (question.getExpAssistant().existsOutsideMethodOrTrace(node)) { question.addUnsupportedNode(node, "Generation of a set comprehension is only supported within operations/functions"); return null; @@ -743,7 +743,7 @@ public SExpCG caseAFuncInstatiationExp(AFuncInstatiationExp node, public SExpCG caseALetBeStExp(ALetBeStExp node, IRInfo question) throws AnalysisException { - if (question.getExpAssistant().existsOutsideOpOrFunc(node)) + if (question.getExpAssistant().existsOutsideMethodOrTrace(node)) { question.addUnsupportedNode(node, "Generation of a let be st expression is only supported within operations/functions"); return null; @@ -962,7 +962,7 @@ public SExpCG caseADistConcatUnaryExp(ADistConcatUnaryExp node, public SExpCG caseASeqCompSeqExp(ASeqCompSeqExp node, IRInfo question) throws AnalysisException { - if (question.getExpAssistant().existsOutsideOpOrFunc(node)) + if (question.getExpAssistant().existsOutsideMethodOrTrace(node)) { question.addUnsupportedNode(node, "Generation of a sequence comprehension is only supported within operations/functions"); return null; @@ -1083,7 +1083,7 @@ public SExpCG caseAMapletExp(AMapletExp node, IRInfo question) public SExpCG caseAMapCompMapExp(AMapCompMapExp node, IRInfo question) throws AnalysisException { - if (question.getExpAssistant().existsOutsideOpOrFunc(node)) + if (question.getExpAssistant().existsOutsideMethodOrTrace(node)) { question.addUnsupportedNode(node, "Generation of a map comprehension is only supported within operations/functions"); return null; From bcc0c6f0bc4220ea428114295da6fefb23a689df Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Fri, 27 Feb 2015 08:58:38 +0100 Subject: [PATCH 153/323] Extend CG AST via ASDT Creator. --- core/cgisa/pom.xml | 80 ++++++++++++++++++- .../cgisa/ir/ExtIrClassDeclStatus.java | 38 +++++++++ core/cgisa/src/main/resources/isacg.ast | 19 +++++ .../src/main/resources/isacg.ast.tostring | 9 +++ 4 files changed, 145 insertions(+), 1 deletion(-) create mode 100644 core/cgisa/src/main/java/org/overturetool/cgisa/ir/ExtIrClassDeclStatus.java create mode 100644 core/cgisa/src/main/resources/isacg.ast create mode 100644 core/cgisa/src/main/resources/isacg.ast.tostring diff --git a/core/cgisa/pom.xml b/core/cgisa/pom.xml index aa2ad6e0e9..bc77509948 100644 --- a/core/cgisa/pom.xml +++ b/core/cgisa/pom.xml @@ -12,6 +12,10 @@ cgisa VDM to Isabelle Translation + + 1.6.4 + + org.overturetool.core @@ -51,8 +55,82 @@ - + + org.overturetool.astcreator + astcreator-plugin + ${astcreator.version} + + + generate-ast + generate-sources + + generate + + + + + cg.astv2 + isacg.ast + Ext + true + false + + org.overturetool.core + codegen + + + + + org.codehaus.mojo + build-helper-maven-plugin + + + add-source + generate-sources + + add-source + + + + ${project.build.directory}/generated-sources/astCreator/ + + + + + + + + + + + + org.eclipse.m2e + lifecycle-mapping + 1.0.0 + + + + + + org.overturetool.astcreator + astcreator-plugin + ${astcreator.version} + + generate + + + + + + + + + + + + diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/ir/ExtIrClassDeclStatus.java b/core/cgisa/src/main/java/org/overturetool/cgisa/ir/ExtIrClassDeclStatus.java new file mode 100644 index 0000000000..cd2d718dad --- /dev/null +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/ir/ExtIrClassDeclStatus.java @@ -0,0 +1,38 @@ +package org.overturetool.cgisa.ir; + +import java.util.Set; + +import org.overture.cgisa.extast.declarations.AExtClassDeclCG; +import org.overture.codegen.ir.IRClassDeclStatus; +import org.overture.codegen.ir.VdmNodeInfo; +import org.overturetool.cgisa.transformations.ExtendClass; + +public class ExtIrClassDeclStatus extends IRClassDeclStatus +{ + + private AExtClassDeclCG eClassCg; + + public ExtIrClassDeclStatus(Set unsupportedInIr, + AExtClassDeclCG classCg, String className) + { + super(className, null, unsupportedInIr); + this.eClassCg = classCg; + } + + public ExtIrClassDeclStatus(IRClassDeclStatus status) + { + super(status.getClassName(), null, status.getUnsupportedInIr()); + this.eClassCg = ExtendClass.transform(status.getClassCg()); + } + + public String getClassName() + { + return className; + } + + public AExtClassDeclCG getEClassCg() + { + return eClassCg; + } + +} diff --git a/core/cgisa/src/main/resources/isacg.ast b/core/cgisa/src/main/resources/isacg.ast new file mode 100644 index 0000000000..1ecc4db994 --- /dev/null +++ b/core/cgisa/src/main/resources/isacg.ast @@ -0,0 +1,19 @@ +Packages + +base org.overturetool.cgisa.extast.node; +analysis org.overturetool.cgisa.extast.analysis; + +Tokens + +Abstract Syntax Tree + +CG = #decl + ; + +#decl {-> package='org.overture.cgisa.extast.declarations'} + = {mrFuncGroup} + [funcs]:CG.#decl.func* + | {extClass} + [baseClass]:CG.#decl.class + [mutrecfuncs]:CG.#decl.mrFuncGroup* + ; diff --git a/core/cgisa/src/main/resources/isacg.ast.tostring b/core/cgisa/src/main/resources/isacg.ast.tostring new file mode 100644 index 0000000000..ed924eb0fa --- /dev/null +++ b/core/cgisa/src/main/resources/isacg.ast.tostring @@ -0,0 +1,9 @@ +To String Extensions + +// import packages used by external $$ java code +import org.overture.ast.util.Utils; +import org.overture.ast.util.ToStringUtil; + +%CG->#decl->extClass = [baseClass] +%CG->#decl->mrFuncGroup = "mrgroup (" + $Utils.listToString($[funcs]$)$ + ")" + From e9e644b0e21fe5d9290f342c7e8468e19a591952 Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Fri, 27 Feb 2015 08:59:39 +0100 Subject: [PATCH 154/323] Change IR transformation mechanism to support extended IRs. --- .../main/java/org/overture/codegen/ir/IRClassDeclStatus.java | 4 ++-- .../src/main/java/org/overture/codegen/ir/IRGenerator.java | 3 ++- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/ir/IRClassDeclStatus.java b/core/codegen/src/main/java/org/overture/codegen/ir/IRClassDeclStatus.java index bb7002fc7a..ec023510ef 100644 --- a/core/codegen/src/main/java/org/overture/codegen/ir/IRClassDeclStatus.java +++ b/core/codegen/src/main/java/org/overture/codegen/ir/IRClassDeclStatus.java @@ -27,8 +27,8 @@ public class IRClassDeclStatus extends IRStatus { - private String className; - private AClassDeclCG classCg; + protected String className; + protected AClassDeclCG classCg; public IRClassDeclStatus(String className, AClassDeclCG classCg, Set unsupportedNodes) diff --git a/core/codegen/src/main/java/org/overture/codegen/ir/IRGenerator.java b/core/codegen/src/main/java/org/overture/codegen/ir/IRGenerator.java index ada3cb8e3d..8dd56fac3c 100644 --- a/core/codegen/src/main/java/org/overture/codegen/ir/IRGenerator.java +++ b/core/codegen/src/main/java/org/overture/codegen/ir/IRGenerator.java @@ -26,6 +26,7 @@ import java.util.Set; import org.overture.ast.analysis.AnalysisException; +import org.overture.ast.analysis.intf.IAnalysis; import org.overture.ast.definitions.SClassDefinition; import org.overture.ast.expressions.PExp; import org.overture.codegen.cgast.SExpCG; @@ -60,7 +61,7 @@ public IRClassDeclStatus generateFrom(SClassDefinition classDef) return new IRClassDeclStatus(classDef.getName().getName(), classCg, unsupportedNodes); } - public void applyTransformation(IRClassDeclStatus status, DepthFirstAnalysisAdaptor transformation) throws org.overture.codegen.cgast.analysis.AnalysisException + public void applyTransformation(IRClassDeclStatus status, org.overture.codegen.cgast.analysis.intf.IAnalysis transformation) throws org.overture.codegen.cgast.analysis.AnalysisException { codeGenInfo.clearTransformationWarnings(); From 3998dfb310159196ab99d9591d8028909075821e Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Fri, 27 Feb 2015 09:00:01 +0100 Subject: [PATCH 155/323] Add extended IR transformation. class -> extended class functions -> mutual recursin groups (stub only) --- .../org/overturetool/cgisa/IsaCodeGen.java | 36 ++++++++++++------- .../cgisa/transformations/ExtendClass.java | 21 +++++++++++ .../cgisa/transformations/GroupMutRecs.java | 18 ++++++++++ 3 files changed, 62 insertions(+), 13 deletions(-) create mode 100644 core/cgisa/src/main/java/org/overturetool/cgisa/transformations/ExtendClass.java create mode 100644 core/cgisa/src/main/java/org/overturetool/cgisa/transformations/GroupMutRecs.java diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaCodeGen.java b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaCodeGen.java index d5706e98c2..2589e17832 100644 --- a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaCodeGen.java +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaCodeGen.java @@ -27,11 +27,12 @@ import java.util.HashSet; import java.util.LinkedList; import java.util.List; +import java.util.Vector; import org.apache.velocity.app.Velocity; import org.overture.ast.analysis.AnalysisException; import org.overture.ast.definitions.SClassDefinition; -import org.overture.codegen.cgast.declarations.AClassDeclCG; +import org.overture.cgisa.extast.declarations.AExtClassDeclCG; import org.overture.codegen.ir.CodeGenBase; import org.overture.codegen.ir.IRClassDeclStatus; import org.overture.codegen.ir.VdmNodeInfo; @@ -39,6 +40,8 @@ import org.overture.codegen.merging.MergeVisitor; import org.overture.codegen.merging.TemplateStructure; import org.overture.codegen.utils.GeneratedModule; +import org.overturetool.cgisa.ir.ExtIrClassDeclStatus; +import org.overturetool.cgisa.transformations.GroupMutRecs; import org.overturetool.cgisa.transformations.SortDependencies; /** @@ -92,9 +95,22 @@ List generateIsabelleSyntax(List ast) } // Apply transformations (none atm...) + + List transformed = new Vector<>(); + + for (IRClassDeclStatus status : statuses) + { + SortDependencies sortTrans = new SortDependencies(status.getClassCg().getFunctions()); + generator.applyTransformation(status, sortTrans); + ExtIrClassDeclStatus eStatus =new ExtIrClassDeclStatus(status); + GroupMutRecs groupMR = new GroupMutRecs(); + generator.applyTransformation(eStatus, groupMR); + transformed.add(eStatus); + } + + // Apply merge visitor to pretty print isabelle syntax - // No utility methods (template callables) added for now TemplateStructure ts = new TemplateStructure("IsaTemplates"); @@ -106,15 +122,9 @@ List generateIsabelleSyntax(List ast) List generated = new ArrayList(); - for (IRClassDeclStatus status : statuses) - { - SortDependencies sortTrans = new SortDependencies(status.getClassCg().getFunctions()); - generator.applyTransformation(status, sortTrans); - } - - for (IRClassDeclStatus status : statuses) + for (ExtIrClassDeclStatus status : transformed) { - AClassDeclCG irClass = status.getClassCg(); + AExtClassDeclCG irClass = status.getEClassCg(); StringWriter sw = new StringWriter(); @@ -122,15 +132,15 @@ List generateIsabelleSyntax(List ast) if (pp.hasMergeErrors()) { - generated.add(new GeneratedModule(irClass.getName(), irClass, pp.getMergeErrors())); + generated.add(new GeneratedModule(irClass.getBaseClass().getName(), irClass, pp.getMergeErrors())); } else if (pp.hasUnsupportedTargLangNodes()) { - generated.add(new GeneratedModule(irClass.getName(), new HashSet(), pp.getUnsupportedInTargLang())); + generated.add(new GeneratedModule(irClass.getBaseClass().getName(), new HashSet(), pp.getUnsupportedInTargLang())); } else { // Code can be generated // Here should code be formatted - GeneratedModule generatedModule = new GeneratedModule(irClass.getName(), irClass, sw.toString()); + GeneratedModule generatedModule = new GeneratedModule(irClass.getBaseClass().getName(), irClass, sw.toString()); generatedModule.setTransformationWarnings(status.getTransformationWarnings()); generated.add(generatedModule); } diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/transformations/ExtendClass.java b/core/cgisa/src/main/java/org/overturetool/cgisa/transformations/ExtendClass.java new file mode 100644 index 0000000000..edf0a208fb --- /dev/null +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/transformations/ExtendClass.java @@ -0,0 +1,21 @@ +package org.overturetool.cgisa.transformations; + +import java.util.LinkedList; + +import org.overture.cgisa.extast.declarations.AExtClassDeclCG; +import org.overture.cgisa.extast.declarations.AMrFuncGroupDeclCG; +import org.overture.codegen.cgast.declarations.AClassDeclCG; + +public class ExtendClass +{ + + public static AExtClassDeclCG transform(AClassDeclCG clss) + { + AExtClassDeclCG extClass; + extClass = new AExtClassDeclCG(); + extClass.setBaseClass(clss); + extClass.setMutrecfuncs(new LinkedList()); + return extClass; + } + +} diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/transformations/GroupMutRecs.java b/core/cgisa/src/main/java/org/overturetool/cgisa/transformations/GroupMutRecs.java new file mode 100644 index 0000000000..b7744ccb69 --- /dev/null +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/transformations/GroupMutRecs.java @@ -0,0 +1,18 @@ +package org.overturetool.cgisa.transformations; + +import org.overture.cgisa.extast.declarations.AExtClassDeclCG; +import org.overture.codegen.cgast.analysis.AnalysisException; +import org.overturetool.cgisa.extast.analysis.DepthFirstAnalysisExtAdaptor; + +public class GroupMutRecs extends DepthFirstAnalysisExtAdaptor +{ + + + @Override + public void caseAExtClassDeclCG(AExtClassDeclCG node) + throws AnalysisException + { + // TODO Auto-generated method stub + super.caseAExtClassDeclCG(node); + } +} From 9d510fc56feb248134be04e3536499d4ffebe2d0 Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Fri, 27 Feb 2015 09:01:28 +0100 Subject: [PATCH 156/323] Add templates for extended class and MR group. --- .../overturetool/cgisa/IsaTemplateManager.java | 7 ++++++- .../IsaTemplates/Declarations/ExtClass.vm | 18 ++++++++++++++++++ .../IsaTemplates/Declarations/MutRec.vm | 1 + 3 files changed, 25 insertions(+), 1 deletion(-) create mode 100644 core/cgisa/src/main/resources/IsaTemplates/Declarations/ExtClass.vm create mode 100644 core/cgisa/src/main/resources/IsaTemplates/Declarations/MutRec.vm diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTemplateManager.java b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTemplateManager.java index 7628671429..f4faa841c2 100644 --- a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTemplateManager.java +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTemplateManager.java @@ -21,6 +21,8 @@ */ package org.overturetool.cgisa; +import org.overture.cgisa.extast.declarations.AExtClassDeclCG; +import org.overture.cgisa.extast.declarations.AMrFuncGroupDeclCG; import org.overture.codegen.cgast.declarations.AFormalParamLocalParamCG; import org.overture.codegen.cgast.declarations.AFuncDeclCG; import org.overture.codegen.merging.TemplateManager; @@ -32,6 +34,8 @@ public class IsaTemplateManager extends TemplateManager private static final String FUNC_TEMPLATE = "Function"; private static final String FORMAL_PARAM = "FormalParam"; + private static final String EXT_CLASS = "ExtClass"; + private static final String MUT_REC = "MutRec"; public IsaTemplateManager(TemplateStructure templateStructure) { @@ -43,7 +47,8 @@ private void initIsaNodes() { nodeTemplateFileNames.put(AFuncDeclCG.class, templateStructure.DECL_PATH + FUNC_TEMPLATE); nodeTemplateFileNames.put(AFormalParamLocalParamCG.class, templateStructure.LOCAL_DECLS_PATH + FORMAL_PARAM); - + nodeTemplateFileNames.put(AExtClassDeclCG.class, templateStructure.DECL_PATH + EXT_CLASS); + nodeTemplateFileNames.put(AMrFuncGroupDeclCG.class, templateStructure.DECL_PATH + MUT_REC); } diff --git a/core/cgisa/src/main/resources/IsaTemplates/Declarations/ExtClass.vm b/core/cgisa/src/main/resources/IsaTemplates/Declarations/ExtClass.vm new file mode 100644 index 0000000000..735d5e8596 --- /dev/null +++ b/core/cgisa/src/main/resources/IsaTemplates/Declarations/ExtClass.vm @@ -0,0 +1,18 @@ +theory $Isa.norm($node.BaseClass.Name) + imports utp_cml +begin + +#foreach( $func in $node.BaseClass.Functions ) +$Isa.trans($func) + +#end +#foreach( $field in $node.BaseClass.Fields ) +$Isa.filter($field) + +#end +#foreach ($mr in $node.Mutrecfuncs ) +$Isa.trans($mr) + +#end + +end \ No newline at end of file diff --git a/core/cgisa/src/main/resources/IsaTemplates/Declarations/MutRec.vm b/core/cgisa/src/main/resources/IsaTemplates/Declarations/MutRec.vm new file mode 100644 index 0000000000..8f7526a8a0 --- /dev/null +++ b/core/cgisa/src/main/resources/IsaTemplates/Declarations/MutRec.vm @@ -0,0 +1 @@ +Mutual Recusion oh no! \ No newline at end of file From 7b5ecf7b5f22a65865b49090bd5705fd6f6f5213 Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Fri, 27 Feb 2015 15:12:05 +0100 Subject: [PATCH 157/323] Update pom version. [Issue: ] --- core/cgisa/pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/cgisa/pom.xml b/core/cgisa/pom.xml index bc77509948..665f7b5341 100644 --- a/core/cgisa/pom.xml +++ b/core/cgisa/pom.xml @@ -4,7 +4,7 @@ org.overturetool core - 2.2.1-SNAPSHOT + 2.2.3-SNAPSHOT ../pom.xml From 4932fdd243ab74f8b0d4c973e9e98fbca663653d Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Fri, 27 Feb 2015 15:12:49 +0100 Subject: [PATCH 158/323] Hack around limited extensiblility of IRGenerator. [Issue: ] --- .../overturetool/cgisa/ExtIrGenerator.java | 37 +++++++++++++++++++ .../org/overturetool/cgisa/IsaCodeGen.java | 30 ++++++++------- 2 files changed, 53 insertions(+), 14 deletions(-) create mode 100644 core/cgisa/src/main/java/org/overturetool/cgisa/ExtIrGenerator.java diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/ExtIrGenerator.java b/core/cgisa/src/main/java/org/overturetool/cgisa/ExtIrGenerator.java new file mode 100644 index 0000000000..1657b62b63 --- /dev/null +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/ExtIrGenerator.java @@ -0,0 +1,37 @@ +package org.overturetool.cgisa; + +import java.util.HashSet; + +import org.overture.codegen.ir.IRClassDeclStatus; +import org.overture.codegen.ir.IRGenerator; +import org.overture.codegen.ir.IrNodeInfo; +import org.overture.codegen.logging.ILogger; +import org.overturetool.cgisa.ir.ExtIrClassDeclStatus; + +public class ExtIrGenerator extends IRGenerator +{ + + public ExtIrGenerator(ILogger log, String objectInitCallPrefix) + { + super(log, objectInitCallPrefix); + } + + @Override + public void applyTransformation(IRClassDeclStatus status, + org.overture.codegen.cgast.analysis.intf.IAnalysis transformation) + throws org.overture.codegen.cgast.analysis.AnalysisException + { + codeGenInfo.clearTransformationWarnings(); + + if (status instanceof ExtIrClassDeclStatus) + { + ((ExtIrClassDeclStatus) status).getEClassCg().apply(transformation); + } else + { + status.getClassCg().apply(transformation); + } + HashSet transformationWarnings = new HashSet(codeGenInfo.getTransformationWarnings()); + + status.addTransformationWarnings(transformationWarnings); + } +} diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaCodeGen.java b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaCodeGen.java index 2589e17832..398cff22ea 100644 --- a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaCodeGen.java +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/IsaCodeGen.java @@ -35,10 +35,12 @@ import org.overture.cgisa.extast.declarations.AExtClassDeclCG; import org.overture.codegen.ir.CodeGenBase; import org.overture.codegen.ir.IRClassDeclStatus; +import org.overture.codegen.ir.IRGenerator; import org.overture.codegen.ir.VdmNodeInfo; import org.overture.codegen.logging.ILogger; import org.overture.codegen.merging.MergeVisitor; import org.overture.codegen.merging.TemplateStructure; +import org.overture.codegen.trans.TempVarPrefixes; import org.overture.codegen.utils.GeneratedModule; import org.overturetool.cgisa.ir.ExtIrClassDeclStatus; import org.overturetool.cgisa.transformations.GroupMutRecs; @@ -55,11 +57,15 @@ public IsaCodeGen() { this(null); } - + public IsaCodeGen(ILogger log) { - super(log); + + super(); + this.varPrefixes = new TempVarPrefixes(); + this.generator = new ExtIrGenerator(log, OBJ_INIT_CALL_NAME_PREFIX); initVelocity(); + } private void initVelocity() @@ -67,7 +73,7 @@ private void initVelocity() Velocity.setProperty("runtime.log.logsystem.class", "org.apache.velocity.runtime.log.NullLogSystem"); Velocity.init(); } - + /** * Main entry point into the Isabelle CG component. Takes an AST and returns corresponding Isabelle Syntax. * @@ -95,39 +101,35 @@ List generateIsabelleSyntax(List ast) } // Apply transformations (none atm...) - + List transformed = new Vector<>(); - + for (IRClassDeclStatus status : statuses) { SortDependencies sortTrans = new SortDependencies(status.getClassCg().getFunctions()); generator.applyTransformation(status, sortTrans); - ExtIrClassDeclStatus eStatus =new ExtIrClassDeclStatus(status); + ExtIrClassDeclStatus eStatus = new ExtIrClassDeclStatus(status); GroupMutRecs groupMR = new GroupMutRecs(); generator.applyTransformation(eStatus, groupMR); transformed.add(eStatus); } - - - // Apply merge visitor to pretty print isabelle syntax + // Apply merge visitor to pretty print isabelle syntax TemplateStructure ts = new TemplateStructure("IsaTemplates"); IsaTranslations isa = new IsaTranslations(ts); - - MergeVisitor pp = isa.getMergeVisitor(); + MergeVisitor pp = isa.getMergeVisitor(); List generated = new ArrayList(); - for (ExtIrClassDeclStatus status : transformed) { AExtClassDeclCG irClass = status.getEClassCg(); StringWriter sw = new StringWriter(); - + irClass.apply(pp, sw); if (pp.hasMergeErrors()) @@ -146,7 +148,7 @@ List generateIsabelleSyntax(List ast) } } - + // Return syntax return generated; From a6b682f6d8e43b95962704593f1462f050b94335 Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Fri, 27 Feb 2015 15:17:54 +0100 Subject: [PATCH 159/323] Expose IRGenerator. Needed for CGIsa --- .../src/main/java/org/overture/codegen/ir/CodeGenBase.java | 4 ++++ .../src/main/java/org/overture/codegen/ir/IRGenerator.java | 2 +- 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/ir/CodeGenBase.java b/core/codegen/src/main/java/org/overture/codegen/ir/CodeGenBase.java index 87f49d202b..3f8b9a788e 100644 --- a/core/codegen/src/main/java/org/overture/codegen/ir/CodeGenBase.java +++ b/core/codegen/src/main/java/org/overture/codegen/ir/CodeGenBase.java @@ -41,6 +41,10 @@ public CodeGenBase(ILogger log) this.generator = new IRGenerator(log, OBJ_INIT_CALL_NAME_PREFIX); } + protected CodeGenBase(){ + super(); + } + public void setIRGenerator(IRGenerator generator) { this.generator = generator; diff --git a/core/codegen/src/main/java/org/overture/codegen/ir/IRGenerator.java b/core/codegen/src/main/java/org/overture/codegen/ir/IRGenerator.java index ada3cb8e3d..edc14d4576 100644 --- a/core/codegen/src/main/java/org/overture/codegen/ir/IRGenerator.java +++ b/core/codegen/src/main/java/org/overture/codegen/ir/IRGenerator.java @@ -36,7 +36,7 @@ public class IRGenerator { - private IRInfo codeGenInfo; + protected IRInfo codeGenInfo; public IRGenerator(ILogger log, String objectInitCallPrefix) { From 7bd5f510fdcae4806829ce266760ce95884dc61d Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Fri, 27 Feb 2015 17:42:18 +0100 Subject: [PATCH 160/323] Introduced the notion of a 'void value' into the Java code generation runtime library --- .../src/main/java/org/overture/codegen/runtime/Utils.java | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/Utils.java b/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/Utils.java index a152813480..e2e9e5ca69 100644 --- a/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/Utils.java +++ b/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/Utils.java @@ -23,6 +23,8 @@ public class Utils { + public static final Object VOID_VALUE = new Object(); + public static int hashCode(Object... fields) { if(fields == null) @@ -89,6 +91,10 @@ public static String toString(Object obj) { return "nil"; } + else if(obj == VOID_VALUE) + { + return "()"; + } else if(obj instanceof Number) { Number n = (Number) obj; From 06cc37d4cccd98ce1fca85514c9c999df7660605 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Fri, 27 Feb 2015 17:44:29 +0100 Subject: [PATCH 161/323] Added the VDM entry expression to the Java code generator settings --- .../org/overture/codegen/vdm2java/JavaSettings.java | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaSettings.java b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaSettings.java index 33e45dddd2..19124afe93 100644 --- a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaSettings.java +++ b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaSettings.java @@ -28,10 +28,13 @@ public class JavaSettings { private boolean disableCloning; private List classesToSkip; + private String vdmEntryExp; public JavaSettings() { + this.disableCloning = false; this.classesToSkip = new LinkedList(); + this.vdmEntryExp = null; } public List getClassesToSkip() @@ -56,4 +59,14 @@ public void setDisableCloning(boolean disableCloning) { this.disableCloning = disableCloning; } + + public String getVdmEntryExp() + { + return vdmEntryExp; + } + + public void setVdmEntryExp(String vdmLaunchConfigEntryExp) + { + this.vdmEntryExp = vdmLaunchConfigEntryExp; + } } From dcb5a8fada3ffa45c75aa8a6323541238f33e713 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Fri, 27 Feb 2015 18:35:14 +0100 Subject: [PATCH 162/323] The 'Java main tag' is used to mark the class that will hold the entry point of the generated Java code --- .../codegen/vdm2java/JavaMainTag.java | 44 +++++++++++++++++++ 1 file changed, 44 insertions(+) create mode 100644 core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaMainTag.java diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaMainTag.java b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaMainTag.java new file mode 100644 index 0000000000..a020a84e53 --- /dev/null +++ b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaMainTag.java @@ -0,0 +1,44 @@ +package org.overture.codegen.vdm2java; + +import org.overture.codegen.cgast.declarations.AClassDeclCG; +import org.overture.codegen.cgast.declarations.AMethodDeclCG; +import org.overture.codegen.cgast.types.AVoidTypeCG; + + +public class JavaMainTag +{ + private boolean isVoidRun; + + public JavaMainTag(AClassDeclCG classCg) + { + checkRunReturnType(classCg); + } + + private void checkRunReturnType(AClassDeclCG classCg) + { + isVoidRun = false; + for(AMethodDeclCG m : classCg.getMethods()) + { + if(m.getName().equals("Run") && m.getMethodType().getResult() instanceof AVoidTypeCG) + { + isVoidRun = true; + } + } + } + + public String getMainMethod() + { + String body; + + if(isVoidRun) + { + body = "Run();IO.println(Utils.toString(Utils.VOID_VALUE));"; + } + else + { + body = "IO.println(Utils.toString(Run()));"; + } + + return "public static void main(String[] args){ " + body + " }"; + } +} From 4c9e0df5096e9dc04ce0e43638541a1ef94e8c8e Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Fri, 27 Feb 2015 18:44:04 +0100 Subject: [PATCH 163/323] In case a Java class is marked with a 'Java main' tag it will generate the corresponding main method --- .../main/java/org/overture/codegen/vdm2java/JavaFormat.java | 5 +++++ .../src/main/resources/JavaTemplates/Declarations/Class.vm | 6 +++++- 2 files changed, 10 insertions(+), 1 deletion(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaFormat.java b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaFormat.java index 11618aabb6..589ffeef72 100644 --- a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaFormat.java +++ b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaFormat.java @@ -929,4 +929,9 @@ public static boolean isScoped(ABlockStmCG block) { return block != null && block.getScoped() != null && block.getScoped(); } + + public static boolean isMainClass(AClassDeclCG clazz) + { + return clazz != null && clazz.getTag() instanceof JavaMainTag; + } } diff --git a/core/codegen/src/main/resources/JavaTemplates/Declarations/Class.vm b/core/codegen/src/main/resources/JavaTemplates/Declarations/Class.vm index 045fdb8ca7..569f471edb 100644 --- a/core/codegen/src/main/resources/JavaTemplates/Declarations/Class.vm +++ b/core/codegen/src/main/resources/JavaTemplates/Declarations/Class.vm @@ -40,7 +40,11 @@ $abstract $node.getAccess() $static class $node.getName() $JavaFormat.formatSupe #foreach( $method in $node.getMethods() ) $JavaFormat.format($method) #end - + ## + #if ($JavaFormat.isMainClass($node)) + $node.getTag().getMainMethod() + #end + #foreach( $typeDecl in $node.getTypeDecls() ) #if (!$JavaFormat.isNamedTypeDecl($typeDecl)) $JavaFormat.format($typeDecl) From 13472676cb5d18c96425ac6b4ca54ae655a2efaa Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Fri, 27 Feb 2015 18:50:58 +0100 Subject: [PATCH 164/323] Updated the 'GeneralCodeGenUtils' with functionality to support construction of a Java main class The functionality includes - Parsing of the entry expression and the main class - Type checking of the entry expression and the main class --- .../codegen/utils/GeneralCodeGenUtils.java | 163 ++++++++++++++++++ 1 file changed, 163 insertions(+) diff --git a/core/codegen/src/main/java/org/overture/codegen/utils/GeneralCodeGenUtils.java b/core/codegen/src/main/java/org/overture/codegen/utils/GeneralCodeGenUtils.java index ca131b3ea5..615eb84629 100644 --- a/core/codegen/src/main/java/org/overture/codegen/utils/GeneralCodeGenUtils.java +++ b/core/codegen/src/main/java/org/overture/codegen/utils/GeneralCodeGenUtils.java @@ -36,11 +36,33 @@ import org.overture.ast.analysis.AnalysisException; import org.overture.ast.definitions.SClassDefinition; import org.overture.ast.expressions.PExp; +import org.overture.ast.factory.AstFactory; +import org.overture.ast.lex.Dialect; +import org.overture.ast.lex.LexLocation; +import org.overture.ast.lex.LexNameToken; +import org.overture.ast.typechecker.NameScope; +import org.overture.ast.types.AVoidType; +import org.overture.ast.util.definitions.ClassList; +import org.overture.codegen.ir.ITempVarGen; import org.overture.codegen.logging.Logger; +import org.overture.parser.lex.LexException; +import org.overture.parser.lex.LexTokenReader; +import org.overture.parser.messages.Console; +import org.overture.parser.messages.VDMErrorsException; +import org.overture.parser.syntax.ClassReader; +import org.overture.parser.syntax.ExpressionReader; +import org.overture.parser.syntax.ParserException; import org.overture.parser.util.ParserUtil; import org.overture.parser.util.ParserUtil.ParserResult; +import org.overture.typechecker.ClassTypeChecker; +import org.overture.typechecker.Environment; +import org.overture.typechecker.PublicClassEnvironment; +import org.overture.typechecker.TypeCheckInfo; +import org.overture.typechecker.TypeChecker; +import org.overture.typechecker.assistant.TypeCheckerAssistantFactory; import org.overture.typechecker.util.TypeCheckerUtil; import org.overture.typechecker.util.TypeCheckerUtil.TypeCheckResult; +import org.overture.typechecker.visitor.TypeCheckVisitor; public class GeneralCodeGenUtils { @@ -108,6 +130,147 @@ public static TypeCheckResult validateExp(String exp) return typeCheckResult; } + + public static SClassDefinition consMainClass(List mergedParseLists, + String expression, Dialect dialect, String mainClassName, + ITempVarGen nameGen) + { + try + { + ClassList classes = new ClassList(); + classes.addAll(mergedParseLists); + PExp entryExp = typeCheckEntryPoint(classes, expression, dialect); + + String resultTypeStr = entryExp.getType() instanceof AVoidType ? "()" + : "?"; + + // Collect all the class names + List namesToAvoid = new LinkedList<>(); + + for (SClassDefinition c : classes) + { + namesToAvoid.add(c.getName().getName()); + } + + // If the user already uses the name proposed for the main class + // we have to find a new name for the main class + if (namesToAvoid.contains(mainClassName)) + { + String prefix = mainClassName + "_"; + mainClassName = nameGen.nextVarName(prefix); + + while (namesToAvoid.contains(mainClassName)) + { + mainClassName = nameGen.nextVarName(prefix); + } + } + + String entryClassTemplate = + "class " + mainClassName + "\n" + + "operations\n" + "public static Run : () ==> " + + resultTypeStr + "\n" + "Run () == " + expression + ";\n" + + "end " + mainClassName; + + SClassDefinition clazz = parseClass(entryClassTemplate, mainClassName, dialect); + + return tcClass(classes, clazz); + + } catch (VDMErrorsException | AnalysisException e) + { + Logger.getLog().printErrorln("Problems encountered when constructing the main class in 'GeneralCodeGenUtils'"); + e.printStackTrace(); + return null; + } + } + + public static PExp typeCheckEntryPoint(ClassList classes, String expression, Dialect dialect) + throws VDMErrorsException, AnalysisException + { + SClassDefinition defaultModule = null; + + LexNameToken name =new LexNameToken("CLASS", "DEFAULT", new LexLocation()); + defaultModule = AstFactory.newAClassClassDefinition(name, null, null); + defaultModule.setUsed(true); + PExp exp = parseExpression(expression, defaultModule.getName().getName(),dialect); + + return tcExp(classes, exp); + } + + public static PExp tcExp(ClassList classes, PExp exp) + throws AnalysisException, VDMErrorsException + { + TypeCheckerAssistantFactory af = new TypeCheckerAssistantFactory(); + ClassTypeChecker.clearErrors(); + ClassTypeChecker classTc = new ClassTypeChecker(classes, af); + + classTc.typeCheck(); + + TypeCheckVisitor tc = new TypeCheckVisitor(); + TypeChecker.clearErrors(); + Environment env = new PublicClassEnvironment(af, classes, null); + + exp.apply(tc, new TypeCheckInfo(af, env, NameScope.NAMESANDSTATE)); + + if (TypeChecker.getErrorCount() > 0) + { + throw new VDMErrorsException(TypeChecker.getErrors()); + } + else + { + return exp; + } + } + + public static SClassDefinition tcClass(ClassList classes, + SClassDefinition clazz) throws AnalysisException, + VDMErrorsException + + { + TypeCheckerAssistantFactory af = new TypeCheckerAssistantFactory(); + ClassTypeChecker.clearErrors(); + ClassTypeChecker classTc = new ClassTypeChecker(classes, af); + + classes.add(clazz); + classTc.typeCheck(); + + if (TypeChecker.getErrorCount() > 0) + { + throw new VDMErrorsException(TypeChecker.getErrors()); + } + else + { + return clazz; + } + } + + public static PExp parseExpression(String expression, + String defaultModuleName, Dialect dialect) throws ParserException, LexException + { + LexTokenReader ltr = new LexTokenReader(expression, dialect, Console.charset); + ExpressionReader reader = new ExpressionReader(ltr); + reader.setCurrentModule(defaultModuleName); + + return reader.readExpression(); + } + + public static SClassDefinition parseClass(String classStr, + String defaultModuleName, Dialect dialect) throws ParserException, LexException + { + LexTokenReader ltr = new LexTokenReader(classStr, dialect, Console.charset); + ClassReader reader = new ClassReader(ltr); + reader.setCurrentModule(defaultModuleName); + + // There should be only one class + for(SClassDefinition clazz : reader.readClasses()) + { + if(clazz.getName().getName().equals(defaultModuleName)) + { + return clazz; + } + } + + return null; + } public static void replaceInFile(File file, String regex, String replacement) { From 25928cca48a586100e5ed19fdcb53f21d31c1ece Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Fri, 27 Feb 2015 19:00:49 +0100 Subject: [PATCH 165/323] Added functionality that enables the user to choose a launch configuration as input for the Java code generator --- .../codegen/util/LaunchConfigData.java | 29 ++++ .../codegen/util/PluginVdm2JavaUtil.java | 137 ++++++++++++++---- 2 files changed, 135 insertions(+), 31 deletions(-) create mode 100644 ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/util/LaunchConfigData.java diff --git a/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/util/LaunchConfigData.java b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/util/LaunchConfigData.java new file mode 100644 index 0000000000..e8bbf56131 --- /dev/null +++ b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/util/LaunchConfigData.java @@ -0,0 +1,29 @@ +package org.overture.ide.plugins.codegen.util; + +public class LaunchConfigData +{ + private String name; + private String exp; + + public LaunchConfigData(String name, String exp) + { + this.name = name; + this.exp = exp; + } + + public String getName() + { + return name; + } + + public String getExp() + { + return exp; + } + + @Override + public String toString() + { + return name + " - " + exp; + } +} diff --git a/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/util/PluginVdm2JavaUtil.java b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/util/PluginVdm2JavaUtil.java index 3f0d4b0943..2281158dc7 100644 --- a/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/util/PluginVdm2JavaUtil.java +++ b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/util/PluginVdm2JavaUtil.java @@ -27,6 +27,7 @@ import java.io.InputStream; import java.io.OutputStream; import java.util.ArrayList; +import java.util.LinkedList; import java.util.List; import java.util.Set; @@ -40,8 +41,14 @@ import org.eclipse.core.runtime.IPath; import org.eclipse.core.runtime.Path; import org.eclipse.core.runtime.preferences.InstanceScope; +import org.eclipse.debug.core.DebugPlugin; +import org.eclipse.debug.core.ILaunchConfiguration; import org.eclipse.jface.viewers.ISelection; import org.eclipse.jface.viewers.IStructuredSelection; +import org.eclipse.jface.viewers.LabelProvider; +import org.eclipse.swt.widgets.Shell; +import org.eclipse.ui.PlatformUI; +import org.eclipse.ui.dialogs.ElementListSelectionDialog; import org.eclipse.ui.handlers.HandlerUtil; import org.osgi.service.prefs.Preferences; import org.overture.ast.definitions.SClassDefinition; @@ -56,6 +63,8 @@ import org.overture.ide.core.resources.IVdmProject; import org.overture.ide.core.resources.IVdmSourceUnit; import org.overture.ide.core.utility.FileUtility; +import org.overture.ide.debug.core.IDebugConstants; +import org.overture.ide.plugins.codegen.CodeGenConsole; import org.overture.ide.plugins.codegen.ICodeGenConstants; import org.overture.ide.plugins.codegen.commands.Vdm2JavaCommand; @@ -74,7 +83,6 @@ public class PluginVdm2JavaUtil public static final String CODEGEN_RUNTIME_SRC_FOLDER_NAME = "src"; public static final String CODEGEN_RUNTIME_LIB_FOLDER_NAME = "lib"; - private PluginVdm2JavaUtil() { } @@ -255,52 +263,119 @@ private static File getFolder(File parent, String folder) resultingFolder.mkdirs(); return resultingFolder; } - - public static void copyCodeGenFile(String inOutFileName, File outputFolder) throws IOException + + public static void copyCodeGenFile(String inOutFileName, File outputFolder) + throws IOException { copyCodeGenFile(inOutFileName, inOutFileName, outputFolder); } - - public static void copyCodeGenFile(String inputFileName, String outputFileName, File outputFolder) throws IOException + + public static void copyCodeGenFile(String inputFileName, + String outputFileName, File outputFolder) throws IOException { InputStream input = Vdm2JavaCommand.class.getResourceAsStream('/' + inputFileName); - - if(input == null) + + if (input == null) { throw new IOException("Could not find resource: " + inputFileName); } - + byte[] buffer = new byte[8 * 1024]; - try { - File outputFile = new File(outputFolder, outputFileName); - - outputFile.getParentFile().mkdirs(); - if(!outputFile.exists()) - { - outputFile.createNewFile(); - } - - OutputStream output = new FileOutputStream(outputFile); - try { - int bytesRead; - while ((bytesRead = input.read(buffer)) != -1) { - output.write(buffer, 0, bytesRead); - } - } finally { - output.close(); - } - } finally { - input.close(); + try + { + File outputFile = new File(outputFolder, outputFileName); + + outputFile.getParentFile().mkdirs(); + if (!outputFile.exists()) + { + outputFile.createNewFile(); + } + + OutputStream output = new FileOutputStream(outputFile); + try + { + int bytesRead; + while ((bytesRead = input.read(buffer)) != -1) + { + output.write(buffer, 0, bytesRead); + } + } finally + { + output.close(); + } + } finally + { + input.close(); } } - + public static List getClassesToSkip() { Preferences preferences = InstanceScope.INSTANCE.getNode(ICodeGenConstants.PLUGIN_ID); - + String userInput = preferences.get(ICodeGenConstants.CLASSES_TO_SKIP, ICodeGenConstants.CLASSES_TO_SKIP_DEFAULT); - + return GeneralCodeGenUtils.getClassesToSkip(userInput); } + + public static String dialog(final IProject project) + { + List matches = getProjectLaunchConfigs(project); + + Shell shell = PlatformUI.getWorkbench().getDisplay().getActiveShell(); + + ElementListSelectionDialog dialog = new ElementListSelectionDialog(shell, new LabelProvider()); + dialog.setTitle("Launch Configuration Selection"); + dialog.setMessage("Select a Launch configuration (* = any string, ? = any char):"); + dialog.setMultipleSelection(false); + dialog.setElements(matches.toArray()); + + int resCode = dialog.open(); + + if (resCode == ElementListSelectionDialog.OK) + { + Object[] dialogResult = dialog.getResult(); + + if (dialogResult.length == 1 + && dialogResult[0] instanceof LaunchConfigData) + { + LaunchConfigData chosenConfig = (LaunchConfigData) dialogResult[0]; + + return chosenConfig.getExp(); + } + } + + return null; + } + + private static List getProjectLaunchConfigs(final IProject project) + { + List matches = new LinkedList<>(); + + try + { + ILaunchConfiguration[] configs = DebugPlugin.getDefault().getLaunchManager().getLaunchConfigurations(); + + for (ILaunchConfiguration launchConfig : configs) + { + String launchConfigProjectName = launchConfig.getAttribute(IDebugConstants.VDM_LAUNCH_CONFIG_PROJECT, ""); + + if (launchConfigProjectName != null && !launchConfigProjectName.equals("") + && launchConfigProjectName.equals(project.getName())) + { + String exp = launchConfig.getAttribute(IDebugConstants.VDM_LAUNCH_CONFIG_EXPRESSION, ""); + matches.add(new LaunchConfigData(launchConfig.getName(), exp)); + } + } + } catch (CoreException e) + { + + CodeGenConsole.GetInstance().printErrorln("Problem looking up launch configurations for project " + + project.getName() + ": " + e.getMessage()); + e.printStackTrace(); + } + + return matches; + } } From 1db6b473505ff7568c627e1e8e273ad9498d368d Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Fri, 27 Feb 2015 19:07:49 +0100 Subject: [PATCH 166/323] The core of the Java code generator now supports launch configuration based code generation --- .../codegen/vdm2java/JavaCodeGen.java | 24 ++++++++++++++++--- 1 file changed, 21 insertions(+), 3 deletions(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java index 0f41ad8a8e..7a3f7447c9 100644 --- a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java +++ b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java @@ -68,10 +68,12 @@ import org.overture.codegen.merging.TemplateStructure; import org.overture.codegen.trans.assistants.TransAssistantCG; import org.overture.codegen.trans.funcvalues.FunctionValueAssistant; +import org.overture.codegen.utils.GeneralCodeGenUtils; import org.overture.codegen.utils.GeneralUtils; import org.overture.codegen.utils.Generated; import org.overture.codegen.utils.GeneratedData; import org.overture.codegen.utils.GeneratedModule; +import org.overture.config.Settings; public class JavaCodeGen extends CodeGenBase { @@ -82,6 +84,8 @@ public class JavaCodeGen extends CodeGenBase "Utils", "Record", "Long", "Double", "Character", "String", "List", "Set" }; + public static final String JAVA_MAIN_CLASS_NAME = "Main"; + private JavaFormat javaFormat; private TemplateStructure javaTemplateStructure; @@ -189,11 +193,20 @@ public List generateJavaFromVdmQuotes() return null; } - + public GeneratedData generateJavaFromVdm( List mergedParseLists) throws AnalysisException, UnsupportedModelingException { + SClassDefinition mainClass = null; + + if(getJavaSettings().getVdmEntryExp() != null) + { + mainClass = GeneralCodeGenUtils.consMainClass(mergedParseLists, getJavaSettings().getVdmEntryExp(), + Settings.dialect, JAVA_MAIN_CLASS_NAME, getInfo().getTempVarNameGen()); + mergedParseLists.add(mainClass); + } + // To document any renaming of variables shadowing other variables removeUnreachableStms(mergedParseLists); List allRenamings = performRenaming(mergedParseLists); @@ -266,16 +279,21 @@ public GeneratedData generateJavaFromVdm( StringWriter writer = new StringWriter(); AClassDeclCG classCg = status.getClassCg(); String className = status.getClassName(); + SClassDefinition vdmClass = (SClassDefinition) status.getClassCg().getSourceNode().getVdmNode(); + + if(vdmClass == mainClass) + { + classCg.setTag(new JavaMainTag(classCg)); + } javaFormat.init(); try { - SClassDefinition vdmClass = (SClassDefinition) status.getClassCg().getSourceNode().getVdmNode(); if (shouldBeGenerated(vdmClass, generator.getIRInfo().getAssistantManager().getDeclAssistant())) { classCg.apply(mergeVisitor, writer); - + if (mergeVisitor.hasMergeErrors()) { generated.add(new GeneratedModule(className, classCg, mergeVisitor.getMergeErrors())); From 940d0e6b8d90f37fe29f49ff1d157acf32aafb04 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Fri, 27 Feb 2015 19:11:46 +0100 Subject: [PATCH 167/323] #421 Finished work on launch configuration based Java code generation --- ide/plugins/codegen/plugin.xml | 32 ++++++++++ .../codegen/commands/Vdm2JavaCommand.java | 60 ++++++++++++------- .../commands/Vdm2JavaLaunchConfigCommand.java | 23 +++++++ 3 files changed, 94 insertions(+), 21 deletions(-) create mode 100644 ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaLaunchConfigCommand.java diff --git a/ide/plugins/codegen/plugin.xml b/ide/plugins/codegen/plugin.xml index 3d8ce48a26..dced944b08 100644 --- a/ide/plugins/codegen/plugin.xml +++ b/ide/plugins/codegen/plugin.xml @@ -9,6 +9,11 @@ id="org.overture.ide.plugins.codegen.vdm2java" name="VDM to Java"> + + + + + + + + + + + + + + + + + mergedParseLists = consMergedParseList(project, model); + final List classesToSkip = PluginVdm2JavaUtil.getClassesToSkip(); + final IRSettings irSettings = getIrSettings(project); + final JavaSettings javaSettings = getJavaSettings(project, classesToSkip); + Job codeGenerate = new Job("Code generate") { @Override @@ -159,23 +163,6 @@ protected IStatus run(IProgressMonitor monitor) { // Begin code generation final JavaCodeGen vdm2java = new JavaCodeGen(); - - Preferences preferences = InstanceScope.INSTANCE.getNode(ICodeGenConstants.PLUGIN_ID); - - boolean generateCharSeqsAsStrings = preferences.getBoolean(ICodeGenConstants.GENERATE_CHAR_SEQUENCES_AS_STRINGS, ICodeGenConstants.GENERATE_CHAR_SEQUENCES_AS_STRING_DEFAULT); - boolean generateConcMechanisms = preferences.getBoolean(ICodeGenConstants.GENERATE_CONCURRENCY_MECHANISMS, ICodeGenConstants.GENERATE_CONCURRENCY_MECHANISMS_DEFAULT); - - IRSettings irSettings = new IRSettings(); - irSettings.setCharSeqAsString(generateCharSeqsAsStrings); - irSettings.setGenerateConc(generateConcMechanisms); - - boolean disableCloning = preferences.getBoolean(ICodeGenConstants.DISABLE_CLONING, ICodeGenConstants.DISABLE_CLONING_DEFAULT); - - JavaSettings javaSettings = new JavaSettings(); - javaSettings.setDisableCloning(disableCloning); - List classesToSkip = PluginVdm2JavaUtil.getClassesToSkip(); - javaSettings.setClassesToSkip(classesToSkip); - vdm2java.setSettings(irSettings); vdm2java.setJavaSettings(javaSettings); @@ -190,8 +177,6 @@ protected IStatus run(IProgressMonitor monitor) GeneralUtils.deleteFolderContents(outputFolder); // Generate user specified classes - List sources = model.getSourceUnits(); - List mergedParseLists = PluginVdm2JavaUtil.mergeParseLists(sources); GeneratedData generatedData = vdm2java.generateJavaFromVdm(mergedParseLists); outputUserSpecifiedSkippedClasses(classesToSkip); @@ -306,7 +291,40 @@ protected IStatus run(IProgressMonitor monitor) return null; } + + public IRSettings getIrSettings(final IProject project) + { + Preferences preferences = InstanceScope.INSTANCE.getNode(ICodeGenConstants.PLUGIN_ID); + + boolean generateCharSeqsAsStrings = preferences.getBoolean(ICodeGenConstants.GENERATE_CHAR_SEQUENCES_AS_STRINGS, ICodeGenConstants.GENERATE_CHAR_SEQUENCES_AS_STRING_DEFAULT); + boolean generateConcMechanisms = preferences.getBoolean(ICodeGenConstants.GENERATE_CONCURRENCY_MECHANISMS, ICodeGenConstants.GENERATE_CONCURRENCY_MECHANISMS_DEFAULT); + + IRSettings irSettings = new IRSettings(); + irSettings.setCharSeqAsString(generateCharSeqsAsStrings); + irSettings.setGenerateConc(generateConcMechanisms); + + return irSettings; + } + + public JavaSettings getJavaSettings(final IProject project, List classesToSkip) + { + Preferences preferences = InstanceScope.INSTANCE.getNode(ICodeGenConstants.PLUGIN_ID); + + boolean disableCloning = preferences.getBoolean(ICodeGenConstants.DISABLE_CLONING, ICodeGenConstants.DISABLE_CLONING_DEFAULT); + + JavaSettings javaSettings = new JavaSettings(); + javaSettings.setDisableCloning(disableCloning); + javaSettings.setClassesToSkip(classesToSkip); + + return javaSettings; + } + public List consMergedParseList(final IProject project, + final IVdmModel model) + { + return PluginVdm2JavaUtil.mergeParseLists(model.getSourceUnits()); + } + private void deleteMarkers(IProject project) { if (project == null) @@ -372,7 +390,7 @@ private void outputRenamings(List allRenamings) private void outputRuntimeBinaries(File outputFolder) { File runtime = new File(outputFolder, PluginVdm2JavaUtil.CODEGEN_RUNTIME_BIN_FILE_NAME); - CodeGenConsole.GetInstance().println("Copied the Java code generator runtime library to " + runtime.getAbsolutePath() + "\n"); + CodeGenConsole.GetInstance().println("Copied the Java code generator runtime library to " + runtime.getAbsolutePath()); } private void outputRuntimeSources(File outputFolder) diff --git a/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaLaunchConfigCommand.java b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaLaunchConfigCommand.java new file mode 100644 index 0000000000..addde5846d --- /dev/null +++ b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaLaunchConfigCommand.java @@ -0,0 +1,23 @@ +package org.overture.ide.plugins.codegen.commands; + +import java.util.List; + +import org.eclipse.core.resources.IProject; +import org.overture.codegen.vdm2java.JavaSettings; +import org.overture.ide.plugins.codegen.util.PluginVdm2JavaUtil; + +public class Vdm2JavaLaunchConfigCommand extends Vdm2JavaCommand +{ + @Override + public JavaSettings getJavaSettings(IProject project, + List classesToSkip) + { + JavaSettings javaSettings = super.getJavaSettings(project, classesToSkip); + + String entryExp = PluginVdm2JavaUtil.dialog(project); + + javaSettings.setVdmLaunchConfigEntryExp(entryExp); + + return javaSettings; + } +} From c8ee7f65741369b270399e799744f66987c05a28 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Fri, 27 Feb 2015 20:07:32 +0100 Subject: [PATCH 168/323] Launch configuration based Java code generation now outputs warnings if no launch configurations can be found --- ide/plugins/codegen/plugin.xml | 2 +- .../codegen/commands/Vdm2JavaCommand.java | 8 +++---- .../commands/Vdm2JavaLaunchConfigCommand.java | 23 ++++++++++++++----- .../codegen/util/PluginVdm2JavaUtil.java | 8 +++---- 4 files changed, 25 insertions(+), 16 deletions(-) diff --git a/ide/plugins/codegen/plugin.xml b/ide/plugins/codegen/plugin.xml index dced944b08..500863cb27 100644 --- a/ide/plugins/codegen/plugin.xml +++ b/ide/plugins/codegen/plugin.xml @@ -53,7 +53,7 @@ diff --git a/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaCommand.java b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaCommand.java index c9a011a82c..2134905a58 100644 --- a/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaCommand.java +++ b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaCommand.java @@ -112,7 +112,8 @@ public Object execute(ExecutionEvent event) throws ExecutionException } CodeGenConsole.GetInstance().activate(); - + CodeGenConsole.GetInstance().clearConsole(); + deleteMarkers(project); final IVdmModel model = vdmProject.getModel(); @@ -151,6 +152,8 @@ public Object execute(ExecutionEvent event) throws ExecutionException return null; } + CodeGenConsole.GetInstance().println("Starting VDM++ to Java code generation...\n"); + final List mergedParseLists = consMergedParseList(project, model); final List classesToSkip = PluginVdm2JavaUtil.getClassesToSkip(); final IRSettings irSettings = getIrSettings(project); @@ -168,9 +171,6 @@ protected IStatus run(IProgressMonitor monitor) try { - CodeGenConsole.GetInstance().clearConsole(); - CodeGenConsole.GetInstance().println("Starting VDM++ to Java code generation...\n"); - File outputFolder = PluginVdm2JavaUtil.getOutputFolder(vdmProject); // Clean folder with generated Java code diff --git a/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaLaunchConfigCommand.java b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaLaunchConfigCommand.java index addde5846d..9ee5436cc2 100644 --- a/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaLaunchConfigCommand.java +++ b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaLaunchConfigCommand.java @@ -4,20 +4,31 @@ import org.eclipse.core.resources.IProject; import org.overture.codegen.vdm2java.JavaSettings; +import org.overture.ide.plugins.codegen.CodeGenConsole; +import org.overture.ide.plugins.codegen.util.LaunchConfigData; import org.overture.ide.plugins.codegen.util.PluginVdm2JavaUtil; public class Vdm2JavaLaunchConfigCommand extends Vdm2JavaCommand { + private static final String WARNING = "[WARNING]"; @Override public JavaSettings getJavaSettings(IProject project, List classesToSkip) { - JavaSettings javaSettings = super.getJavaSettings(project, classesToSkip); - - String entryExp = PluginVdm2JavaUtil.dialog(project); - - javaSettings.setVdmLaunchConfigEntryExp(entryExp); - + JavaSettings javaSettings = super.getJavaSettings(project, classesToSkip); + + List launchConfigs = PluginVdm2JavaUtil.getProjectLaunchConfigs(project); + + if (!launchConfigs.isEmpty()) + { + String entryExp = PluginVdm2JavaUtil.dialog(launchConfigs); + javaSettings.setVdmEntryExp(entryExp); + } else + { + CodeGenConsole.GetInstance().println(WARNING + " No launch configuration could be found for this project."); + CodeGenConsole.GetInstance().println(WARNING + " Continuing Java code generation without launch configuration...\n"); + } + return javaSettings; } } diff --git a/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/util/PluginVdm2JavaUtil.java b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/util/PluginVdm2JavaUtil.java index 2281158dc7..1c8a12763f 100644 --- a/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/util/PluginVdm2JavaUtil.java +++ b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/util/PluginVdm2JavaUtil.java @@ -319,17 +319,15 @@ public static List getClassesToSkip() return GeneralCodeGenUtils.getClassesToSkip(userInput); } - public static String dialog(final IProject project) + public static String dialog(List launchConfigs) { - List matches = getProjectLaunchConfigs(project); - Shell shell = PlatformUI.getWorkbench().getDisplay().getActiveShell(); ElementListSelectionDialog dialog = new ElementListSelectionDialog(shell, new LabelProvider()); dialog.setTitle("Launch Configuration Selection"); dialog.setMessage("Select a Launch configuration (* = any string, ? = any char):"); dialog.setMultipleSelection(false); - dialog.setElements(matches.toArray()); + dialog.setElements(launchConfigs.toArray()); int resCode = dialog.open(); @@ -349,7 +347,7 @@ public static String dialog(final IProject project) return null; } - private static List getProjectLaunchConfigs(final IProject project) + public static List getProjectLaunchConfigs(final IProject project) { List matches = new LinkedList<>(); From d1f9955362a65d49fc66095b7cb5ad98585a74fd Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Fri, 27 Feb 2015 21:45:30 +0100 Subject: [PATCH 169/323] Updated launch configuration based code generation The code generation process is now cancelled if 1) no launch configuration can be found or 2) the user presses 'Cancel' in the launch configuration dialog --- .../codegen/commands/Vdm2JavaCommand.java | 15 +++++++++---- .../commands/Vdm2JavaLaunchConfigCommand.java | 22 ++++++++++++++----- 2 files changed, 27 insertions(+), 10 deletions(-) diff --git a/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaCommand.java b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaCommand.java index 2134905a58..b7ac42e5d9 100644 --- a/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaCommand.java +++ b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaCommand.java @@ -151,19 +151,26 @@ public Object execute(ExecutionEvent event) throws ExecutionException + project.getName()); return null; } - + CodeGenConsole.GetInstance().println("Starting VDM++ to Java code generation...\n"); - final List mergedParseLists = consMergedParseList(project, model); final List classesToSkip = PluginVdm2JavaUtil.getClassesToSkip(); - final IRSettings irSettings = getIrSettings(project); final JavaSettings javaSettings = getJavaSettings(project, classesToSkip); + + final IRSettings irSettings = getIrSettings(project); + final List mergedParseLists = consMergedParseList(project, model); + - Job codeGenerate = new Job("Code generate") + Job codeGenerate = new Job("VDM++ to Java code generation") { @Override protected IStatus run(IProgressMonitor monitor) { + if(javaSettings == null) + { + return Status.CANCEL_STATUS; + } + // Begin code generation final JavaCodeGen vdm2java = new JavaCodeGen(); vdm2java.setSettings(irSettings); diff --git a/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaLaunchConfigCommand.java b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaLaunchConfigCommand.java index 9ee5436cc2..b008588219 100644 --- a/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaLaunchConfigCommand.java +++ b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaLaunchConfigCommand.java @@ -11,24 +11,34 @@ public class Vdm2JavaLaunchConfigCommand extends Vdm2JavaCommand { private static final String WARNING = "[WARNING]"; + @Override public JavaSettings getJavaSettings(IProject project, List classesToSkip) { - JavaSettings javaSettings = super.getJavaSettings(project, classesToSkip); - List launchConfigs = PluginVdm2JavaUtil.getProjectLaunchConfigs(project); if (!launchConfigs.isEmpty()) { String entryExp = PluginVdm2JavaUtil.dialog(launchConfigs); - javaSettings.setVdmEntryExp(entryExp); + + if (entryExp != null) + { + JavaSettings javaSettings = super.getJavaSettings(project, classesToSkip); + javaSettings.setVdmEntryExp(entryExp); + return javaSettings; + } + else + { + CodeGenConsole.GetInstance().println("Process cancelled by user."); + } } else { - CodeGenConsole.GetInstance().println(WARNING + " No launch configuration could be found for this project."); - CodeGenConsole.GetInstance().println(WARNING + " Continuing Java code generation without launch configuration...\n"); + CodeGenConsole.GetInstance().println(WARNING + + " No launch configuration could be found for this project.\n"); + CodeGenConsole.GetInstance().println("Cancelling launch configuration based code generation...\n"); } - return javaSettings; + return null; } } From 72bb6198892761b1787a6e8b43c4ec643c60154f Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sat, 28 Feb 2015 08:58:54 +0100 Subject: [PATCH 170/323] Fixes to the Java code generation runtime library: - It was based on the old approach to generating quotes - Formatting is now done using the Utils library --- .../java/org/overture/codegen/runtime/IO.java | 37 ++++--------------- 1 file changed, 7 insertions(+), 30 deletions(-) diff --git a/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/IO.java b/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/IO.java index edc29c477b..4f9efaec9a 100644 --- a/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/IO.java +++ b/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/IO.java @@ -30,9 +30,6 @@ public class IO { - //private static final Number START = 1; - private static final Number APPEND = 2; - private static File BaseDIr = new File(".").getParentFile(); private static final String NOT_SUPPORTED_MSG = "Operation is currently not supported"; @@ -47,12 +44,12 @@ public static

boolean writeval(p val) { return true; } - public static

boolean fwriteval(String filename, p val, Number fdir) { + public static

boolean fwriteval(String filename, p val, Object fdir) { throw new UnsupportedOperationException(NOT_SUPPORTED_MSG); } - public static

boolean fwriteval(VDMSeq filename, p val, Number fdir) { + public static

boolean fwriteval(VDMSeq filename, p val, Object fdir) { throw new UnsupportedOperationException(NOT_SUPPORTED_MSG); } @@ -93,7 +90,7 @@ public boolean echo(VDMSeq text) { return fecho("[]", SeqUtil.toStr(text), null); } - public boolean fecho(String filename, String text, Number fdir) { + public boolean fecho(String filename, String text, Object fdir) { if (filename.equals("[]")) { @@ -104,7 +101,7 @@ public boolean fecho(String filename, String text, Number fdir) { try { File file = getFile(filename); - FileOutputStream fos = new FileOutputStream(file, fdir == APPEND); + FileOutputStream fos = new FileOutputStream(file, fdir.getClass().getName().equals("quotes.append")); fos.write(text.getBytes(Charset.defaultCharset().name())); fos.close(); @@ -117,7 +114,7 @@ public boolean fecho(String filename, String text, Number fdir) { return true; } - public boolean fecho(VDMSeq filename, VDMSeq text, Number fdir) { + public boolean fecho(VDMSeq filename, VDMSeq text, Object fdir) { return fecho(filename.toString(), text.toString(), fdir); } @@ -157,17 +154,7 @@ private static Object[] formatList(List args) for(int i = 0; i < args.size(); i++) { Object arg = args.get(i); - - if(arg instanceof Number) - { - Number n = (Number) arg; - - if(n.doubleValue() % 1 == 0) - { - int intVal = n.intValue(); - args.set(i, intVal); - } - } + args.set(i, formatArg(arg)); } return args.toArray(); @@ -175,16 +162,6 @@ private static Object[] formatList(List args) private static String formatArg(Object arg) { - if(arg instanceof Number) - { - Number n = (Number) arg; - - if(n.doubleValue() % 1 == 0) - { - return Integer.toString(n.intValue()); - } - } - - return arg.toString(); + return Utils.toString(arg); } } From 65192327576c1fad72388f4005981c66b6f21b24 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sat, 28 Feb 2015 09:37:34 +0100 Subject: [PATCH 171/323] Added support for the 'classname' operation in the 'VDMUtil' library --- .../java/org/overture/codegen/runtime/VDMUtil.java | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/VDMUtil.java b/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/VDMUtil.java index fc0bba7b72..b79ad59e84 100644 --- a/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/VDMUtil.java +++ b/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/VDMUtil.java @@ -6,4 +6,16 @@ public static String val2seq_of_char(Object value) { return Utils.toString(value); } + + public static String classname(Object obj) + { + if(obj != null && obj.getClass().getEnclosingClass() == null) + { + return obj.getClass().getSimpleName(); + } + else + { + return null; + } + } } From 3ea407344fd62ed8a996e9d5d0137c5d576b08a6 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sat, 28 Feb 2015 12:31:24 +0100 Subject: [PATCH 172/323] Updates to test results needed due to the introduction of the CallObjStm transformation --- .../ConcurrentWithLetBeSt.result | 8 ++------ .../traces_expansion_specs/LetBeStNested.result | 8 ++------ .../LetDefConsecutive.result | 8 ++------ .../LetDefConsecutiveRepeat.result | 8 ++------ .../traces_expansion_specs/ObjectBind.result | 4 +--- .../SharedObjectBind.result | 16 ++++------------ .../traces_verdict_specs/SameTestTwice.result | 8 ++------ 7 files changed, 15 insertions(+), 45 deletions(-) diff --git a/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentWithLetBeSt.result b/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentWithLetBeSt.result index 11173a81de..a94363f2fe 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentWithLetBeSt.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentWithLetBeSt.result @@ -40,9 +40,7 @@ public class Entry implements java.io.Serializable { CallStatement callStm_1 = new CallStatement() { public Object execute(final Object instance) { - Number result_1 = ((Entry) store.getValue(ID_1)).op(); - - return result_1; + return ((Entry) store.getValue(ID_1)).op(); } public String toString() { @@ -66,9 +64,7 @@ public class Entry implements java.io.Serializable { CallStatement callStm_2 = new CallStatement() { public Object execute(final Object instance) { - Number result_2 = ((Entry) store.getValue(ID_2)).op(); - - return result_2; + return ((Entry) store.getValue(ID_2)).op(); } public String toString() { diff --git a/core/codegen/src/test/resources/traces_expansion_specs/LetBeStNested.result b/core/codegen/src/test/resources/traces_expansion_specs/LetBeStNested.result index 2df43927f3..0a74df452b 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/LetBeStNested.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/LetBeStNested.result @@ -49,9 +49,7 @@ public class Entry implements java.io.Serializable { SequenceTraceNode sequence_2 = new SequenceTraceNode(); CallStatement callStm_1 = new CallStatement() { public Object execute(final Object instance) { - Number result_1 = ((Entry) store.getValue(ID_1)).op(); - - return result_1; + return ((Entry) store.getValue(ID_1)).op(); } public String toString() { @@ -63,9 +61,7 @@ public class Entry implements java.io.Serializable { CallStatement callStm_2 = new CallStatement() { public Object execute(final Object instance) { - Number result_2 = ((Entry) store.getValue(ID_2)).op(); - - return result_2; + return ((Entry) store.getValue(ID_2)).op(); } public String toString() { diff --git a/core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutive.result b/core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutive.result index 6f9c46ce5b..95fb793aed 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutive.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutive.result @@ -37,9 +37,7 @@ public class Entry implements java.io.Serializable { CallStatement callStm_1 = new CallStatement() { public Object execute(final Object instance) { - Number result_1 = ((Entry) store.getValue(ID_1)).op(); - - return result_1; + return ((Entry) store.getValue(ID_1)).op(); } public String toString() { @@ -58,9 +56,7 @@ public class Entry implements java.io.Serializable { CallStatement callStm_2 = new CallStatement() { public Object execute(final Object instance) { - Number result_2 = ((Entry) store.getValue(ID_2)).op(); - - return result_2; + return ((Entry) store.getValue(ID_2)).op(); } public String toString() { diff --git a/core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutiveRepeat.result b/core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutiveRepeat.result index 0fb49882ff..ad5e3515a9 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutiveRepeat.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutiveRepeat.result @@ -37,9 +37,7 @@ public class Entry implements java.io.Serializable { CallStatement callStm_1 = new CallStatement() { public Object execute(final Object instance) { - Number result_1 = ((Entry) store.getValue(ID_1)).op(); - - return result_1; + return ((Entry) store.getValue(ID_1)).op(); } public String toString() { @@ -60,9 +58,7 @@ public class Entry implements java.io.Serializable { CallStatement callStm_2 = new CallStatement() { public Object execute(final Object instance) { - Number result_2 = ((Entry) store.getValue(ID_2)).op(); - - return result_2; + return ((Entry) store.getValue(ID_2)).op(); } public String toString() { diff --git a/core/codegen/src/test/resources/traces_expansion_specs/ObjectBind.result b/core/codegen/src/test/resources/traces_expansion_specs/ObjectBind.result index c342d4b1bd..60ea4d0873 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/ObjectBind.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/ObjectBind.result @@ -29,9 +29,7 @@ public class Entry implements java.io.Serializable { CallStatement callStm_1 = new CallStatement() { public Object execute(final Object instance) { - Number result_1 = ((Entry) store.getValue(ID_1)).op(); - - return result_1; + return ((Entry) store.getValue(ID_1)).op(); } public String toString() { diff --git a/core/codegen/src/test/resources/traces_expansion_specs/SharedObjectBind.result b/core/codegen/src/test/resources/traces_expansion_specs/SharedObjectBind.result index cf78f2d781..53ff0d70fb 100644 --- a/core/codegen/src/test/resources/traces_expansion_specs/SharedObjectBind.result +++ b/core/codegen/src/test/resources/traces_expansion_specs/SharedObjectBind.result @@ -65,9 +65,7 @@ public class Entry implements java.io.Serializable { SequenceTraceNode sequence_2 = new SequenceTraceNode(); CallStatement callStm_1 = new CallStatement() { public Object execute(final Object instance) { - Number result_1 = ((Entry) store.getValue(ID_2)).inc(); - - return result_1; + return ((Entry) store.getValue(ID_2)).inc(); } public String toString() { @@ -79,9 +77,7 @@ public class Entry implements java.io.Serializable { CallStatement callStm_2 = new CallStatement() { public Object execute(final Object instance) { - Number result_2 = ((Entry) store.getValue(ID_2)).inc(); - - return result_2; + return ((Entry) store.getValue(ID_2)).inc(); } public String toString() { @@ -93,9 +89,7 @@ public class Entry implements java.io.Serializable { CallStatement callStm_3 = new CallStatement() { public Object execute(final Object instance) { - Number result_3 = ((Entry) store.getValue(ID_3)).inc(); - - return result_3; + return ((Entry) store.getValue(ID_3)).inc(); } public String toString() { @@ -107,9 +101,7 @@ public class Entry implements java.io.Serializable { CallStatement callStm_4 = new CallStatement() { public Object execute(final Object instance) { - Number result_4 = ((Entry) store.getValue(ID_3)).inc(); - - return result_4; + return ((Entry) store.getValue(ID_3)).inc(); } public String toString() { diff --git a/core/codegen/src/test/resources/traces_verdict_specs/SameTestTwice.result b/core/codegen/src/test/resources/traces_verdict_specs/SameTestTwice.result index d6f63843f6..dff060b0bf 100644 --- a/core/codegen/src/test/resources/traces_verdict_specs/SameTestTwice.result +++ b/core/codegen/src/test/resources/traces_verdict_specs/SameTestTwice.result @@ -45,9 +45,7 @@ public class Entry implements java.io.Serializable { AlternativeTraceNode alternatives_2 = new AlternativeTraceNode(); CallStatement callStm_1 = new CallStatement() { public Object execute(final Object instance) { - Number result_1 = ((Entry) store.getValue(ID_1)).op(); - - return result_1; + return ((Entry) store.getValue(ID_1)).op(); } public String toString() { @@ -61,9 +59,7 @@ public class Entry implements java.io.Serializable { CallStatement callStm_2 = new CallStatement() { public Object execute(final Object instance) { - Number result_2 = ((Entry) store.getValue(ID_1)).op(); - - return result_2; + return ((Entry) store.getValue(ID_1)).op(); } public String toString() { From 2be8da1da1cfcf1d256174a8a0b0af376740d43c Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sat, 28 Feb 2015 12:35:26 +0100 Subject: [PATCH 173/323] Updates to the 'JavaCallStmToStringBuilder' used in the traces transformation These changes are needed due to the introduction of the CallObjStm transformation --- .../codegen/traces/JavaCallStmToStringBuilder.java | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/JavaCallStmToStringBuilder.java b/core/codegen/src/main/java/org/overture/codegen/traces/JavaCallStmToStringBuilder.java index 3965e25842..f85df2fdf0 100644 --- a/core/codegen/src/main/java/org/overture/codegen/traces/JavaCallStmToStringBuilder.java +++ b/core/codegen/src/main/java/org/overture/codegen/traces/JavaCallStmToStringBuilder.java @@ -4,14 +4,13 @@ import java.util.Map; import org.overture.codegen.cgast.SExpCG; -import org.overture.codegen.cgast.SObjectDesignatorCG; import org.overture.codegen.cgast.SStmCG; import org.overture.codegen.cgast.STypeCG; import org.overture.codegen.cgast.declarations.AMethodDeclCG; import org.overture.codegen.cgast.expressions.AApplyExpCG; import org.overture.codegen.cgast.expressions.AIdentifierVarExpCG; import org.overture.codegen.cgast.expressions.ASeqConcatBinaryExpCG; -import org.overture.codegen.cgast.statements.ACallObjectStmCG; +import org.overture.codegen.cgast.statements.ACallObjectExpStmCG; import org.overture.codegen.cgast.statements.APlainCallStmCG; import org.overture.codegen.cgast.statements.AReturnStmCG; import org.overture.codegen.cgast.types.AClassTypeCG; @@ -49,11 +48,11 @@ public AMethodDeclCG consToString(IRInfo info, SStmCG callStm, Map args = callObj.getArgs(); @@ -61,7 +60,9 @@ public AMethodDeclCG consToString(IRInfo info, SStmCG callStm, Map Date: Sat, 28 Feb 2015 12:47:06 +0100 Subject: [PATCH 174/323] Added toString implementations for the IR nodes used to replace object designators --- core/codegen/src/main/resources/cg.astv2.tostring | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/core/codegen/src/main/resources/cg.astv2.tostring b/core/codegen/src/main/resources/cg.astv2.tostring index 9682c093f1..00df33afbe 100644 --- a/core/codegen/src/main/resources/cg.astv2.tostring +++ b/core/codegen/src/main/resources/cg.astv2.tostring @@ -51,3 +51,9 @@ import org.overture.ast.util.ToStringUtil; %CG->#exp->#Var->identifier = [name] %CG->#exp->#Var->explicit = [name] %CG->#exp->#Var->super = [name] + + +%CG->#exp->apply = [root] "(" + $Utils.listToString($[args]$)$ + ")" +%CG->#exp->field = [object] + "." + [memberName] +%CG->#exp->new = [name] "(" + $Utils.listToString($[args]$)$ + ")" +%CG->#exp->self = "self" From 5695436b5f1f2a3885742a2dc3dcfb03c1baf043 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sat, 28 Feb 2015 13:33:19 +0100 Subject: [PATCH 175/323] Added toString implementations for patterns in the IR --- .../src/main/resources/cg.astv2.tostring | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/core/codegen/src/main/resources/cg.astv2.tostring b/core/codegen/src/main/resources/cg.astv2.tostring index 00df33afbe..308ee5eb12 100644 --- a/core/codegen/src/main/resources/cg.astv2.tostring +++ b/core/codegen/src/main/resources/cg.astv2.tostring @@ -8,6 +8,23 @@ import org.overture.ast.util.ToStringUtil; %CG->#decl->class = [name] +//start + +//patterns +%CG->#pattern->identifier = [name] +%CG->#pattern->ignore = "-" +%CG->#pattern->bool = [value] +%CG->#pattern->char = [value] +%CG->#pattern->int = [value] +%CG->#pattern->null = "null" +%CG->#pattern->quote = [value] +%CG->#pattern->real = [value] +%CG->#pattern->string = [value] +%CG->#pattern->tuple = "mk_(" + $Utils.listToString($[patterns]$)$ + ")" +%CG->#pattern->record = [typename] "_(" + $Utils.listToString($[patterns]$)$ + ")" + +//end + // Object designator %CG->#objectDesignator->identifier = [exp]; %CG->#objectDesignator->apply = [object] "(" + $Utils.listToString($[args]$)$ + ")" From 00e9e9a6f74871db15ac6fe1edf800732bbf0024 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sat, 28 Feb 2015 13:49:04 +0100 Subject: [PATCH 176/323] Added toStrings for binds, multiple binds and names in the IR --- core/codegen/src/main/resources/cg.astv2.tostring | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/core/codegen/src/main/resources/cg.astv2.tostring b/core/codegen/src/main/resources/cg.astv2.tostring index 308ee5eb12..7b9866fddd 100644 --- a/core/codegen/src/main/resources/cg.astv2.tostring +++ b/core/codegen/src/main/resources/cg.astv2.tostring @@ -10,7 +10,7 @@ import org.overture.ast.util.ToStringUtil; //start -//patterns +// patterns %CG->#pattern->identifier = [name] %CG->#pattern->ignore = "-" %CG->#pattern->bool = [value] @@ -23,6 +23,18 @@ import org.overture.ast.util.ToStringUtil; %CG->#pattern->tuple = "mk_(" + $Utils.listToString($[patterns]$)$ + ")" %CG->#pattern->record = [typename] "_(" + $Utils.listToString($[patterns]$)$ + ")" +// binds +%CG->#bind->set = ""+ [pattern] + " in set " [set]; + + +// multiple binds +%CG->multipleBind->set = ""+ $Utils.listToString($[patterns]$)$ + " in set " [set]; + + +// names +%CG->name->type = [name] +%CG->name->token = [name] + //end // Object designator From a47aaf6993f895e976a46a34d96e4579aab07276 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sat, 28 Feb 2015 23:35:35 +0100 Subject: [PATCH 177/323] Added toString implementations for state designators in the IR --- core/codegen/src/main/resources/cg.astv2.tostring | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/core/codegen/src/main/resources/cg.astv2.tostring b/core/codegen/src/main/resources/cg.astv2.tostring index 7b9866fddd..b8bb3d7bb6 100644 --- a/core/codegen/src/main/resources/cg.astv2.tostring +++ b/core/codegen/src/main/resources/cg.astv2.tostring @@ -44,6 +44,11 @@ import org.overture.ast.util.ToStringUtil; %CG->#objectDesignator->new = "new "+[exp] %CG->#objectDesignator->self = "self" +// State designators +%CG->#stateDesignator->identifier = [name] +%CG->#stateDesignator->field = [object] "." [field] +%CG->#stateDesignator->mapSeq = [mapseq] "(" + [exp] + ")" + // Types //#basic %CG->#type->#basic->char = "char" From 0a668c52df7e043dc8bd5f3feff6c4bc92e661fd Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sun, 1 Mar 2015 22:36:13 +0100 Subject: [PATCH 178/323] Improvements to concurrency related test results and refactoring of a converter class "Statechanged" was sometimes called on local variable assignments when code generating concurrency --- .../{uniontypes => conv}/ObjectDesignatorToExpCG.java | 0 .../concurrency_classics_specs/POP3_LogBased_Test1.result | 7 ------- 2 files changed, 7 deletions(-) rename core/codegen/src/main/java/org/overture/codegen/trans/{uniontypes => conv}/ObjectDesignatorToExpCG.java (100%) diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/uniontypes/ObjectDesignatorToExpCG.java b/core/codegen/src/main/java/org/overture/codegen/trans/conv/ObjectDesignatorToExpCG.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/trans/uniontypes/ObjectDesignatorToExpCG.java rename to core/codegen/src/main/java/org/overture/codegen/trans/conv/ObjectDesignatorToExpCG.java diff --git a/core/codegen/src/test/resources/concurrency_classics_specs/POP3_LogBased_Test1.result b/core/codegen/src/test/resources/concurrency_classics_specs/POP3_LogBased_Test1.result index 0f1ca4f775..ca5b2d827a 100644 --- a/core/codegen/src/test/resources/concurrency_classics_specs/POP3_LogBased_Test1.result +++ b/core/codegen/src/test/resources/concurrency_classics_specs/POP3_LogBased_Test1.result @@ -103,8 +103,6 @@ public class Log implements EvaluatePP { iterator_13.hasNext();) { String m = (String) iterator_13.next(); output = output + m + "\n"; - - sentinel.stateChanged(); } return output; @@ -638,7 +636,6 @@ public class POP3ClientHandler extends VDMThread implements EvaluatePP { } response = ternaryIfExp_1; - sentinel.stateChanged(); } } } else { @@ -646,7 +643,6 @@ public class POP3ClientHandler extends VDMThread implements EvaluatePP { } } else { response = new POP3Types.OkResponse(quitMsg); - sentinel.stateChanged(); } return response; @@ -1244,7 +1240,6 @@ public class POP3ClientHandler extends VDMThread implements EvaluatePP { sentinel.stateChanged(); cmd = msgChannel.ServerListen(); - sentinel.stateChanged(); Boolean whileCond1 = true; @@ -1257,7 +1252,6 @@ public class POP3ClientHandler extends VDMThread implements EvaluatePP { msgChannel.ServerSend(ReceiveCommand(((Object) cmd))); cmd = msgChannel.ServerListen(); - sentinel.stateChanged(); } msgChannel.ServerSend(ReceiveCommand(((Object) cmd))); @@ -2574,7 +2568,6 @@ public class POP3TestListener extends VDMThread implements EvaluatePP { LogServer(((Object) response)); response = mc.ClientListen(); - sentinel.stateChanged(); } LogServer(((Object) response)); From 387c1f2c8fc4d1220edef6aeff54a02c45a8e199 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sun, 1 Mar 2015 22:50:30 +0100 Subject: [PATCH 179/323] Added a "map read expression" and a "map put statement" to the IR. Also templates for these constructs have been added to the Java backend. --- .../org/overture/codegen/merging/TemplateManager.java | 10 +++++++++- .../main/resources/JavaTemplates/Expressions/MapGet.vm | 5 +++++ .../main/resources/JavaTemplates/Statements/MapPut.vm | 5 +++++ core/codegen/src/main/resources/cg.astv2 | 2 ++ 4 files changed, 21 insertions(+), 1 deletion(-) create mode 100644 core/codegen/src/main/resources/JavaTemplates/Expressions/MapGet.vm create mode 100644 core/codegen/src/main/resources/JavaTemplates/Statements/MapPut.vm diff --git a/core/codegen/src/main/java/org/overture/codegen/merging/TemplateManager.java b/core/codegen/src/main/java/org/overture/codegen/merging/TemplateManager.java index 9089d67dd5..b1e4e701c1 100644 --- a/core/codegen/src/main/java/org/overture/codegen/merging/TemplateManager.java +++ b/core/codegen/src/main/java/org/overture/codegen/merging/TemplateManager.java @@ -63,6 +63,7 @@ import org.overture.codegen.cgast.statements.AIncrementStmCG; import org.overture.codegen.cgast.statements.ALocalAssignmentStmCG; import org.overture.codegen.cgast.statements.ALocalPatternAssignmentStmCG; +import org.overture.codegen.cgast.statements.AMapPutStmCG; import org.overture.codegen.cgast.statements.AMapSeqStateDesignatorCG; import org.overture.codegen.cgast.statements.ANewObjectDesignatorCG; import org.overture.codegen.cgast.statements.ANotImplementedStmCG; @@ -344,6 +345,10 @@ protected void initNodeTemplateFileNames() nodeTemplateFileNames.put(AStartlistStmCG.class, templateStructure.STM_PATH + "Startlist"); + + nodeTemplateFileNames.put(AMapPutStmCG.class, templateStructure.STM_PATH + + "MapPut"); + // Expressions nodeTemplateFileNames.put(AApplyExpCG.class, templateStructure.EXP_PATH @@ -426,7 +431,10 @@ protected void initNodeTemplateFileNames() nodeTemplateFileNames.put(AHistoryExpCG.class, templateStructure.EXP_PATH + "hisCounter"); - + + nodeTemplateFileNames.put(AMapGetExpCG.class, templateStructure.EXP_PATH + + "MapGet"); + // Is expressions nodeTemplateFileNames.put(ABoolIsExpCG.class, templateStructure.IS_EXP_PATH diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/MapGet.vm b/core/codegen/src/main/resources/JavaTemplates/Expressions/MapGet.vm new file mode 100644 index 0000000000..2c046ae62f --- /dev/null +++ b/core/codegen/src/main/resources/JavaTemplates/Expressions/MapGet.vm @@ -0,0 +1,5 @@ +#set( $map = $JavaFormat.format($node.getMap()) ) +#set( $domValue = $JavaFormat.format($node.getDomValue()) ) +#set( $type = $JavaFormat.format($node.getType()) ) +## +((${type}) ${map}.get(${domValue})) \ No newline at end of file diff --git a/core/codegen/src/main/resources/JavaTemplates/Statements/MapPut.vm b/core/codegen/src/main/resources/JavaTemplates/Statements/MapPut.vm new file mode 100644 index 0000000000..1d137ba335 --- /dev/null +++ b/core/codegen/src/main/resources/JavaTemplates/Statements/MapPut.vm @@ -0,0 +1,5 @@ +#set( $map = $JavaFormat.format($node.getMap()) ) +#set( $domValue = $JavaFormat.format($node.getDomValue()) ) +#set( $rngValue = $JavaFormat.format($node.getRngValue()) ) +## +${map}.put(${domValue}, ${rngValue}); \ No newline at end of file diff --git a/core/codegen/src/main/resources/cg.astv2 b/core/codegen/src/main/resources/cg.astv2 index f8dbf25368..7e9ccc1a54 100644 --- a/core/codegen/src/main/resources/cg.astv2 +++ b/core/codegen/src/main/resources/cg.astv2 @@ -228,6 +228,7 @@ CG {-> package='org.overture.codegen.cgast' [type]:CG.#type [name]:java_String [args]:CG.#exp* + | {mapPut} [map]:CG.#exp [domValue]:CG.#exp [rngValue]:CG.#exp ; #call {-> package='org.overture.codegen.cgast.statements' @@ -298,6 +299,7 @@ CG {-> package='org.overture.codegen.cgast' | {history}[histype]:java_String [opsname]:java_String [sentinelType]:CG.#type.class | {time} | {assignExp} [target]:CG.#exp [value]:CG.#exp + | {mapGet} [map]:CG.#exp [domValue]:CG.#exp ; #modifier {-> package='org.overture.codegen.cgast.expressions'} From 87d761056bb40b026327a19c10f1e65cdc0b0b44 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sun, 1 Mar 2015 22:56:38 +0100 Subject: [PATCH 180/323] Updates to imports --- .../java/org/overture/codegen/assistant/TypeAssistantCG.java | 2 +- .../org/overture/codegen/trans/CallObjStmTransformation.java | 2 +- .../overture/codegen/trans/conv/ObjectDesignatorToExpCG.java | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/assistant/TypeAssistantCG.java b/core/codegen/src/main/java/org/overture/codegen/assistant/TypeAssistantCG.java index 9586cdf6da..a7860a0689 100644 --- a/core/codegen/src/main/java/org/overture/codegen/assistant/TypeAssistantCG.java +++ b/core/codegen/src/main/java/org/overture/codegen/assistant/TypeAssistantCG.java @@ -82,7 +82,7 @@ import org.overture.codegen.ir.IRInfo; import org.overture.codegen.ir.SourceNode; import org.overture.codegen.logging.Logger; -import org.overture.codegen.trans.uniontypes.ObjectDesignatorToExpCG; +import org.overture.codegen.trans.conv.ObjectDesignatorToExpCG; import org.overture.typechecker.TypeComparator; import org.overture.typechecker.assistant.definition.PDefinitionAssistantTC; import org.overture.typechecker.assistant.type.PTypeAssistantTC; diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/CallObjStmTransformation.java b/core/codegen/src/main/java/org/overture/codegen/trans/CallObjStmTransformation.java index 89c2fd428f..c3e8d47d0d 100644 --- a/core/codegen/src/main/java/org/overture/codegen/trans/CallObjStmTransformation.java +++ b/core/codegen/src/main/java/org/overture/codegen/trans/CallObjStmTransformation.java @@ -9,7 +9,7 @@ import org.overture.codegen.cgast.statements.ACallObjectStmCG; import org.overture.codegen.ir.IRInfo; import org.overture.codegen.logging.Logger; -import org.overture.codegen.trans.uniontypes.ObjectDesignatorToExpCG; +import org.overture.codegen.trans.conv.ObjectDesignatorToExpCG; public class CallObjStmTransformation extends DepthFirstAnalysisAdaptor { diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/conv/ObjectDesignatorToExpCG.java b/core/codegen/src/main/java/org/overture/codegen/trans/conv/ObjectDesignatorToExpCG.java index 91fd5c051b..452a068c50 100644 --- a/core/codegen/src/main/java/org/overture/codegen/trans/conv/ObjectDesignatorToExpCG.java +++ b/core/codegen/src/main/java/org/overture/codegen/trans/conv/ObjectDesignatorToExpCG.java @@ -19,7 +19,7 @@ * . * #~% */ -package org.overture.codegen.trans.uniontypes; +package org.overture.codegen.trans.conv; import java.util.LinkedList; import java.util.List; From 1be3678a51261fac92c459e084028d908403203a Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sun, 1 Mar 2015 23:02:59 +0100 Subject: [PATCH 181/323] Added assignment transformation to clear out state designators --- .../trans/AssignStmTransformation.java | 72 +++++++++++++++++++ 1 file changed, 72 insertions(+) create mode 100644 core/codegen/src/main/java/org/overture/codegen/trans/AssignStmTransformation.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/AssignStmTransformation.java b/core/codegen/src/main/java/org/overture/codegen/trans/AssignStmTransformation.java new file mode 100644 index 0000000000..54f1e1bf1f --- /dev/null +++ b/core/codegen/src/main/java/org/overture/codegen/trans/AssignStmTransformation.java @@ -0,0 +1,72 @@ +package org.overture.codegen.trans; + +import java.util.List; + +import org.overture.codegen.cgast.SExpCG; +import org.overture.codegen.cgast.SStmCG; +import org.overture.codegen.cgast.analysis.AnalysisException; +import org.overture.codegen.cgast.analysis.DepthFirstAnalysisAdaptor; +import org.overture.codegen.cgast.declarations.AClassDeclCG; +import org.overture.codegen.cgast.statements.AAssignmentStmCG; +import org.overture.codegen.cgast.statements.ALocalAssignmentStmCG; +import org.overture.codegen.cgast.statements.AMapPutStmCG; +import org.overture.codegen.cgast.statements.AMapSeqStateDesignatorCG; +import org.overture.codegen.ir.IRInfo; +import org.overture.codegen.logging.Logger; +import org.overture.codegen.trans.assistants.TransAssistantCG; +import org.overture.codegen.trans.conv.FieldDesignatorToExpCG; + +public class AssignStmTransformation extends DepthFirstAnalysisAdaptor +{ + private FieldDesignatorToExpCG converter; + + public AssignStmTransformation(IRInfo info, List classes, TransAssistantCG transAssistant) + { + this.converter = new FieldDesignatorToExpCG(info, classes, transAssistant); + } + + @Override + public void caseAAssignmentStmCG(AAssignmentStmCG node) + throws AnalysisException + { + SStmCG newNode = null; + if(node.getTarget() instanceof AMapSeqStateDesignatorCG) + { + AMapSeqStateDesignatorCG target = (AMapSeqStateDesignatorCG) node.getTarget(); + + SExpCG mapExp = target.getMapseq().apply(converter); + + SExpCG domValue = target.getExp(); + SExpCG rngValue = node.getExp(); + + AMapPutStmCG mapPut = new AMapPutStmCG(); + mapPut.setMap(mapExp); + mapPut.setDomValue(domValue.clone()); + mapPut.setRngValue(rngValue.clone()); + mapPut.setSourceNode(node.getSourceNode()); + mapPut.setTag(node.getTag()); + + newNode = mapPut; + + } + else + { + ALocalAssignmentStmCG localAssign = new ALocalAssignmentStmCG(); + localAssign.setTarget(node.getTarget().apply(converter)); + localAssign.setExp(node.getExp().clone()); + localAssign.setSourceNode(node.getSourceNode()); + localAssign.setTag(node.getTag()); + + newNode = localAssign; + } + + if(node.parent() != null) + { + node.parent().replaceChild(node, newNode); + } + else + { + Logger.getLog().printErrorln("Could not find parent of " + node + " in " + "'" + this.getClass().getSimpleName() + "'" ); + } + } +} From a9c365e41d16cc4a76a9a3ea0cbb2b7d1567699c Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sun, 1 Mar 2015 23:29:17 +0100 Subject: [PATCH 182/323] Added utility functionality to check if an identifier state designator represents a local variable or not --- .../codegen/assistant/DeclAssistantCG.java | 39 +++++++++++++++++++ 1 file changed, 39 insertions(+) diff --git a/core/codegen/src/main/java/org/overture/codegen/assistant/DeclAssistantCG.java b/core/codegen/src/main/java/org/overture/codegen/assistant/DeclAssistantCG.java index 92d1cd7420..10b74d645a 100644 --- a/core/codegen/src/main/java/org/overture/codegen/assistant/DeclAssistantCG.java +++ b/core/codegen/src/main/java/org/overture/codegen/assistant/DeclAssistantCG.java @@ -54,6 +54,7 @@ import org.overture.codegen.cgast.declarations.AVarDeclCG; import org.overture.codegen.cgast.expressions.ANullExpCG; import org.overture.codegen.cgast.name.ATypeNameCG; +import org.overture.codegen.cgast.statements.AIdentifierStateDesignatorCG; import org.overture.codegen.cgast.types.ABoolBasicTypeCG; import org.overture.codegen.cgast.types.ACharBasicTypeCG; import org.overture.codegen.cgast.types.AIntNumericBasicTypeCG; @@ -66,6 +67,7 @@ import org.overture.codegen.ir.IRConstants; import org.overture.codegen.ir.IRInfo; import org.overture.codegen.ir.SourceNode; +import org.overture.codegen.logging.Logger; import org.overture.codegen.utils.LexNameTokenWrapper; public class DeclAssistantCG extends AssistantBase @@ -576,4 +578,41 @@ public List consFormalParams( } return paramsCg; } + + /** + * Checks if an identifier state designator represents a local variable. + * Please note that variable hiding and shadowing is assumed to be removed + * from the model. + * + * @param node the identifier + * @param classes all classes in the model + * @return true if the identifier represents a local variable - false otherwise + */ + public boolean isLocal(AIdentifierStateDesignatorCG node, List classes) + { + AClassDeclCG encClass = node.getAncestor(AClassDeclCG.class); + + if(encClass == null) + { + Logger.getLog().printErrorln("Could not find enclosing class of " + node + + " in '" + this.getClass().getName() + "'"); + return false; + } + + String fieldName = node.getName(); + + List encClassFields = getAllFields(encClass, classes); + + for(AFieldDeclCG field : encClassFields) + { + if(field.getName().equals(fieldName)) + { + // So it must be a global identifier + return false; + } + } + + // If we could not find a field with this name then it must be local + return true; + } } From 8fb757f10706208c2bdead2ca4bc31d8f0faa99f Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sun, 1 Mar 2015 23:39:52 +0100 Subject: [PATCH 183/323] Added functionality to convert state designators into equivalent expressions --- .../trans/AssignStmTransformation.java | 6 +- .../trans/conv/StateDesignatorToExpCG.java | 121 ++++++++++++++++++ 2 files changed, 124 insertions(+), 3 deletions(-) create mode 100644 core/codegen/src/main/java/org/overture/codegen/trans/conv/StateDesignatorToExpCG.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/AssignStmTransformation.java b/core/codegen/src/main/java/org/overture/codegen/trans/AssignStmTransformation.java index 54f1e1bf1f..38e3f5aae0 100644 --- a/core/codegen/src/main/java/org/overture/codegen/trans/AssignStmTransformation.java +++ b/core/codegen/src/main/java/org/overture/codegen/trans/AssignStmTransformation.java @@ -14,15 +14,15 @@ import org.overture.codegen.ir.IRInfo; import org.overture.codegen.logging.Logger; import org.overture.codegen.trans.assistants.TransAssistantCG; -import org.overture.codegen.trans.conv.FieldDesignatorToExpCG; +import org.overture.codegen.trans.conv.StateDesignatorToExpCG; public class AssignStmTransformation extends DepthFirstAnalysisAdaptor { - private FieldDesignatorToExpCG converter; + private StateDesignatorToExpCG converter; public AssignStmTransformation(IRInfo info, List classes, TransAssistantCG transAssistant) { - this.converter = new FieldDesignatorToExpCG(info, classes, transAssistant); + this.converter = new StateDesignatorToExpCG(info, classes, transAssistant); } @Override diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/conv/StateDesignatorToExpCG.java b/core/codegen/src/main/java/org/overture/codegen/trans/conv/StateDesignatorToExpCG.java new file mode 100644 index 0000000000..74fdb6ee25 --- /dev/null +++ b/core/codegen/src/main/java/org/overture/codegen/trans/conv/StateDesignatorToExpCG.java @@ -0,0 +1,121 @@ +package org.overture.codegen.trans.conv; + +import java.util.List; + +import org.overture.codegen.cgast.INode; +import org.overture.codegen.cgast.SExpCG; +import org.overture.codegen.cgast.analysis.AnalysisException; +import org.overture.codegen.cgast.analysis.AnswerAdaptor; +import org.overture.codegen.cgast.declarations.AClassDeclCG; +import org.overture.codegen.cgast.expressions.AExplicitVarExpCG; +import org.overture.codegen.cgast.expressions.AFieldExpCG; +import org.overture.codegen.cgast.expressions.AIdentifierVarExpCG; +import org.overture.codegen.cgast.expressions.AMapGetExpCG; +import org.overture.codegen.cgast.statements.AFieldStateDesignatorCG; +import org.overture.codegen.cgast.statements.AIdentifierStateDesignatorCG; +import org.overture.codegen.cgast.statements.AMapSeqStateDesignatorCG; +import org.overture.codegen.cgast.types.AClassTypeCG; +import org.overture.codegen.ir.IRInfo; +import org.overture.codegen.trans.assistants.TransAssistantCG; + +/** + * Converts a state designator into an equivalent expression. Please note that this converter assumes map sequence state + * designators to be "map readings" and not "map modifications". More explicitly, this means that the parent of a map + * sequence state designator is assumed to be a state designator and not an assignment statement. + * + * @author pvj + */ +public class StateDesignatorToExpCG extends AnswerAdaptor +{ + private IRInfo info; + private List classes; + private TransAssistantCG transAssistant; + + public StateDesignatorToExpCG(IRInfo info, List classes, TransAssistantCG transAssistant) + { + this.info = info; + this.classes = classes; + this.transAssistant = transAssistant; + } + + @Override + public SExpCG caseAIdentifierStateDesignatorCG( + AIdentifierStateDesignatorCG node) throws AnalysisException + { + boolean isLocal = info.getDeclAssistant().isLocal(node, classes); + + if(node.getExplicit()) + { + AClassTypeCG classType = new AClassTypeCG(); + classType.setName(node.getClassName()); + + AExplicitVarExpCG explicitVar = new AExplicitVarExpCG(); + explicitVar.setClassType(classType); + explicitVar.setIsLambda(false); + explicitVar.setIsLocal(isLocal); + explicitVar.setName(node.getName()); + explicitVar.setSourceNode(node.getSourceNode()); + explicitVar.setTag(node.getTag()); + explicitVar.setType(node.getType().clone()); + + return explicitVar; + } + else + { + AIdentifierVarExpCG idVar = transAssistant.consIdentifierVar(node.getName(), node.getType().clone()); + idVar.setTag(node.getTag()); + idVar.setSourceNode(node.getSourceNode()); + idVar.setIsLocal(isLocal); + + return idVar; + } + } + + @Override + public SExpCG caseAFieldStateDesignatorCG(AFieldStateDesignatorCG node) + throws AnalysisException + { + SExpCG objExp = node.getObject().apply(this); + + AFieldExpCG fieldExp = new AFieldExpCG(); + fieldExp.setMemberName(node.getField()); + fieldExp.setObject(objExp); + fieldExp.setType(node.getType().clone()); + fieldExp.setTag(node.getTag()); + fieldExp.setSourceNode(node.getSourceNode()); + + return fieldExp; + } + + @Override + public SExpCG caseAMapSeqStateDesignatorCG(AMapSeqStateDesignatorCG node) + throws AnalysisException + { + SExpCG domValue = node.getExp(); + SExpCG mapSeq = node.getMapseq().apply(this); + + AMapGetExpCG mapGet = new AMapGetExpCG(); + mapGet.setType(node.getType().clone()); + mapGet.setDomValue(domValue.clone()); + mapGet.setMap(mapSeq); + mapGet.setSourceNode(node.getSourceNode()); + mapGet.setTag(node.getTag()); + + // e.g. ((Rec) m(true)).field := 2; + return mapGet; + } + + @Override + public SExpCG createNewReturnValue(INode node) throws AnalysisException + { + assert false : "This should never happen"; + return null; + } + + @Override + public SExpCG createNewReturnValue(Object node) throws AnalysisException + { + assert false : "This should never happen"; + return null; + } +} From 2cf7ebcb66416cbca5c3ff09f10c593a5a88a64e Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sun, 1 Mar 2015 23:41:17 +0100 Subject: [PATCH 184/323] Added the 'AssignStmTransformation' to the Java transformation series --- .../java/org/overture/codegen/vdm2java/JavaTransSeries.java | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaTransSeries.java b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaTransSeries.java index 8c0ff383b4..ecf583ff78 100644 --- a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaTransSeries.java +++ b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaTransSeries.java @@ -7,6 +7,7 @@ import org.overture.codegen.cgast.expressions.AIntLiteralExpCG; import org.overture.codegen.cgast.types.AExternalTypeCG; import org.overture.codegen.ir.IRInfo; +import org.overture.codegen.trans.AssignStmTransformation; import org.overture.codegen.trans.CallObjStmTransformation; import org.overture.codegen.trans.IPostCheckCreator; import org.overture.codegen.trans.IsExpTransformation; @@ -53,6 +54,8 @@ public DepthFirstAnalysisAdaptor[] consAnalyses(List classes, IRInfo irInfo = codeGen.getIRGenerator().getIRInfo(); CallObjStmTransformation callObjTransformation = new CallObjStmTransformation(irInfo, classes); + AssignStmTransformation assignTransformation = new AssignStmTransformation(irInfo, classes, transAssistant); + PrePostTransformation prePostTransformation = new PrePostTransformation(irInfo); IfExpTransformation ifExpTransformation = new IfExpTransformation(transAssistant); FunctionValueTransformation funcValueTransformation = new FunctionValueTransformation(irInfo, transAssistant, functionValueAssistant, INTERFACE_NAME_PREFIX, TEMPLATE_TYPE_PREFIX, EVAL_METHOD_PREFIX, PARAM_NAME_PREFIX); @@ -74,6 +77,7 @@ public DepthFirstAnalysisAdaptor[] consAnalyses(List classes, JavaClassToStringTrans javaToStringTransformation = new JavaClassToStringTrans(irInfo); DepthFirstAnalysisAdaptor[] analyses = new DepthFirstAnalysisAdaptor[] { + assignTransformation, callObjTransformation, funcTransformation, prePostTransformation, ifExpTransformation, funcValueTransformation, transVisitor, patternTransformation, From 0897f76cdee2dce453878069e78165cad15dec94 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sun, 1 Mar 2015 23:45:05 +0100 Subject: [PATCH 185/323] Updated the 'JavaValueSemantics' class to take the map put statement and the map get expression into account --- .../codegen/vdm2java/JavaValueSemantics.java | 47 ++++++++++++++++++- 1 file changed, 45 insertions(+), 2 deletions(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaValueSemantics.java b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaValueSemantics.java index f02ed76072..67eaa7554b 100644 --- a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaValueSemantics.java +++ b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaValueSemantics.java @@ -43,6 +43,7 @@ import org.overture.codegen.cgast.expressions.AIndicesUnaryExpCG; import org.overture.codegen.cgast.expressions.AInstanceofExpCG; import org.overture.codegen.cgast.expressions.ALenUnaryExpCG; +import org.overture.codegen.cgast.expressions.AMapGetExpCG; import org.overture.codegen.cgast.expressions.ANewExpCG; import org.overture.codegen.cgast.expressions.ANotEqualsBinaryExpCG; import org.overture.codegen.cgast.expressions.ASetProperSubsetBinaryExpCG; @@ -51,6 +52,7 @@ import org.overture.codegen.cgast.expressions.ATupleSizeExpCG; import org.overture.codegen.cgast.statements.AForAllStmCG; import org.overture.codegen.cgast.statements.ALocalAssignmentStmCG; +import org.overture.codegen.cgast.statements.AMapPutStmCG; import org.overture.codegen.cgast.types.AExternalTypeCG; import org.overture.codegen.cgast.types.AMethodTypeCG; import org.overture.codegen.cgast.types.ARecordTypeCG; @@ -94,12 +96,16 @@ public boolean cloneMember(AFieldNumberExpCG exp) { return false; } - + + if(cloneNotNeededMapPutGet(exp)) + { + return false; + } + STypeCG type = exp.getTuple().getType(); if (type instanceof ATupleTypeCG) { - ATupleTypeCG tupleType = (ATupleTypeCG) type; long field = exp.getField(); @@ -126,6 +132,11 @@ public boolean cloneMember(AFieldExpCG exp) { return false; } + + if(cloneNotNeededMapPutGet(exp)) + { + return false; + } STypeCG type = exp.getObject().getType(); @@ -173,6 +184,11 @@ public boolean shouldClone(SExpCG exp) } } + if(cloneNotNeededMapPutGet(exp)) + { + return false; + } + if(isPrePostArgument(exp)) { return false; @@ -199,6 +215,33 @@ public boolean shouldClone(SExpCG exp) return false; } + private boolean cloneNotNeededMapPutGet(SExpCG exp) + { + INode parent = exp.parent(); + + if(parent instanceof AMapPutStmCG) + { + AMapPutStmCG mapPut = (AMapPutStmCG) parent; + + if(mapPut.getMap() == exp) + { + return true; + } + } + + if(parent instanceof AMapGetExpCG) + { + AMapGetExpCG mapGet = (AMapGetExpCG) parent; + + if(mapGet.getMap() == exp) + { + return true; + } + } + + return false; + } + private boolean cloneNotNeeded(INode parent) { while(parent instanceof ACastUnaryExpCG) From d7994e0fcf586c9412585eb3fde492da622d3372 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sun, 1 Mar 2015 23:55:57 +0100 Subject: [PATCH 186/323] Updates to the transformation that generates the "sentinel.stateChanged()" call This is a consequence of the most recent work on transforming state designators out of the IR --- .../conc/InstanceVarPPEvalTransformation.java | 42 ++++++++++++++++++- 1 file changed, 41 insertions(+), 1 deletion(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/conc/InstanceVarPPEvalTransformation.java b/core/codegen/src/main/java/org/overture/codegen/trans/conc/InstanceVarPPEvalTransformation.java index f89cc1cb5a..56ef87ca31 100644 --- a/core/codegen/src/main/java/org/overture/codegen/trans/conc/InstanceVarPPEvalTransformation.java +++ b/core/codegen/src/main/java/org/overture/codegen/trans/conc/InstanceVarPPEvalTransformation.java @@ -2,23 +2,35 @@ import java.util.List; +import org.overture.codegen.cgast.SStmCG; import org.overture.codegen.cgast.STypeCG; import org.overture.codegen.cgast.analysis.AnalysisException; import org.overture.codegen.cgast.analysis.DepthFirstAnalysisAdaptor; import org.overture.codegen.cgast.declarations.AClassDeclCG; import org.overture.codegen.cgast.declarations.AMethodDeclCG; import org.overture.codegen.cgast.expressions.AIdentifierVarExpCG; +import org.overture.codegen.cgast.expressions.SVarExpCG; import org.overture.codegen.cgast.statements.AAssignmentStmCG; import org.overture.codegen.cgast.statements.ABlockStmCG; import org.overture.codegen.cgast.statements.ACallObjectExpStmCG; +import org.overture.codegen.cgast.statements.ALocalAssignmentStmCG; +import org.overture.codegen.cgast.statements.AMapPutStmCG; import org.overture.codegen.cgast.types.AVoidTypeCG; import org.overture.codegen.ir.IRGeneratedTag; import org.overture.codegen.ir.IRInfo; import org.overture.codegen.logging.Logger; import org.overture.codegen.trans.assistants.TransAssistantCG; +/** + * This transformation generates a "state change" call to the Sentinel class to make it re-evaluate permission + * predicates. It assumes all state updates to come from the local assignment statement, the assignment statement + * or the "map put statement". + * + * @author pvj + */ public class InstanceVarPPEvalTransformation extends DepthFirstAnalysisAdaptor { + //TODO: put constants somewhere appropriate private static final String SENTINEL_FIELD_NAME = "sentinel"; private TransAssistantCG transAssistant; private IRInfo info; @@ -34,6 +46,33 @@ public InstanceVarPPEvalTransformation(IRInfo info, TransAssistantCG transAssist @Override public void caseAAssignmentStmCG(AAssignmentStmCG node) throws AnalysisException + { + handleStateUpdate(node); + } + + @Override + public void caseALocalAssignmentStmCG(ALocalAssignmentStmCG node) + throws AnalysisException + { + if(node.getTarget() instanceof SVarExpCG) + { + SVarExpCG var = (SVarExpCG)node.getTarget(); + if(var.getIsLocal()) + { + return; + } + } + + handleStateUpdate(node); + } + + @Override + public void caseAMapPutStmCG(AMapPutStmCG node) throws AnalysisException + { + handleStateUpdate(node); + } + + private void handleStateUpdate(SStmCG node) { if(!info.getSettings().generateConc()) { @@ -83,6 +122,7 @@ public void caseAAssignmentStmCG(AAssignmentStmCG node) ACallObjectExpStmCG callSentinel = new ACallObjectExpStmCG(); callSentinel.setObj(sentinelVar); + //TODO: put constants somewhere appropriate callSentinel.setFieldName("stateChanged"); callSentinel.setType(new AVoidTypeCG()); @@ -94,7 +134,7 @@ public void caseAAssignmentStmCG(AAssignmentStmCG node) replacementBlock.getStatements().add(callSentinel); } - private STypeCG getSentinelFieldType(AAssignmentStmCG node) + private STypeCG getSentinelFieldType(SStmCG node) { AClassDeclCG enclosingClass = node.getAncestor(AClassDeclCG.class); From def73fd57316efd385c18e864beee7b766093e4b Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Mon, 2 Mar 2015 00:18:32 +0100 Subject: [PATCH 187/323] Renaming of an assignment node in the IR --- .../codegen/merging/TemplateManager.java | 4 ++-- .../codegen/trans/AssignStmTransformation.java | 14 +++++++------- .../codegen/trans/TransformationVisitor.java | 18 +++++++++--------- .../trans/assistants/TransAssistantCG.java | 6 +++--- .../conc/InstanceVarPPEvalTransformation.java | 4 ++-- .../conc/MainClassConcTransformation.java | 4 ++-- .../codegen/trans/let/LetBeStStrategy.java | 4 ++-- .../trans/patterns/PatternTransformation.java | 14 +++++++------- .../uniontypes/UnionTypeTransformation.java | 4 ++-- .../codegen/vdm2java/JavaValueSemantics.java | 6 +++--- core/codegen/src/main/resources/cg.astv2 | 2 +- 11 files changed, 40 insertions(+), 40 deletions(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/merging/TemplateManager.java b/core/codegen/src/main/java/org/overture/codegen/merging/TemplateManager.java index b1e4e701c1..6903703fc3 100644 --- a/core/codegen/src/main/java/org/overture/codegen/merging/TemplateManager.java +++ b/core/codegen/src/main/java/org/overture/codegen/merging/TemplateManager.java @@ -44,6 +44,7 @@ import org.overture.codegen.cgast.expressions.*; import org.overture.codegen.cgast.patterns.AIdentifierPatternCG; import org.overture.codegen.cgast.statements.AApplyObjectDesignatorCG; +import org.overture.codegen.cgast.statements.AAssignToExpStmCG; import org.overture.codegen.cgast.statements.AAssignmentStmCG; import org.overture.codegen.cgast.statements.ABlockStmCG; import org.overture.codegen.cgast.statements.ABreakStmCG; @@ -61,7 +62,6 @@ import org.overture.codegen.cgast.statements.AIdentifierStateDesignatorCG; import org.overture.codegen.cgast.statements.AIfStmCG; import org.overture.codegen.cgast.statements.AIncrementStmCG; -import org.overture.codegen.cgast.statements.ALocalAssignmentStmCG; import org.overture.codegen.cgast.statements.ALocalPatternAssignmentStmCG; import org.overture.codegen.cgast.statements.AMapPutStmCG; import org.overture.codegen.cgast.statements.AMapSeqStateDesignatorCG; @@ -277,7 +277,7 @@ protected void initNodeTemplateFileNames() nodeTemplateFileNames.put(ASkipStmCG.class, templateStructure.STM_PATH + "Skip"); - nodeTemplateFileNames.put(ALocalAssignmentStmCG.class, templateStructure.STM_PATH + nodeTemplateFileNames.put(AAssignToExpStmCG.class, templateStructure.STM_PATH + "LocalAssignment"); nodeTemplateFileNames.put(ALocalPatternAssignmentStmCG.class, templateStructure.STM_PATH diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/AssignStmTransformation.java b/core/codegen/src/main/java/org/overture/codegen/trans/AssignStmTransformation.java index 38e3f5aae0..074c2a6565 100644 --- a/core/codegen/src/main/java/org/overture/codegen/trans/AssignStmTransformation.java +++ b/core/codegen/src/main/java/org/overture/codegen/trans/AssignStmTransformation.java @@ -7,8 +7,8 @@ import org.overture.codegen.cgast.analysis.AnalysisException; import org.overture.codegen.cgast.analysis.DepthFirstAnalysisAdaptor; import org.overture.codegen.cgast.declarations.AClassDeclCG; +import org.overture.codegen.cgast.statements.AAssignToExpStmCG; import org.overture.codegen.cgast.statements.AAssignmentStmCG; -import org.overture.codegen.cgast.statements.ALocalAssignmentStmCG; import org.overture.codegen.cgast.statements.AMapPutStmCG; import org.overture.codegen.cgast.statements.AMapSeqStateDesignatorCG; import org.overture.codegen.ir.IRInfo; @@ -51,13 +51,13 @@ public void caseAAssignmentStmCG(AAssignmentStmCG node) } else { - ALocalAssignmentStmCG localAssign = new ALocalAssignmentStmCG(); - localAssign.setTarget(node.getTarget().apply(converter)); - localAssign.setExp(node.getExp().clone()); - localAssign.setSourceNode(node.getSourceNode()); - localAssign.setTag(node.getTag()); + AAssignToExpStmCG assign = new AAssignToExpStmCG(); + assign.setTarget(node.getTarget().apply(converter)); + assign.setExp(node.getExp().clone()); + assign.setSourceNode(node.getSourceNode()); + assign.setTag(node.getTag()); - newNode = localAssign; + newNode = assign; } if(node.parent() != null) diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/TransformationVisitor.java b/core/codegen/src/main/java/org/overture/codegen/trans/TransformationVisitor.java index 299d793433..d25542cb97 100644 --- a/core/codegen/src/main/java/org/overture/codegen/trans/TransformationVisitor.java +++ b/core/codegen/src/main/java/org/overture/codegen/trans/TransformationVisitor.java @@ -59,6 +59,7 @@ import org.overture.codegen.cgast.expressions.SBoolBinaryExpCG; import org.overture.codegen.cgast.patterns.AIdentifierPatternCG; import org.overture.codegen.cgast.patterns.ASetMultipleBindCG; +import org.overture.codegen.cgast.statements.AAssignToExpStmCG; import org.overture.codegen.cgast.statements.AAssignmentStmCG; import org.overture.codegen.cgast.statements.ABlockStmCG; import org.overture.codegen.cgast.statements.ABreakStmCG; @@ -68,7 +69,6 @@ import org.overture.codegen.cgast.statements.AIdentifierStateDesignatorCG; import org.overture.codegen.cgast.statements.AIfStmCG; import org.overture.codegen.cgast.statements.ALetBeStStmCG; -import org.overture.codegen.cgast.statements.ALocalAssignmentStmCG; import org.overture.codegen.cgast.statements.AWhileStmCG; import org.overture.codegen.cgast.types.ABoolBasicTypeCG; import org.overture.codegen.cgast.types.AIntNumericBasicTypeCG; @@ -153,11 +153,11 @@ public void caseATernaryIfExpCG(ATernaryIfExpCG node) SExpCG trueValue = node.getTrueValue(); SExpCG falseValue = node.getFalseValue(); - ALocalAssignmentStmCG trueBranch = new ALocalAssignmentStmCG(); + AAssignToExpStmCG trueBranch = new AAssignToExpStmCG(); trueBranch.setTarget(resultVar.clone()); trueBranch.setExp(trueValue.clone()); - ALocalAssignmentStmCG falseBranch = new ALocalAssignmentStmCG(); + AAssignToExpStmCG falseBranch = new AAssignToExpStmCG(); falseBranch.setTarget(resultVar.clone()); falseBranch.setExp(falseValue); @@ -361,7 +361,7 @@ public void caseALetBeStExpCG(ALetBeStExpCG node) throws AnalysisException AVarDeclCG resultDecl = transformationAssistant.consDecl(var, value.getType().clone(), transformationAssistant.consNullExp()); outerBlock.getLocalDefs().add(resultDecl); - ALocalAssignmentStmCG setLetBeStResult = new ALocalAssignmentStmCG(); + AAssignToExpStmCG setLetBeStResult = new AAssignToExpStmCG(); setLetBeStResult.setTarget(transformationAssistant.consIdentifierVar(var, value.getType().clone())); setLetBeStResult.setExp(value); outerBlock.getStatements().add(setLetBeStResult); @@ -698,10 +698,10 @@ private void transform(SStmCG enclosingStm, ABlockStmCG block, block.getStatements().add(enclosingStm); } - private ALocalAssignmentStmCG assignToVar(AIdentifierVarExpCG var, + private AAssignToExpStmCG assignToVar(AIdentifierVarExpCG var, SExpCG exp) { - ALocalAssignmentStmCG assignment = new ALocalAssignmentStmCG(); + AAssignToExpStmCG assignment = new AAssignToExpStmCG(); assignment.setTarget(var.clone()); assignment.setExp(exp.clone()); @@ -768,7 +768,7 @@ private AIfStmCG consAndExpCheck(AAndBoolBinaryExpCG node, String andResultVarNa AIfStmCG rightCheck = new AIfStmCG(); rightCheck.setIfExp(right); - ALocalAssignmentStmCG assignAndVar = new ALocalAssignmentStmCG(); + AAssignToExpStmCG assignAndVar = new AAssignToExpStmCG(); assignAndVar.setTarget(transformationAssistant.consBoolCheck(andResultVarName, false)); assignAndVar.setExp(info.getAssistantManager().getExpAssistant().consBoolLiteral(true)); @@ -787,13 +787,13 @@ private SStmCG consOrExpCheck(AOrBoolBinaryExpCG node, String orResultVarName) AIfStmCG leftCheck = new AIfStmCG(); leftCheck.setIfExp(left); - ALocalAssignmentStmCG setOrResultVarTrue = new ALocalAssignmentStmCG(); + AAssignToExpStmCG setOrResultVarTrue = new AAssignToExpStmCG(); setOrResultVarTrue.setTarget(transformationAssistant.consBoolCheck(orResultVarName, false)); setOrResultVarTrue.setExp(info.getAssistantManager().getExpAssistant().consBoolLiteral(true)); leftCheck.setThenStm(setOrResultVarTrue); - ALocalAssignmentStmCG setOrResultVarToRightExp = new ALocalAssignmentStmCG(); + AAssignToExpStmCG setOrResultVarToRightExp = new AAssignToExpStmCG(); setOrResultVarToRightExp.setTarget(transformationAssistant.consBoolCheck(orResultVarName, false)); setOrResultVarToRightExp.setExp(right); diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/assistants/TransAssistantCG.java b/core/codegen/src/main/java/org/overture/codegen/trans/assistants/TransAssistantCG.java index 3f680d2145..d5989ba87f 100644 --- a/core/codegen/src/main/java/org/overture/codegen/trans/assistants/TransAssistantCG.java +++ b/core/codegen/src/main/java/org/overture/codegen/trans/assistants/TransAssistantCG.java @@ -49,12 +49,12 @@ import org.overture.codegen.cgast.name.ATypeNameCG; import org.overture.codegen.cgast.patterns.AIdentifierPatternCG; import org.overture.codegen.cgast.patterns.ASetMultipleBindCG; +import org.overture.codegen.cgast.statements.AAssignToExpStmCG; import org.overture.codegen.cgast.statements.ABlockStmCG; import org.overture.codegen.cgast.statements.ACallObjectExpStmCG; import org.overture.codegen.cgast.statements.AForLoopStmCG; import org.overture.codegen.cgast.statements.AIfStmCG; import org.overture.codegen.cgast.statements.AIncrementStmCG; -import org.overture.codegen.cgast.statements.ALocalAssignmentStmCG; import org.overture.codegen.cgast.statements.ALocalPatternAssignmentStmCG; import org.overture.codegen.cgast.types.ABoolBasicTypeCG; import org.overture.codegen.cgast.types.AClassTypeCG; @@ -229,10 +229,10 @@ public SExpCG consBoolCheck(String boolVarName, boolean negate) } } - public ALocalAssignmentStmCG consBoolVarAssignment(SExpCG predicate, + public AAssignToExpStmCG consBoolVarAssignment(SExpCG predicate, String boolVarName) { - ALocalAssignmentStmCG boolVarAssignment = new ALocalAssignmentStmCG(); + AAssignToExpStmCG boolVarAssignment = new AAssignToExpStmCG(); boolVarAssignment.setTarget(consBoolCheck(boolVarName, false)); boolVarAssignment.setExp(predicate != null ? predicate.clone() : info.getExpAssistant().consBoolLiteral(true)); diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/conc/InstanceVarPPEvalTransformation.java b/core/codegen/src/main/java/org/overture/codegen/trans/conc/InstanceVarPPEvalTransformation.java index 56ef87ca31..502bb02724 100644 --- a/core/codegen/src/main/java/org/overture/codegen/trans/conc/InstanceVarPPEvalTransformation.java +++ b/core/codegen/src/main/java/org/overture/codegen/trans/conc/InstanceVarPPEvalTransformation.java @@ -10,10 +10,10 @@ import org.overture.codegen.cgast.declarations.AMethodDeclCG; import org.overture.codegen.cgast.expressions.AIdentifierVarExpCG; import org.overture.codegen.cgast.expressions.SVarExpCG; +import org.overture.codegen.cgast.statements.AAssignToExpStmCG; import org.overture.codegen.cgast.statements.AAssignmentStmCG; import org.overture.codegen.cgast.statements.ABlockStmCG; import org.overture.codegen.cgast.statements.ACallObjectExpStmCG; -import org.overture.codegen.cgast.statements.ALocalAssignmentStmCG; import org.overture.codegen.cgast.statements.AMapPutStmCG; import org.overture.codegen.cgast.types.AVoidTypeCG; import org.overture.codegen.ir.IRGeneratedTag; @@ -51,7 +51,7 @@ public void caseAAssignmentStmCG(AAssignmentStmCG node) } @Override - public void caseALocalAssignmentStmCG(ALocalAssignmentStmCG node) + public void caseAAssignToExpStmCG(AAssignToExpStmCG node) throws AnalysisException { if(node.getTarget() instanceof SVarExpCG) diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/conc/MainClassConcTransformation.java b/core/codegen/src/main/java/org/overture/codegen/trans/conc/MainClassConcTransformation.java index 355a4f76c5..afc2dbcba3 100644 --- a/core/codegen/src/main/java/org/overture/codegen/trans/conc/MainClassConcTransformation.java +++ b/core/codegen/src/main/java/org/overture/codegen/trans/conc/MainClassConcTransformation.java @@ -24,10 +24,10 @@ import org.overture.codegen.cgast.expressions.ASelfExpCG; import org.overture.codegen.cgast.name.ATypeNameCG; import org.overture.codegen.cgast.patterns.AIdentifierPatternCG; +import org.overture.codegen.cgast.statements.AAssignToExpStmCG; import org.overture.codegen.cgast.statements.ABlockStmCG; import org.overture.codegen.cgast.statements.AElseIfStmCG; import org.overture.codegen.cgast.statements.AIfStmCG; -import org.overture.codegen.cgast.statements.ALocalAssignmentStmCG; import org.overture.codegen.cgast.statements.APlainCallStmCG; import org.overture.codegen.cgast.statements.AReturnStmCG; import org.overture.codegen.cgast.statements.ATryStmCG; @@ -144,7 +144,7 @@ public void caseAClassDeclCG(AClassDeclCG node) throws AnalysisException { ABlockStmCG bodyConst = new ABlockStmCG(); - ALocalAssignmentStmCG stm = new ALocalAssignmentStmCG(); + AAssignToExpStmCG stm = new AAssignToExpStmCG(); AIdentifierVarExpCG field = new AIdentifierVarExpCG(); diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/let/LetBeStStrategy.java b/core/codegen/src/main/java/org/overture/codegen/trans/let/LetBeStStrategy.java index 61012205de..b5751bcbd9 100644 --- a/core/codegen/src/main/java/org/overture/codegen/trans/let/LetBeStStrategy.java +++ b/core/codegen/src/main/java/org/overture/codegen/trans/let/LetBeStStrategy.java @@ -32,8 +32,8 @@ import org.overture.codegen.cgast.expressions.AIdentifierVarExpCG; import org.overture.codegen.cgast.expressions.ALetBeStNoBindingRuntimeErrorExpCG; import org.overture.codegen.cgast.expressions.ANullExpCG; +import org.overture.codegen.cgast.statements.AAssignToExpStmCG; import org.overture.codegen.cgast.statements.AIfStmCG; -import org.overture.codegen.cgast.statements.ALocalAssignmentStmCG; import org.overture.codegen.cgast.statements.ALocalPatternAssignmentStmCG; import org.overture.codegen.cgast.statements.ARaiseErrorStmCG; import org.overture.codegen.cgast.types.AErrorTypeCG; @@ -97,7 +97,7 @@ public List getPreForLoopStms(AIdentifierVarExpCG setVar, { if (count > 0) { - ALocalAssignmentStmCG successAssignment = new ALocalAssignmentStmCG(); + AAssignToExpStmCG successAssignment = new AAssignToExpStmCG(); successAssignment.setExp(transAssistant.getInfo().getExpAssistant().consBoolLiteral(false)); successAssignment.setTarget(transAssistant.consSuccessVar(successVarName)); diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/patterns/PatternTransformation.java b/core/codegen/src/main/java/org/overture/codegen/trans/patterns/PatternTransformation.java index 89792e3ba2..b008c1458a 100644 --- a/core/codegen/src/main/java/org/overture/codegen/trans/patterns/PatternTransformation.java +++ b/core/codegen/src/main/java/org/overture/codegen/trans/patterns/PatternTransformation.java @@ -66,13 +66,13 @@ import org.overture.codegen.cgast.patterns.ARecordPatternCG; import org.overture.codegen.cgast.patterns.AStringPatternCG; import org.overture.codegen.cgast.patterns.ATuplePatternCG; +import org.overture.codegen.cgast.statements.AAssignToExpStmCG; import org.overture.codegen.cgast.statements.ABlockStmCG; import org.overture.codegen.cgast.statements.ACaseAltStmStmCG; import org.overture.codegen.cgast.statements.ACasesStmCG; import org.overture.codegen.cgast.statements.AContinueStmCG; import org.overture.codegen.cgast.statements.AForAllStmCG; import org.overture.codegen.cgast.statements.AIfStmCG; -import org.overture.codegen.cgast.statements.ALocalAssignmentStmCG; import org.overture.codegen.cgast.statements.ALocalPatternAssignmentStmCG; import org.overture.codegen.cgast.statements.ARaiseErrorStmCG; import org.overture.codegen.cgast.types.ABoolBasicTypeCG; @@ -446,7 +446,7 @@ private ABlockStmCG consPatternHandlingInIterationBlock( varExp.setIsLambda(false); varExp.setName(((AIdentifierPatternCG) nextDeclPattern).getName()); - ALocalAssignmentStmCG assignment = new ALocalAssignmentStmCG(); + AAssignToExpStmCG assignment = new AAssignToExpStmCG(); assignment.setTarget(varExp); assignment.setExp(assignedExp.clone()); replacementBlock.getStatements().addFirst(assignment); @@ -815,7 +815,7 @@ private ABlockStmCG consRecordPatternCheck(boolean declarePattern, ifStm.setIfExp(instanceOfExp); ifStm.setThenStm(recordPatternBlock); - ALocalAssignmentStmCG setFalse = new ALocalAssignmentStmCG(); + AAssignToExpStmCG setFalse = new AAssignToExpStmCG(); setFalse.setTarget(patternData.getSuccessVar().clone()); setFalse.setExp(info.getExpAssistant().consBoolLiteral(false)); ifStm.setElseStm(setFalse); @@ -950,7 +950,7 @@ private void initSuccessVar(PatternBlockData patternData, SExpCG initExp, patternData.getSuccessVarDecl().setExp(initExp); } else { - ALocalAssignmentStmCG successVarAssignment = new ALocalAssignmentStmCG(); + AAssignToExpStmCG successVarAssignment = new AAssignToExpStmCG(); successVarAssignment.setTarget(patternData.getSuccessVar().clone()); successVarAssignment.setExp(initExp); @@ -998,7 +998,7 @@ private ABlockStmCG consFieldCheckBlock(PatternBlockData patternData, if (currentPattern instanceof AIdentifierPatternCG) { - ALocalAssignmentStmCG localAssignment = declareAndAssignIdVarAssignment(patternData.getDeclBlock(), currentPattern, currentType, actualValue); + AAssignToExpStmCG localAssignment = declareAndAssignIdVarAssignment(patternData.getDeclBlock(), currentPattern, currentType, actualValue); thenPart.getStatements().add(localAssignment); } else { @@ -1093,7 +1093,7 @@ private SExpCG consFieldValueToMatch(AIdentifierVarExpCG patternVar, return null; } - private ALocalAssignmentStmCG declareAndAssignIdVarAssignment( + private AAssignToExpStmCG declareAndAssignIdVarAssignment( ABlockStmCG declBlock, SPatternCG currentPattern, STypeCG currentType, SExpCG valueToMatch) { @@ -1110,7 +1110,7 @@ private ALocalAssignmentStmCG declareAndAssignIdVarAssignment( var.setIsLocal(true); var.setIsLambda(false); - ALocalAssignmentStmCG localAssignment = new ALocalAssignmentStmCG(); + AAssignToExpStmCG localAssignment = new AAssignToExpStmCG(); localAssignment.setTarget(var); localAssignment.setExp(valueToMatch); diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/uniontypes/UnionTypeTransformation.java b/core/codegen/src/main/java/org/overture/codegen/trans/uniontypes/UnionTypeTransformation.java index b1f7725705..99ae4133dd 100644 --- a/core/codegen/src/main/java/org/overture/codegen/trans/uniontypes/UnionTypeTransformation.java +++ b/core/codegen/src/main/java/org/overture/codegen/trans/uniontypes/UnionTypeTransformation.java @@ -58,11 +58,11 @@ import org.overture.codegen.cgast.expressions.SVarExpBase; import org.overture.codegen.cgast.expressions.SVarExpCG; import org.overture.codegen.cgast.patterns.AIdentifierPatternCG; +import org.overture.codegen.cgast.statements.AAssignToExpStmCG; import org.overture.codegen.cgast.statements.ABlockStmCG; import org.overture.codegen.cgast.statements.ACallObjectExpStmCG; import org.overture.codegen.cgast.statements.AElseIfStmCG; import org.overture.codegen.cgast.statements.AIfStmCG; -import org.overture.codegen.cgast.statements.ALocalAssignmentStmCG; import org.overture.codegen.cgast.statements.APlainCallStmCG; import org.overture.codegen.cgast.statements.ARaiseErrorStmCG; import org.overture.codegen.cgast.statements.AReturnStmCG; @@ -409,7 +409,7 @@ private void handleFieldExp(SExpCG node, String memberName, SExpCG subject, STyp setSubject(fieldExp, castedFieldExp); - ALocalAssignmentStmCG assignment = new ALocalAssignmentStmCG(); + AAssignToExpStmCG assignment = new AAssignToExpStmCG(); assignment.setTarget(resultVar.clone()); assignment.setExp(getAssignmentExp(node, fieldExp)); diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaValueSemantics.java b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaValueSemantics.java index 67eaa7554b..4cd22e329e 100644 --- a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaValueSemantics.java +++ b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaValueSemantics.java @@ -50,8 +50,8 @@ import org.overture.codegen.cgast.expressions.ASetSubsetBinaryExpCG; import org.overture.codegen.cgast.expressions.ATupleCompatibilityExpCG; import org.overture.codegen.cgast.expressions.ATupleSizeExpCG; +import org.overture.codegen.cgast.statements.AAssignToExpStmCG; import org.overture.codegen.cgast.statements.AForAllStmCG; -import org.overture.codegen.cgast.statements.ALocalAssignmentStmCG; import org.overture.codegen.cgast.statements.AMapPutStmCG; import org.overture.codegen.cgast.types.AExternalTypeCG; import org.overture.codegen.cgast.types.AMethodTypeCG; @@ -175,9 +175,9 @@ public boolean shouldClone(SExpCG exp) return false; } - if (parent instanceof ALocalAssignmentStmCG) + if (parent instanceof AAssignToExpStmCG) { - ALocalAssignmentStmCG assignment = (ALocalAssignmentStmCG) parent; + AAssignToExpStmCG assignment = (AAssignToExpStmCG) parent; if (assignment.getTarget() == exp) { return false; diff --git a/core/codegen/src/main/resources/cg.astv2 b/core/codegen/src/main/resources/cg.astv2 index 7e9ccc1a54..5babdf490a 100644 --- a/core/codegen/src/main/resources/cg.astv2 +++ b/core/codegen/src/main/resources/cg.astv2 @@ -196,7 +196,7 @@ CG {-> package='org.overture.codegen.cgast' | {return} [exp]:CG.#exp | {abstractBody} | {assignment} [target]:CG.#stateDesignator [exp]:CG.#exp - | {localAssignment} [target]:CG.#exp [exp]:CG.#exp + | {assignToExp} [target]:CG.#exp [exp]:CG.#exp | {localPatternAssignment} [target]:CG.#pattern [exp]:CG.#exp (nextElementDecl):CG.#decl.var | {block} [scoped]:java_Boolean [localDefs]:CG.#decl.var* [statements]:CG.#stm* | {callObject} [type]:CG.#type [designator]:CG.#objectDesignator /*[className]:java_String*/ [fieldName]:java_String From 78555db1ff52f95a09e8d1ede60120e354d374cd Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Mon, 2 Mar 2015 13:06:21 +0100 Subject: [PATCH 188/323] Improved result files related to code generation of concurrency Removed some 'sentinel.stateChanged()' calls, which are not needed --- .../POP3_LogBased_Test1.result | 10 ---------- 1 file changed, 10 deletions(-) diff --git a/core/codegen/src/test/resources/concurrency_classics_specs/POP3_LogBased_Test1.result b/core/codegen/src/test/resources/concurrency_classics_specs/POP3_LogBased_Test1.result index ca5b2d827a..3421c13be2 100644 --- a/core/codegen/src/test/resources/concurrency_classics_specs/POP3_LogBased_Test1.result +++ b/core/codegen/src/test/resources/concurrency_classics_specs/POP3_LogBased_Test1.result @@ -1587,8 +1587,6 @@ public class POP3Server extends VDMThread implements EvaluatePP { seqCompResult_2 = SeqUtil.conc(Utils.clone(seqCompResult_2), SeqUtil.seq( ((POP3Message) oldMsgs.get(Utils.index(i))))); - - sentinel.stateChanged(); } } @@ -1737,8 +1735,6 @@ public class POP3Server extends VDMThread implements EvaluatePP { seqCompResult_3 = SeqUtil.conc(Utils.clone(seqCompResult_3), SeqUtil.seq( ((POP3Message) oldMsgs.get(Utils.index(i))).Undelete())); - - sentinel.stateChanged(); } VDMSeq newMsgs = Utils.clone(seqCompResult_3); @@ -1787,8 +1783,6 @@ public class POP3Server extends VDMThread implements EvaluatePP { seqCompResult_4), SeqUtil.seq( new MessageInfo(i, GetMessageSize(user, i)))); - - sentinel.stateChanged(); } } @@ -1827,8 +1821,6 @@ public class POP3Server extends VDMThread implements EvaluatePP { Number index = ((Number) iterator_8.next()); seqCompResult_5 = SeqUtil.conc(Utils.clone(seqCompResult_5), SeqUtil.seq(GetUidl(user, index))); - - sentinel.stateChanged(); } return Utils.clone(seqCompResult_5); @@ -1860,8 +1852,6 @@ public class POP3Server extends VDMThread implements EvaluatePP { seqCompResult_6 = SeqUtil.conc(Utils.clone(seqCompResult_6), SeqUtil.seq( ((POP3Message) mb.msgs.get(Utils.index(i))).GetSize())); - - sentinel.stateChanged(); } return sumseq(Utils.clone(seqCompResult_6)); From d6d298d3678607aca8f93aa70a515b6d59a2d35a Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Mon, 2 Mar 2015 13:09:37 +0100 Subject: [PATCH 189/323] Moved a state designator to exp conversion method into the Expression Assistant --- .../codegen/assistant/ExpAssistantCG.java | 36 +++++++++++++++++++ 1 file changed, 36 insertions(+) diff --git a/core/codegen/src/main/java/org/overture/codegen/assistant/ExpAssistantCG.java b/core/codegen/src/main/java/org/overture/codegen/assistant/ExpAssistantCG.java index 4296d58093..e449f87101 100644 --- a/core/codegen/src/main/java/org/overture/codegen/assistant/ExpAssistantCG.java +++ b/core/codegen/src/main/java/org/overture/codegen/assistant/ExpAssistantCG.java @@ -52,6 +52,7 @@ import org.overture.codegen.cgast.SExpCG; import org.overture.codegen.cgast.SMultipleBindCG; import org.overture.codegen.cgast.STypeCG; +import org.overture.codegen.cgast.declarations.AClassDeclCG; import org.overture.codegen.cgast.expressions.ABoolIsExpCG; import org.overture.codegen.cgast.expressions.ABoolLiteralExpCG; import org.overture.codegen.cgast.expressions.ACaseAltExpExpCG; @@ -59,7 +60,9 @@ import org.overture.codegen.cgast.expressions.ACharLiteralExpCG; import org.overture.codegen.cgast.expressions.AEnumSeqExpCG; import org.overture.codegen.cgast.expressions.AEqualsBinaryExpCG; +import org.overture.codegen.cgast.expressions.AExplicitVarExpCG; import org.overture.codegen.cgast.expressions.AGeneralIsExpCG; +import org.overture.codegen.cgast.expressions.AIdentifierVarExpCG; import org.overture.codegen.cgast.expressions.AIntIsExpCG; import org.overture.codegen.cgast.expressions.AIntLiteralExpCG; import org.overture.codegen.cgast.expressions.AIsolationUnaryExpCG; @@ -80,6 +83,7 @@ import org.overture.codegen.cgast.expressions.SUnaryExpCG; import org.overture.codegen.cgast.patterns.ASetMultipleBindCG; import org.overture.codegen.cgast.statements.AForLoopStmCG; +import org.overture.codegen.cgast.statements.AIdentifierStateDesignatorCG; import org.overture.codegen.cgast.statements.AWhileStmCG; import org.overture.codegen.cgast.types.ABoolBasicTypeCG; import org.overture.codegen.cgast.types.ACharBasicTypeCG; @@ -98,6 +102,7 @@ import org.overture.codegen.cgast.types.SBasicTypeCG; import org.overture.codegen.cgast.utils.AHeaderLetBeStCG; import org.overture.codegen.ir.IRInfo; +import org.overture.codegen.trans.assistants.TransAssistantCG; public class ExpAssistantCG extends AssistantBase { @@ -556,4 +561,35 @@ public SExpCG consIsExpBasicType(SExpCG expCg, STypeCG checkedType) return basicIsExp; } + + public SExpCG idStateDesignatorToExp(IRInfo info, TransAssistantCG transAssistant, List classes, AIdentifierStateDesignatorCG node) + { + boolean isLocal = info.getDeclAssistant().isLocal(node, classes); + + if(node.getExplicit()) + { + AClassTypeCG classType = new AClassTypeCG(); + classType.setName(node.getClassName()); + + AExplicitVarExpCG explicitVar = new AExplicitVarExpCG(); + explicitVar.setClassType(classType); + explicitVar.setIsLambda(false); + explicitVar.setIsLocal(isLocal); + explicitVar.setName(node.getName()); + explicitVar.setSourceNode(node.getSourceNode()); + explicitVar.setTag(node.getTag()); + explicitVar.setType(node.getType().clone()); + + return explicitVar; + } + else + { + AIdentifierVarExpCG idVar = transAssistant.consIdentifierVar(node.getName(), node.getType().clone()); + idVar.setTag(node.getTag()); + idVar.setSourceNode(node.getSourceNode()); + idVar.setIsLocal(isLocal); + + return idVar; + } + } } From 3a8b143a4b91e648680273855e26c509e0179a4c Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Mon, 2 Mar 2015 13:13:30 +0100 Subject: [PATCH 190/323] Cleared out assignment statements that are added to the IR post the assignment statement transformation --- .../codegen/trans/TransformationVisitor.java | 35 +++++-------------- .../codegen/trans/comp/CompStrategy.java | 10 +++--- .../trans/conv/StateDesignatorToExpCG.java | 31 +--------------- .../vdm2java/JavaQuoteValueCreator.java | 20 ++++------- .../codegen/vdm2java/JavaRecordCreator.java | 10 +++--- 5 files changed, 25 insertions(+), 81 deletions(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/TransformationVisitor.java b/core/codegen/src/main/java/org/overture/codegen/trans/TransformationVisitor.java index d25542cb97..2cab8d6d61 100644 --- a/core/codegen/src/main/java/org/overture/codegen/trans/TransformationVisitor.java +++ b/core/codegen/src/main/java/org/overture/codegen/trans/TransformationVisitor.java @@ -45,6 +45,7 @@ import org.overture.codegen.cgast.expressions.AEqualsBinaryExpCG; import org.overture.codegen.cgast.expressions.AExists1QuantifierExpCG; import org.overture.codegen.cgast.expressions.AExistsQuantifierExpCG; +import org.overture.codegen.cgast.expressions.AFieldExpCG; import org.overture.codegen.cgast.expressions.AForAllQuantifierExpCG; import org.overture.codegen.cgast.expressions.AIdentifierVarExpCG; import org.overture.codegen.cgast.expressions.ALetBeStExpCG; @@ -60,13 +61,10 @@ import org.overture.codegen.cgast.patterns.AIdentifierPatternCG; import org.overture.codegen.cgast.patterns.ASetMultipleBindCG; import org.overture.codegen.cgast.statements.AAssignToExpStmCG; -import org.overture.codegen.cgast.statements.AAssignmentStmCG; import org.overture.codegen.cgast.statements.ABlockStmCG; import org.overture.codegen.cgast.statements.ABreakStmCG; import org.overture.codegen.cgast.statements.ACaseAltStmStmCG; import org.overture.codegen.cgast.statements.ACasesStmCG; -import org.overture.codegen.cgast.statements.AFieldStateDesignatorCG; -import org.overture.codegen.cgast.statements.AIdentifierStateDesignatorCG; import org.overture.codegen.cgast.statements.AIfStmCG; import org.overture.codegen.cgast.statements.ALetBeStStmCG; import org.overture.codegen.cgast.statements.AWhileStmCG; @@ -77,7 +75,6 @@ import org.overture.codegen.ir.IRConstants; import org.overture.codegen.ir.IRInfo; import org.overture.codegen.ir.ITempVarGen; -import org.overture.codegen.logging.Logger; import org.overture.codegen.trans.assistants.TransAssistantCG; import org.overture.codegen.trans.comp.ComplexCompStrategy; import org.overture.codegen.trans.comp.MapCompStrategy; @@ -394,8 +391,6 @@ public void caseALetBeStExpCG(ALetBeStExpCG node) throws AnalysisException public void caseARecordModExpCG(ARecordModExpCG node) throws AnalysisException { - AClassDeclCG enclosingClass = node.getAncestor(AClassDeclCG.class); - String recModifierName = info.getTempVarNameGen().nextVarName(recModifierExpPrefix); AVarDeclCG recDecl = transformationAssistant.consDecl(recModifierName, node.getType().clone(), node.getRec().clone()); @@ -403,20 +398,6 @@ public void caseARecordModExpCG(ARecordModExpCG node) declStm.getLocalDefs().add(recDecl); AIdentifierVarExpCG recVar = transformationAssistant.consIdentifierVar(recModifierName, node.getType().clone()); - - AIdentifierStateDesignatorCG rec = new AIdentifierStateDesignatorCG(); - rec.setName(recVar.getName()); - rec.setType(node.getRecType().clone()); - rec.setExplicit(false); - - if(enclosingClass != null) - { - rec.setClassName(enclosingClass.getName()); - } - else - { - Logger.getLog().printErrorln("Could not find enclosing class for node: " + node); - } ABlockStmCG replacementBlock = new ABlockStmCG(); replacementBlock.getStatements().add(declStm); @@ -428,13 +409,13 @@ public void caseARecordModExpCG(ARecordModExpCG node) STypeCG fieldType = info.getTypeAssistant().getFieldType(classes, node.getRecType(), name); - AFieldStateDesignatorCG fieldDesignator = new AFieldStateDesignatorCG(); - fieldDesignator.setType(fieldType); - fieldDesignator.setObject(rec.clone()); - fieldDesignator.setField(name); + AFieldExpCG field = new AFieldExpCG(); + field.setType(fieldType); + field.setObject(recVar.clone()); + field.setMemberName(name); - AAssignmentStmCG assignment = new AAssignmentStmCG(); - assignment.setTarget(fieldDesignator); + AAssignToExpStmCG assignment = new AAssignToExpStmCG(); + assignment.setTarget(field); assignment.setExp(value); replacementBlock.getStatements().add(assignment); @@ -442,7 +423,7 @@ public void caseARecordModExpCG(ARecordModExpCG node) SStmCG enclosingStm = transformationAssistant.getEnclosingStm(node, "record modification expression"); - transform(enclosingStm, replacementBlock, recVar, node); + transform(enclosingStm, replacementBlock, recVar.clone(), node); replacementBlock.apply(this); } diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/comp/CompStrategy.java b/core/codegen/src/main/java/org/overture/codegen/trans/comp/CompStrategy.java index 83d36c9900..96882eb642 100644 --- a/core/codegen/src/main/java/org/overture/codegen/trans/comp/CompStrategy.java +++ b/core/codegen/src/main/java/org/overture/codegen/trans/comp/CompStrategy.java @@ -32,8 +32,7 @@ import org.overture.codegen.cgast.expressions.AIdentifierVarExpCG; import org.overture.codegen.cgast.expressions.SBinaryExpCG; import org.overture.codegen.cgast.patterns.AIdentifierPatternCG; -import org.overture.codegen.cgast.statements.AAssignmentStmCG; -import org.overture.codegen.cgast.statements.AIdentifierStateDesignatorCG; +import org.overture.codegen.cgast.statements.AAssignToExpStmCG; import org.overture.codegen.cgast.statements.AIfStmCG; import org.overture.codegen.ir.ITempVarGen; import org.overture.codegen.trans.AbstractIterationStrategy; @@ -72,11 +71,10 @@ protected abstract List getConditionalAdd( protected List consConditionalAdd(AIdentifierVarExpCG compResult, SBinaryExpCG collectionMerge) { - AIdentifierStateDesignatorCG result = new AIdentifierStateDesignatorCG(); - result.setType(compResult.getType().clone()); - result.setName(compResult.getName()); + AIdentifierVarExpCG result = transAssistant.consIdentifierVar(compResult.getName(), + compResult.getType().clone()); - AAssignmentStmCG updateCompResult = new AAssignmentStmCG(); + AAssignToExpStmCG updateCompResult = new AAssignToExpStmCG(); updateCompResult.setTarget(result); updateCompResult.setExp(collectionMerge); diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/conv/StateDesignatorToExpCG.java b/core/codegen/src/main/java/org/overture/codegen/trans/conv/StateDesignatorToExpCG.java index 74fdb6ee25..a2c23ec4d1 100644 --- a/core/codegen/src/main/java/org/overture/codegen/trans/conv/StateDesignatorToExpCG.java +++ b/core/codegen/src/main/java/org/overture/codegen/trans/conv/StateDesignatorToExpCG.java @@ -7,14 +7,11 @@ import org.overture.codegen.cgast.analysis.AnalysisException; import org.overture.codegen.cgast.analysis.AnswerAdaptor; import org.overture.codegen.cgast.declarations.AClassDeclCG; -import org.overture.codegen.cgast.expressions.AExplicitVarExpCG; import org.overture.codegen.cgast.expressions.AFieldExpCG; -import org.overture.codegen.cgast.expressions.AIdentifierVarExpCG; import org.overture.codegen.cgast.expressions.AMapGetExpCG; import org.overture.codegen.cgast.statements.AFieldStateDesignatorCG; import org.overture.codegen.cgast.statements.AIdentifierStateDesignatorCG; import org.overture.codegen.cgast.statements.AMapSeqStateDesignatorCG; -import org.overture.codegen.cgast.types.AClassTypeCG; import org.overture.codegen.ir.IRInfo; import org.overture.codegen.trans.assistants.TransAssistantCG; @@ -42,33 +39,7 @@ public StateDesignatorToExpCG(IRInfo info, List classes, TransAssi public SExpCG caseAIdentifierStateDesignatorCG( AIdentifierStateDesignatorCG node) throws AnalysisException { - boolean isLocal = info.getDeclAssistant().isLocal(node, classes); - - if(node.getExplicit()) - { - AClassTypeCG classType = new AClassTypeCG(); - classType.setName(node.getClassName()); - - AExplicitVarExpCG explicitVar = new AExplicitVarExpCG(); - explicitVar.setClassType(classType); - explicitVar.setIsLambda(false); - explicitVar.setIsLocal(isLocal); - explicitVar.setName(node.getName()); - explicitVar.setSourceNode(node.getSourceNode()); - explicitVar.setTag(node.getTag()); - explicitVar.setType(node.getType().clone()); - - return explicitVar; - } - else - { - AIdentifierVarExpCG idVar = transAssistant.consIdentifierVar(node.getName(), node.getType().clone()); - idVar.setTag(node.getTag()); - idVar.setSourceNode(node.getSourceNode()); - idVar.setIsLocal(isLocal); - - return idVar; - } + return info.getExpAssistant().idStateDesignatorToExp(info, transAssistant, classes, node); } @Override diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaQuoteValueCreator.java b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaQuoteValueCreator.java index 58297d0a3e..ae3cfb6bc5 100644 --- a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaQuoteValueCreator.java +++ b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaQuoteValueCreator.java @@ -14,9 +14,8 @@ import org.overture.codegen.cgast.expressions.ANullExpCG; import org.overture.codegen.cgast.expressions.ASuperVarExpCG; import org.overture.codegen.cgast.name.ATypeNameCG; -import org.overture.codegen.cgast.statements.AAssignmentStmCG; +import org.overture.codegen.cgast.statements.AAssignToExpStmCG; import org.overture.codegen.cgast.statements.ABlockStmCG; -import org.overture.codegen.cgast.statements.AIdentifierStateDesignatorCG; import org.overture.codegen.cgast.statements.AIfStmCG; import org.overture.codegen.cgast.statements.AReturnStmCG; import org.overture.codegen.cgast.types.ABoolBasicTypeCG; @@ -114,11 +113,7 @@ private AMethodDeclCG consQuoteCtor(String name) hashcodeCompare.setLeft(hashcodeVar); hashcodeCompare.setRight(consZero()); - AIdentifierStateDesignatorCG hashCodeId = new AIdentifierStateDesignatorCG(); - hashCodeId.setClassName(name); - hashCodeId.setExplicit(false); - hashCodeId.setName(HASHCODE_FIELD); - hashCodeId.setType(consFieldType()); + AIdentifierVarExpCG hashCodeId = transformationAssistant.consIdentifierVar(HASHCODE_FIELD, consFieldType()); AMethodTypeCG hashCodeMethodType = new AMethodTypeCG(); hashCodeMethodType.setResult(consFieldType()); @@ -133,7 +128,7 @@ private AMethodDeclCG consQuoteCtor(String name) superCall.setType(consFieldType()); superCall.setRoot(superVar); - AAssignmentStmCG assignHashcode = new AAssignmentStmCG(); + AAssignToExpStmCG assignHashcode = new AAssignToExpStmCG(); assignHashcode.setTarget(hashCodeId); assignHashcode.setExp(superCall); @@ -162,11 +157,8 @@ private AMethodDeclCG consGetInstanceMethod(String name) nullCompare.setLeft(instanceVar); nullCompare.setRight(new ANullExpCG()); - AIdentifierStateDesignatorCG instanceId = new AIdentifierStateDesignatorCG(); - instanceId.setClassName(name); - instanceId.setExplicit(false); - instanceId.setName(INSTANCE_FIELD); - instanceId.setType(quoteClassType.clone()); + AIdentifierVarExpCG instanceId = transformationAssistant.consIdentifierVar(INSTANCE_FIELD, + quoteClassType.clone()); ATypeNameCG typeName = new ATypeNameCG(); typeName.setDefiningClass(null); @@ -176,7 +168,7 @@ private AMethodDeclCG consGetInstanceMethod(String name) newQuote.setName(typeName); newQuote.setType(quoteClassType); - AAssignmentStmCG assignInstance = new AAssignmentStmCG(); + AAssignToExpStmCG assignInstance = new AAssignToExpStmCG(); assignInstance.setTarget(instanceId); assignInstance.setExp(newQuote); diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaRecordCreator.java b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaRecordCreator.java index 8d39e349f5..a0b06268e2 100644 --- a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaRecordCreator.java +++ b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaRecordCreator.java @@ -42,9 +42,8 @@ import org.overture.codegen.cgast.expressions.ATernaryIfExpCG; import org.overture.codegen.cgast.name.ATypeNameCG; import org.overture.codegen.cgast.patterns.AIdentifierPatternCG; -import org.overture.codegen.cgast.statements.AAssignmentStmCG; +import org.overture.codegen.cgast.statements.AAssignToExpStmCG; import org.overture.codegen.cgast.statements.ABlockStmCG; -import org.overture.codegen.cgast.statements.AIdentifierStateDesignatorCG; import org.overture.codegen.cgast.statements.AIfStmCG; import org.overture.codegen.cgast.statements.AReturnStmCG; import org.overture.codegen.cgast.types.ABoolBasicTypeCG; @@ -94,9 +93,12 @@ public String formatRecordConstructor(ARecordDeclCG record) // Construct the initialization of the record field using the // corresponding formal parameter. - AAssignmentStmCG assignment = new AAssignmentStmCG(); - AIdentifierStateDesignatorCG id = new AIdentifierStateDesignatorCG(); + AAssignToExpStmCG assignment = new AAssignToExpStmCG(); + AIdentifierVarExpCG id = new AIdentifierVarExpCG(); id.setName(name); + id.setType(field.getType().clone()); + id.setIsLambda(false); + id.setIsLocal(true); AIdentifierVarExpCG varExp = new AIdentifierVarExpCG(); varExp.setType(field.getType().clone()); From 0a12488c4ff9365f6ef0606c3d961006e858cbe0 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Mon, 2 Mar 2015 13:22:17 +0100 Subject: [PATCH 191/323] The 'JavaValueSemantics' class now takes the assign-to-exp statement into account --- .../codegen/vdm2java/JavaValueSemantics.java | 28 ++++++++++++++++++- 1 file changed, 27 insertions(+), 1 deletion(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaValueSemantics.java b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaValueSemantics.java index 4cd22e329e..350235ea6e 100644 --- a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaValueSemantics.java +++ b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaValueSemantics.java @@ -102,6 +102,11 @@ public boolean cloneMember(AFieldNumberExpCG exp) return false; } + if(cloneNotNeededAssign(exp)) + { + return false; + } + STypeCG type = exp.getTuple().getType(); if (type instanceof ATupleTypeCG) @@ -119,7 +124,7 @@ public boolean cloneMember(AFieldNumberExpCG exp) return false; } - + public boolean cloneMember(AFieldExpCG exp) { if (javaSettings.getDisableCloning()) @@ -137,6 +142,11 @@ public boolean cloneMember(AFieldExpCG exp) { return false; } + + if(cloneNotNeededAssign(exp)) + { + return false; + } STypeCG type = exp.getObject().getType(); @@ -353,4 +363,20 @@ private boolean usesStructuralEquivalence(STypeCG type) || type instanceof SSeqTypeCG || type instanceof SSetTypeCG || type instanceof SMapTypeCG; } + + private boolean cloneNotNeededAssign(SExpCG exp) + { + INode parent = exp.parent(); + + if (parent instanceof AAssignToExpStmCG) + { + AAssignToExpStmCG assignment = (AAssignToExpStmCG) parent; + if (assignment.getTarget() == exp) + { + return true; + } + } + + return false; + } } From c812fab822500f3f06e2169f120bd021231e0791 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Mon, 2 Mar 2015 13:28:27 +0100 Subject: [PATCH 192/323] Removed state designators from the Java backend. Due to the introduction of the assignment statement transformation and the removel of additional costruction of the assignment statement + state designators the templates for state designators are not needed anymore. --- .../overture/codegen/vdm2java/JavaFormat.java | 31 ------------------- .../JavaTemplates/StateDesignator/Field.vm | 1 - .../StateDesignator/Identifier.vm | 7 ----- .../JavaTemplates/StateDesignator/MapSeq.vm | 1 - 4 files changed, 40 deletions(-) delete mode 100644 core/codegen/src/main/resources/JavaTemplates/StateDesignator/Field.vm delete mode 100644 core/codegen/src/main/resources/JavaTemplates/StateDesignator/Identifier.vm delete mode 100644 core/codegen/src/main/resources/JavaTemplates/StateDesignator/MapSeq.vm diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaFormat.java b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaFormat.java index 589ffeef72..5b1457800c 100644 --- a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaFormat.java +++ b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaFormat.java @@ -292,37 +292,6 @@ public static boolean isMapSeq(SStateDesignatorCG stateDesignator) return stateDesignator instanceof AMapSeqStateDesignatorCG; } - public String formatMapSeqStateDesignator(AMapSeqStateDesignatorCG mapSeq) - throws AnalysisException - { - INode parent = mapSeq.parent(); - - SStateDesignatorCG stateDesignator = mapSeq.getMapseq(); - SExpCG domValue = mapSeq.getExp(); - - String stateDesignatorStr = format(stateDesignator); - String domValStr = format(domValue); - - if (parent instanceof AAssignmentStmCG) - { - AAssignmentStmCG assignment = (AAssignmentStmCG) parent; - SExpCG rngValue = assignment.getExp(); - String rngValStr = format(rngValue); - - // e.g. counters.put("c1", 4); - return stateDesignatorStr + ".put(" + domValStr + ", " + rngValStr - + ")"; - } else - { - STypeCG type = mapSeq.getType(); - String typeStr = format(type); - - // e.g. ((Rec) m(true)).field := 2; - return "( (" + typeStr + ")" + format(mapSeq.getMapseq()) + ".get(" - + domValStr + "))"; - } - } - private String getNumberDereference(INode node, boolean ignoreContext) { if (ignoreContext && node instanceof SExpCG) diff --git a/core/codegen/src/main/resources/JavaTemplates/StateDesignator/Field.vm b/core/codegen/src/main/resources/JavaTemplates/StateDesignator/Field.vm deleted file mode 100644 index dc7b1337dc..0000000000 --- a/core/codegen/src/main/resources/JavaTemplates/StateDesignator/Field.vm +++ /dev/null @@ -1 +0,0 @@ -$JavaFormat.format($node.getObject()).$node.getField() \ No newline at end of file diff --git a/core/codegen/src/main/resources/JavaTemplates/StateDesignator/Identifier.vm b/core/codegen/src/main/resources/JavaTemplates/StateDesignator/Identifier.vm deleted file mode 100644 index 481d093092..0000000000 --- a/core/codegen/src/main/resources/JavaTemplates/StateDesignator/Identifier.vm +++ /dev/null @@ -1,7 +0,0 @@ -#set( $prefix = "" ) -## -#if ( $node.getExplicit() ) - #set( $prefix = "${node.getClassName()}.") -#end -## -${prefix}${node.getName()} \ No newline at end of file diff --git a/core/codegen/src/main/resources/JavaTemplates/StateDesignator/MapSeq.vm b/core/codegen/src/main/resources/JavaTemplates/StateDesignator/MapSeq.vm deleted file mode 100644 index 9fc32036e3..0000000000 --- a/core/codegen/src/main/resources/JavaTemplates/StateDesignator/MapSeq.vm +++ /dev/null @@ -1 +0,0 @@ -$JavaFormat.formatMapSeqStateDesignator($node) \ No newline at end of file From 23263bd7a1c372d304553bb8959ce519d3672a6a Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Mon, 2 Mar 2015 15:15:36 +0100 Subject: [PATCH 193/323] Cleaning up the history expression template and some imports --- .../java/org/overture/codegen/merging/TemplateManager.java | 2 +- .../main/java/org/overture/codegen/vdm2java/JavaFormat.java | 1 - .../main/resources/JavaTemplates/Expressions/HistoryExp.vm | 5 +++++ .../main/resources/JavaTemplates/Expressions/hisCounter.vm | 6 ------ 4 files changed, 6 insertions(+), 8 deletions(-) create mode 100644 core/codegen/src/main/resources/JavaTemplates/Expressions/HistoryExp.vm delete mode 100644 core/codegen/src/main/resources/JavaTemplates/Expressions/hisCounter.vm diff --git a/core/codegen/src/main/java/org/overture/codegen/merging/TemplateManager.java b/core/codegen/src/main/java/org/overture/codegen/merging/TemplateManager.java index 6903703fc3..f6025e86bc 100644 --- a/core/codegen/src/main/java/org/overture/codegen/merging/TemplateManager.java +++ b/core/codegen/src/main/java/org/overture/codegen/merging/TemplateManager.java @@ -430,7 +430,7 @@ protected void initNodeTemplateFileNames() + "SubSeq"); nodeTemplateFileNames.put(AHistoryExpCG.class, templateStructure.EXP_PATH - + "hisCounter"); + + "HistoryExp"); nodeTemplateFileNames.put(AMapGetExpCG.class, templateStructure.EXP_PATH + "MapGet"); diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaFormat.java b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaFormat.java index 5b1457800c..b76ce05112 100644 --- a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaFormat.java +++ b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaFormat.java @@ -68,7 +68,6 @@ import org.overture.codegen.cgast.expressions.SUnaryExpCG; import org.overture.codegen.cgast.expressions.SVarExpCG; import org.overture.codegen.cgast.name.ATypeNameCG; -import org.overture.codegen.cgast.statements.AAssignmentStmCG; import org.overture.codegen.cgast.statements.ABlockStmCG; import org.overture.codegen.cgast.statements.AForLoopStmCG; import org.overture.codegen.cgast.statements.AMapSeqStateDesignatorCG; diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/HistoryExp.vm b/core/codegen/src/main/resources/JavaTemplates/Expressions/HistoryExp.vm new file mode 100644 index 0000000000..2d1731656e --- /dev/null +++ b/core/codegen/src/main/resources/JavaTemplates/Expressions/HistoryExp.vm @@ -0,0 +1,5 @@ +#set( $counterType = $node.getHistype() ) +#set( $innerClass = $JavaFormat.format($node.getSentinelType()) ) +#set( $opName = $node.getOpsname() ) +## +sentinel.${counterType}[(( ${innerClass} )sentinel).${opName}] \ No newline at end of file diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/hisCounter.vm b/core/codegen/src/main/resources/JavaTemplates/Expressions/hisCounter.vm deleted file mode 100644 index 2ab32a2723..0000000000 --- a/core/codegen/src/main/resources/JavaTemplates/Expressions/hisCounter.vm +++ /dev/null @@ -1,6 +0,0 @@ -#set( $countertype = $node.getHistype() ) -#set( $innerclass = $JavaFormat.format($node.getSentinelType()) ) -#set( $opname = $node.getOpsname() ) -## -sentinel.${countertype}[((${innerclass})sentinel).${opname}] -##hello \ No newline at end of file From 71341ce136408b839b2b87158a8181c98b5acab6 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Mon, 2 Mar 2015 21:54:29 +0100 Subject: [PATCH 194/323] Fix for the functionality that determines whether an identifier state designator is local or not The approach now uses a visitor that does not rely on previous assumptions --- .../codegen/assistant/DeclAssistantCG.java | 38 +----- .../codegen/assistant/ExpAssistantCG.java | 2 +- .../codegen/assistant/IsLocalAnalysis.java | 112 ++++++++++++++++++ 3 files changed, 116 insertions(+), 36 deletions(-) create mode 100644 core/codegen/src/main/java/org/overture/codegen/assistant/IsLocalAnalysis.java diff --git a/core/codegen/src/main/java/org/overture/codegen/assistant/DeclAssistantCG.java b/core/codegen/src/main/java/org/overture/codegen/assistant/DeclAssistantCG.java index 10b74d645a..df646cdf9a 100644 --- a/core/codegen/src/main/java/org/overture/codegen/assistant/DeclAssistantCG.java +++ b/core/codegen/src/main/java/org/overture/codegen/assistant/DeclAssistantCG.java @@ -67,7 +67,6 @@ import org.overture.codegen.ir.IRConstants; import org.overture.codegen.ir.IRInfo; import org.overture.codegen.ir.SourceNode; -import org.overture.codegen.logging.Logger; import org.overture.codegen.utils.LexNameTokenWrapper; public class DeclAssistantCG extends AssistantBase @@ -579,40 +578,9 @@ public List consFormalParams( return paramsCg; } - /** - * Checks if an identifier state designator represents a local variable. - * Please note that variable hiding and shadowing is assumed to be removed - * from the model. - * - * @param node the identifier - * @param classes all classes in the model - * @return true if the identifier represents a local variable - false otherwise - */ - public boolean isLocal(AIdentifierStateDesignatorCG node, List classes) + public boolean isLocal(AIdentifierStateDesignatorCG node) { - AClassDeclCG encClass = node.getAncestor(AClassDeclCG.class); - - if(encClass == null) - { - Logger.getLog().printErrorln("Could not find enclosing class of " + node + - " in '" + this.getClass().getName() + "'"); - return false; - } - - String fieldName = node.getName(); - - List encClassFields = getAllFields(encClass, classes); - - for(AFieldDeclCG field : encClassFields) - { - if(field.getName().equals(fieldName)) - { - // So it must be a global identifier - return false; - } - } - - // If we could not find a field with this name then it must be local - return true; + IsLocalAnalysis an = new IsLocalAnalysis(node); + return an.isLocal(); } } diff --git a/core/codegen/src/main/java/org/overture/codegen/assistant/ExpAssistantCG.java b/core/codegen/src/main/java/org/overture/codegen/assistant/ExpAssistantCG.java index e449f87101..fe04a41f64 100644 --- a/core/codegen/src/main/java/org/overture/codegen/assistant/ExpAssistantCG.java +++ b/core/codegen/src/main/java/org/overture/codegen/assistant/ExpAssistantCG.java @@ -564,7 +564,7 @@ public SExpCG consIsExpBasicType(SExpCG expCg, STypeCG checkedType) public SExpCG idStateDesignatorToExp(IRInfo info, TransAssistantCG transAssistant, List classes, AIdentifierStateDesignatorCG node) { - boolean isLocal = info.getDeclAssistant().isLocal(node, classes); + boolean isLocal = info.getDeclAssistant().isLocal(node); if(node.getExplicit()) { diff --git a/core/codegen/src/main/java/org/overture/codegen/assistant/IsLocalAnalysis.java b/core/codegen/src/main/java/org/overture/codegen/assistant/IsLocalAnalysis.java new file mode 100644 index 0000000000..774ee88552 --- /dev/null +++ b/core/codegen/src/main/java/org/overture/codegen/assistant/IsLocalAnalysis.java @@ -0,0 +1,112 @@ +package org.overture.codegen.assistant; + +import java.util.LinkedList; +import java.util.List; + +import org.overture.codegen.cgast.SPatternCG; +import org.overture.codegen.cgast.SStmCG; +import org.overture.codegen.cgast.analysis.DepthFirstAnalysisAdaptor; +import org.overture.codegen.cgast.declarations.AClassDeclCG; +import org.overture.codegen.cgast.declarations.AMethodDeclCG; +import org.overture.codegen.cgast.declarations.AVarDeclCG; +import org.overture.codegen.cgast.patterns.AIdentifierPatternCG; +import org.overture.codegen.cgast.statements.ABlockStmCG; +import org.overture.codegen.cgast.statements.AIdentifierStateDesignatorCG; +import org.overture.codegen.logging.Logger; + +public class IsLocalAnalysis extends DepthFirstAnalysisAdaptor +{ + private AIdentifierStateDesignatorCG id; + private List names; + private boolean isLocal; + + public IsLocalAnalysis(AIdentifierStateDesignatorCG id) + { + this.id = id; + this.names = new LinkedList(); + this.isLocal = false; + } + + public boolean isLocal() + { + AClassDeclCG encClass = id.getAncestor(AClassDeclCG.class); + + if(encClass == null) + { + Logger.getLog().printErrorln("Could not find enclosing class for " + + "node " + id + " in '" + this.getClass().getSimpleName() + "'"); + return false; + } + else + { + try + { + encClass.apply(this); + } catch (org.overture.codegen.cgast.analysis.AnalysisException e) + { + // Exceptions are used to terminate the analysis + } + } + + return isLocal; + } + + @Override + public void caseAClassDeclCG(AClassDeclCG node) + throws org.overture.codegen.cgast.analysis.AnalysisException + { + // Only check the methods of the enclosing class + for(AMethodDeclCG method : node.getMethods()) + { + method.apply(this); + } + + if(node.getThread() != null) + { + node.getThread().apply(this); + } + } + + + @Override + public void caseABlockStmCG(ABlockStmCG node) + throws org.overture.codegen.cgast.analysis.AnalysisException + { + int adds = 0; + for(AVarDeclCG d : node.getLocalDefs()) + { + SPatternCG pattern = d.getPattern(); + if(pattern instanceof AIdentifierPatternCG) + { + AIdentifierPatternCG idPattern = (AIdentifierPatternCG) pattern; + names.add(idPattern.getName()); + adds++; + } + } + + for(SStmCG stm : node.getStatements()) + { + stm.apply(this); + } + + + for(int i = 0; i < adds; i++) + { + names.remove(names.size() - 1); + } + } + + @Override + public void caseAIdentifierStateDesignatorCG( + AIdentifierStateDesignatorCG node) + throws org.overture.codegen.cgast.analysis.AnalysisException + { + if(node == id) + { + // If the name of the identifier state designator is in the list of local names + // then it must be local + isLocal = names.contains(node.getName()); + throw new org.overture.codegen.cgast.analysis.AnalysisException("Stop analysis"); + } + } +} \ No newline at end of file From 411e47cc3c54262518bd00a42a1760c21d0e248f Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Tue, 3 Mar 2015 00:41:44 +0100 Subject: [PATCH 195/323] Removed an IR analysis that is not needed anymore --- .../codegen/assistant/IsLocalAnalysis.java | 112 ------------------ 1 file changed, 112 deletions(-) delete mode 100644 core/codegen/src/main/java/org/overture/codegen/assistant/IsLocalAnalysis.java diff --git a/core/codegen/src/main/java/org/overture/codegen/assistant/IsLocalAnalysis.java b/core/codegen/src/main/java/org/overture/codegen/assistant/IsLocalAnalysis.java deleted file mode 100644 index 774ee88552..0000000000 --- a/core/codegen/src/main/java/org/overture/codegen/assistant/IsLocalAnalysis.java +++ /dev/null @@ -1,112 +0,0 @@ -package org.overture.codegen.assistant; - -import java.util.LinkedList; -import java.util.List; - -import org.overture.codegen.cgast.SPatternCG; -import org.overture.codegen.cgast.SStmCG; -import org.overture.codegen.cgast.analysis.DepthFirstAnalysisAdaptor; -import org.overture.codegen.cgast.declarations.AClassDeclCG; -import org.overture.codegen.cgast.declarations.AMethodDeclCG; -import org.overture.codegen.cgast.declarations.AVarDeclCG; -import org.overture.codegen.cgast.patterns.AIdentifierPatternCG; -import org.overture.codegen.cgast.statements.ABlockStmCG; -import org.overture.codegen.cgast.statements.AIdentifierStateDesignatorCG; -import org.overture.codegen.logging.Logger; - -public class IsLocalAnalysis extends DepthFirstAnalysisAdaptor -{ - private AIdentifierStateDesignatorCG id; - private List names; - private boolean isLocal; - - public IsLocalAnalysis(AIdentifierStateDesignatorCG id) - { - this.id = id; - this.names = new LinkedList(); - this.isLocal = false; - } - - public boolean isLocal() - { - AClassDeclCG encClass = id.getAncestor(AClassDeclCG.class); - - if(encClass == null) - { - Logger.getLog().printErrorln("Could not find enclosing class for " - + "node " + id + " in '" + this.getClass().getSimpleName() + "'"); - return false; - } - else - { - try - { - encClass.apply(this); - } catch (org.overture.codegen.cgast.analysis.AnalysisException e) - { - // Exceptions are used to terminate the analysis - } - } - - return isLocal; - } - - @Override - public void caseAClassDeclCG(AClassDeclCG node) - throws org.overture.codegen.cgast.analysis.AnalysisException - { - // Only check the methods of the enclosing class - for(AMethodDeclCG method : node.getMethods()) - { - method.apply(this); - } - - if(node.getThread() != null) - { - node.getThread().apply(this); - } - } - - - @Override - public void caseABlockStmCG(ABlockStmCG node) - throws org.overture.codegen.cgast.analysis.AnalysisException - { - int adds = 0; - for(AVarDeclCG d : node.getLocalDefs()) - { - SPatternCG pattern = d.getPattern(); - if(pattern instanceof AIdentifierPatternCG) - { - AIdentifierPatternCG idPattern = (AIdentifierPatternCG) pattern; - names.add(idPattern.getName()); - adds++; - } - } - - for(SStmCG stm : node.getStatements()) - { - stm.apply(this); - } - - - for(int i = 0; i < adds; i++) - { - names.remove(names.size() - 1); - } - } - - @Override - public void caseAIdentifierStateDesignatorCG( - AIdentifierStateDesignatorCG node) - throws org.overture.codegen.cgast.analysis.AnalysisException - { - if(node == id) - { - // If the name of the identifier state designator is in the list of local names - // then it must be local - isLocal = names.contains(node.getName()); - throw new org.overture.codegen.cgast.analysis.AnalysisException("Stop analysis"); - } - } -} \ No newline at end of file From 6a899c034e2890187ca508cb0c9292df573d0ea3 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Tue, 3 Mar 2015 00:44:34 +0100 Subject: [PATCH 196/323] Refactoring of generic VDM analysis functionality into a base class visitor Also, there is a fix for the proceed operation. The parent is now set as a last thing during the iteration. --- .../analysis/vdm/IdOccurencesCollector.java | 27 +------------ .../codegen/analysis/vdm/VdmAnalysis.java | 38 +++++++++++++++++++ 2 files changed, 40 insertions(+), 25 deletions(-) create mode 100644 core/codegen/src/main/java/org/overture/codegen/analysis/vdm/VdmAnalysis.java diff --git a/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/IdOccurencesCollector.java b/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/IdOccurencesCollector.java index 9a0af73b85..a710611e19 100644 --- a/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/IdOccurencesCollector.java +++ b/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/IdOccurencesCollector.java @@ -4,21 +4,19 @@ import java.util.Set; import org.overture.ast.analysis.AnalysisException; -import org.overture.ast.analysis.DepthFirstAnalysisAdaptor; import org.overture.ast.intf.lex.ILexNameToken; import org.overture.ast.node.INode; import org.overture.ast.patterns.AIdentifierPattern; -public class IdOccurencesCollector extends DepthFirstAnalysisAdaptor +public class IdOccurencesCollector extends VdmAnalysis { private ILexNameToken name; - private INode topNode; private Set idOccurences; public IdOccurencesCollector(ILexNameToken name, INode topNode) { + super(topNode); this.name = name; - this.topNode = topNode; this.idOccurences = new HashSet(); } @@ -39,25 +37,4 @@ public void caseAIdentifierPattern(AIdentifierPattern node) } } } - - private boolean proceed(INode node) - { - if (node == topNode) - { - return true; - } - - INode parent = node.parent(); - - Set visited = new HashSet(); - - while (parent != null && !visited.contains(parent) - && this.topNode != parent) - { - parent = parent.parent(); - visited.add(parent); - } - - return this.topNode == parent; - } } diff --git a/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/VdmAnalysis.java b/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/VdmAnalysis.java new file mode 100644 index 0000000000..9ee38bd790 --- /dev/null +++ b/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/VdmAnalysis.java @@ -0,0 +1,38 @@ +package org.overture.codegen.analysis.vdm; + +import java.util.HashSet; +import java.util.Set; + +import org.overture.ast.analysis.DepthFirstAnalysisAdaptor; +import org.overture.ast.node.INode; + +public abstract class VdmAnalysis extends DepthFirstAnalysisAdaptor +{ + protected INode topNode; + + public VdmAnalysis(INode topNode) + { + this.topNode = topNode; + } + + protected boolean proceed(INode node) + { + if (node == topNode) + { + return true; + } + + INode parent = node.parent(); + + Set visited = new HashSet(); + + while (parent != null && !visited.contains(parent) + && this.topNode != parent) + { + visited.add(parent); + parent = parent.parent(); + } + + return this.topNode == parent; + } +} \ No newline at end of file From 6f61786712f2689008b84b92977a5419c715ca53 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Tue, 3 Mar 2015 00:48:53 +0100 Subject: [PATCH 197/323] Added functionality to determine if an identifier state designator is local or not. --- .../vdm/IdStateDesignatorDefCollector.java | 155 ++++++++++++++++++ .../codegen/assistant/DeclAssistantCG.java | 20 ++- .../codegen/assistant/ExpAssistantCG.java | 6 +- .../java/org/overture/codegen/ir/IRInfo.java | 17 ++ .../codegen/vdm2java/JavaCodeGen.java | 22 +++ .../visitor/StateDesignatorVisitorCG.java | 4 +- core/codegen/src/main/resources/cg.astv2 | 2 +- 7 files changed, 216 insertions(+), 10 deletions(-) create mode 100644 core/codegen/src/main/java/org/overture/codegen/analysis/vdm/IdStateDesignatorDefCollector.java diff --git a/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/IdStateDesignatorDefCollector.java b/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/IdStateDesignatorDefCollector.java new file mode 100644 index 0000000000..33519653fe --- /dev/null +++ b/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/IdStateDesignatorDefCollector.java @@ -0,0 +1,155 @@ +package org.overture.codegen.analysis.vdm; + +import java.util.HashMap; +import java.util.HashSet; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import org.overture.ast.analysis.AnalysisException; +import org.overture.ast.definitions.AAssignmentDefinition; +import org.overture.ast.definitions.AClassClassDefinition; +import org.overture.ast.definitions.AExplicitOperationDefinition; +import org.overture.ast.definitions.AInheritedDefinition; +import org.overture.ast.definitions.AInstanceVariableDefinition; +import org.overture.ast.definitions.AThreadDefinition; +import org.overture.ast.definitions.AValueDefinition; +import org.overture.ast.definitions.PDefinition; +import org.overture.ast.definitions.SClassDefinition; +import org.overture.ast.node.INode; +import org.overture.ast.statements.ABlockSimpleBlockStm; +import org.overture.ast.statements.AIdentifierStateDesignator; +import org.overture.ast.statements.PStm; + +/** + * Computes the definitions of identifier state designators + * + * @author pvj + * + */ +public class IdStateDesignatorDefCollector extends VdmAnalysis +{ + private List defsInScope; + private Map idDefs; + private Set visited; + + public IdStateDesignatorDefCollector(INode topNode) + { + super(topNode); + this.defsInScope = new LinkedList(); + this.idDefs = new HashMap<>(); + this.visited = new HashSet<>(); + } + + public static Map getIdDefs(List classes) throws AnalysisException + { + Map allDefs = new HashMap<>(); + + for(SClassDefinition clazz : classes) + { + IdStateDesignatorDefCollector collector = new IdStateDesignatorDefCollector(clazz); + clazz.apply(collector); + allDefs.putAll(collector.idDefs); + } + + return allDefs; + } + + @Override + public void caseAClassClassDefinition(AClassClassDefinition node) + throws AnalysisException + { + if(!proceed(node)) + { + return; + } + + // Instance variables and values are visible to all operations + for(int i = 0; i < node.getDefinitions().size(); i++) + { + PDefinition def = node.getDefinitions().get(i); + + while(def instanceof AInheritedDefinition) + { + def = ((AInheritedDefinition) def).getSuperdef(); + } + + if(def instanceof AInstanceVariableDefinition || def instanceof AValueDefinition) + { + defsInScope.add(def); + } + } + + for(PDefinition def : node.getDefinitions()) + { + // Check only explicit operations or threads within the enclosing class + if(def instanceof AExplicitOperationDefinition || def instanceof AThreadDefinition) + { + def.apply(this); + } + } + } + + @Override + public void caseABlockSimpleBlockStm(ABlockSimpleBlockStm node) + throws AnalysisException + { + if(!proceed(node)) + { + return; + } + + int adds = 0; + for(AAssignmentDefinition d : node.getAssignmentDefs()) + { + defsInScope.add(d); + adds++; + } + + for(PStm stm : node.getStatements()) + { + stm.apply(this); + } + + for(int i = 0; i < adds; i++) + { + defsInScope.remove(defsInScope.size() - 1); + } + } + + @Override + public void caseAIdentifierStateDesignator(AIdentifierStateDesignator node) + throws AnalysisException + { + if(!proceed(node)) + { + return; + } + + for(int i = defsInScope.size() - 1; i >= 0; i--) + { + PDefinition nextDef = defsInScope.get(i); + + if(node.getName().equals(nextDef.getName())) + { + this.idDefs.put(node, nextDef); + break; + } + } + } + + @Override + protected boolean proceed(INode node) + { + if(visited.contains(node)) + { + return false; + } + else + { + visited.add(node); + return super.proceed(node); + } + } +} diff --git a/core/codegen/src/main/java/org/overture/codegen/assistant/DeclAssistantCG.java b/core/codegen/src/main/java/org/overture/codegen/assistant/DeclAssistantCG.java index df646cdf9a..396497debe 100644 --- a/core/codegen/src/main/java/org/overture/codegen/assistant/DeclAssistantCG.java +++ b/core/codegen/src/main/java/org/overture/codegen/assistant/DeclAssistantCG.java @@ -27,6 +27,7 @@ import java.util.Set; import org.overture.ast.analysis.AnalysisException; +import org.overture.ast.definitions.AAssignmentDefinition; import org.overture.ast.definitions.AClassClassDefinition; import org.overture.ast.definitions.AEqualsDefinition; import org.overture.ast.definitions.AExplicitFunctionDefinition; @@ -39,6 +40,7 @@ import org.overture.ast.node.INode; import org.overture.ast.patterns.APatternListTypePair; import org.overture.ast.patterns.PPattern; +import org.overture.ast.statements.AIdentifierStateDesignator; import org.overture.ast.statements.ASubclassResponsibilityStm; import org.overture.codegen.cgast.SDeclCG; import org.overture.codegen.cgast.SExpCG; @@ -54,7 +56,6 @@ import org.overture.codegen.cgast.declarations.AVarDeclCG; import org.overture.codegen.cgast.expressions.ANullExpCG; import org.overture.codegen.cgast.name.ATypeNameCG; -import org.overture.codegen.cgast.statements.AIdentifierStateDesignatorCG; import org.overture.codegen.cgast.types.ABoolBasicTypeCG; import org.overture.codegen.cgast.types.ACharBasicTypeCG; import org.overture.codegen.cgast.types.AIntNumericBasicTypeCG; @@ -67,6 +68,7 @@ import org.overture.codegen.ir.IRConstants; import org.overture.codegen.ir.IRInfo; import org.overture.codegen.ir.SourceNode; +import org.overture.codegen.logging.Logger; import org.overture.codegen.utils.LexNameTokenWrapper; public class DeclAssistantCG extends AssistantBase @@ -578,9 +580,19 @@ public List consFormalParams( return paramsCg; } - public boolean isLocal(AIdentifierStateDesignatorCG node) + public boolean isLocal(AIdentifierStateDesignator id, IRInfo info) { - IsLocalAnalysis an = new IsLocalAnalysis(node); - return an.isLocal(); + PDefinition idDef = info.getIdStateDesignatorDefs().get(id); + + if(idDef == null) + { + Logger.getLog().printErrorln("Could not find definition for identifier " + + "state designator " + id + " in '" + this.getClass().getSimpleName() + "'"); + return false; + } + else + { + return idDef instanceof AAssignmentDefinition; + } } } diff --git a/core/codegen/src/main/java/org/overture/codegen/assistant/ExpAssistantCG.java b/core/codegen/src/main/java/org/overture/codegen/assistant/ExpAssistantCG.java index fe04a41f64..81172c696a 100644 --- a/core/codegen/src/main/java/org/overture/codegen/assistant/ExpAssistantCG.java +++ b/core/codegen/src/main/java/org/overture/codegen/assistant/ExpAssistantCG.java @@ -564,8 +564,6 @@ public SExpCG consIsExpBasicType(SExpCG expCg, STypeCG checkedType) public SExpCG idStateDesignatorToExp(IRInfo info, TransAssistantCG transAssistant, List classes, AIdentifierStateDesignatorCG node) { - boolean isLocal = info.getDeclAssistant().isLocal(node); - if(node.getExplicit()) { AClassTypeCG classType = new AClassTypeCG(); @@ -574,7 +572,7 @@ public SExpCG idStateDesignatorToExp(IRInfo info, TransAssistantCG transAssistan AExplicitVarExpCG explicitVar = new AExplicitVarExpCG(); explicitVar.setClassType(classType); explicitVar.setIsLambda(false); - explicitVar.setIsLocal(isLocal); + explicitVar.setIsLocal(node.getIsLocal()); explicitVar.setName(node.getName()); explicitVar.setSourceNode(node.getSourceNode()); explicitVar.setTag(node.getTag()); @@ -587,7 +585,7 @@ public SExpCG idStateDesignatorToExp(IRInfo info, TransAssistantCG transAssistan AIdentifierVarExpCG idVar = transAssistant.consIdentifierVar(node.getName(), node.getType().clone()); idVar.setTag(node.getTag()); idVar.setSourceNode(node.getSourceNode()); - idVar.setIsLocal(isLocal); + idVar.setIsLocal(node.getIsLocal()); return idVar; } diff --git a/core/codegen/src/main/java/org/overture/codegen/ir/IRInfo.java b/core/codegen/src/main/java/org/overture/codegen/ir/IRInfo.java index e9c4955102..7c91789d94 100644 --- a/core/codegen/src/main/java/org/overture/codegen/ir/IRInfo.java +++ b/core/codegen/src/main/java/org/overture/codegen/ir/IRInfo.java @@ -29,8 +29,10 @@ import java.util.Set; import org.overture.ast.definitions.AExplicitOperationDefinition; +import org.overture.ast.definitions.PDefinition; import org.overture.ast.definitions.SClassDefinition; import org.overture.ast.node.INode; +import org.overture.ast.statements.AIdentifierStateDesignator; import org.overture.codegen.assistant.AssistantManager; import org.overture.codegen.assistant.BindAssistantCG; import org.overture.codegen.assistant.DeclAssistantCG; @@ -89,6 +91,9 @@ public class IRInfo // Object initialization call prefix private String objectInitCallPrefix; + // Definitions for identifier state designators + private Map idStateDesignatorDefs; + public IRInfo(String objectInitCallPrefix) { super(); @@ -105,6 +110,8 @@ public IRInfo(String objectInitCallPrefix) this.objectInitCallPrefix = objectInitCallPrefix; this.objectInitCallNames = new HashMap(); + + this.idStateDesignatorDefs = new HashMap(); } public AssistantManager getAssistantManager() @@ -312,4 +319,14 @@ public String getObjectInitializerCall(AExplicitOperationDefinition vdmOp) return initName; } } + + public Map getIdStateDesignatorDefs() + { + return idStateDesignatorDefs; + } + + public void setIdStateDesignatorDefs(Map idDefs) + { + this.idStateDesignatorDefs = idDefs; + } } diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java index 7a3f7447c9..806b069224 100644 --- a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java +++ b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java @@ -27,6 +27,7 @@ import java.util.HashSet; import java.util.LinkedList; import java.util.List; +import java.util.Map; import java.util.Set; import org.apache.velocity.app.Velocity; @@ -38,7 +39,9 @@ import org.overture.ast.expressions.ANotYetSpecifiedExp; import org.overture.ast.expressions.PExp; import org.overture.ast.node.INode; +import org.overture.ast.statements.AIdentifierStateDesignator; import org.overture.ast.statements.ANotYetSpecifiedStm; +import org.overture.codegen.analysis.vdm.IdStateDesignatorDefCollector; import org.overture.codegen.analysis.vdm.Renaming; import org.overture.codegen.analysis.vdm.UnreachableStmRemover; import org.overture.codegen.analysis.vdm.VarShadowingRenameCollector; @@ -207,6 +210,8 @@ public GeneratedData generateJavaFromVdm( mergedParseLists.add(mainClass); } + computeDefTable(mergedParseLists); + // To document any renaming of variables shadowing other variables removeUnreachableStms(mergedParseLists); List allRenamings = performRenaming(mergedParseLists); @@ -354,6 +359,23 @@ else if(mergeVisitor.hasUnsupportedTargLangNodes()) return new GeneratedData(generated, generateJavaFromVdmQuotes(), invalidNamesResult, skipping, allRenamings); } + private void computeDefTable(List mergedParseLists) + throws AnalysisException + { + List classesToConsider = new LinkedList<>(); + + for(SClassDefinition c : mergedParseLists) + { + if(!getInfo().getDeclAssistant().classIsLibrary(c)) + { + classesToConsider.add(c); + } + } + + Map idDefs = IdStateDesignatorDefCollector.getIdDefs(classesToConsider); + getInfo().setIdStateDesignatorDefs(idDefs); + } + private void removeUnreachableStms(List mergedParseLists) throws AnalysisException { UnreachableStmRemover remover = new UnreachableStmRemover(); diff --git a/core/codegen/src/main/java/org/overture/codegen/visitor/StateDesignatorVisitorCG.java b/core/codegen/src/main/java/org/overture/codegen/visitor/StateDesignatorVisitorCG.java index f0e0a53d4c..d8980ccf02 100644 --- a/core/codegen/src/main/java/org/overture/codegen/visitor/StateDesignatorVisitorCG.java +++ b/core/codegen/src/main/java/org/overture/codegen/visitor/StateDesignatorVisitorCG.java @@ -68,7 +68,8 @@ public SStateDesignatorCG caseAIdentifierStateDesignator( String name = node.getName().getName(); String className = node.getName().getModule(); boolean explicit = node.getName().getExplicit(); - + boolean isLocal = question.getDeclAssistant().isLocal(node, question); + STypeCG typeCg = type.apply(question.getTypeVisitor(), question); AIdentifierStateDesignatorCG idStateDesignatorCg = new AIdentifierStateDesignatorCG(); @@ -76,6 +77,7 @@ public SStateDesignatorCG caseAIdentifierStateDesignator( idStateDesignatorCg.setName(name); idStateDesignatorCg.setClassName(className); idStateDesignatorCg.setExplicit(explicit); + idStateDesignatorCg.setIsLocal(isLocal); return idStateDesignatorCg; } diff --git a/core/codegen/src/main/resources/cg.astv2 b/core/codegen/src/main/resources/cg.astv2 index 5babdf490a..ae5e51a68c 100644 --- a/core/codegen/src/main/resources/cg.astv2 +++ b/core/codegen/src/main/resources/cg.astv2 @@ -172,7 +172,7 @@ CG {-> package='org.overture.codegen.cgast' #stateDesignator {-> package='org.overture.codegen.cgast.statements' | [type]:CG.#type } - = {identifier} [name]:java_String [explicit]:java_Boolean [className]:java_String + = {identifier} [name]:java_String [explicit]:java_Boolean [className]:java_String [isLocal]:java_Boolean | {field} [object]:CG.#stateDesignator [field]:java_String | {mapSeq} [mapseq]:CG.#stateDesignator [exp]:CG.#exp ; From 5f58d167f6bdca3f47ee1f891eb2d1b5830c7128 Mon Sep 17 00:00:00 2001 From: Nick Battle Date: Tue, 3 Mar 2015 13:02:29 +0000 Subject: [PATCH 198/323] The is_ expression does not work for function types, fixes #424 --- .../interpreter/values/CompFunctionValue.java | 22 +++++++++++--- .../interpreter/values/FunctionValue.java | 29 ++++++++++++++----- 2 files changed, 40 insertions(+), 11 deletions(-) diff --git a/core/interpreter/src/main/java/org/overture/interpreter/values/CompFunctionValue.java b/core/interpreter/src/main/java/org/overture/interpreter/values/CompFunctionValue.java index 09e5e25032..51bae3be3c 100644 --- a/core/interpreter/src/main/java/org/overture/interpreter/values/CompFunctionValue.java +++ b/core/interpreter/src/main/java/org/overture/interpreter/values/CompFunctionValue.java @@ -77,14 +77,28 @@ protected Value convertValueTo(PType to, Context ctxt, Set done) else { AFunctionType restrictedType = assistant.getFunction(to); - - if (!type.equals(restrictedType)) + + if (type.equals(restrictedType)) { - return abort(4164, "Compose function cannot be restricted to " + restrictedType, ctxt); + return this; + } + else if (ctxt.assistantFactory.getTypeComparator().isSubType(type, restrictedType)) + { + // The new function amends the parameters of ff2 and the result of ff1 + + FunctionValue leftValue = (FunctionValue)ff1.clone(); + leftValue.type = AstFactory.newAFunctionType(ff1.location, + ff1.type.getPartial(), ff1.type.getParameters(), restrictedType.getResult()); + + FunctionValue rightValue = (FunctionValue)ff2.clone(); + rightValue.type = AstFactory.newAFunctionType(ff2.location, + ff2.type.getPartial(), restrictedType.getParameters(), ff2.type.getResult()); + + return new CompFunctionValue(leftValue, rightValue); } else { - return this; + return abort(4165, "Cannot convert " + this + " to " + restrictedType, ctxt); } } } diff --git a/core/interpreter/src/main/java/org/overture/interpreter/values/FunctionValue.java b/core/interpreter/src/main/java/org/overture/interpreter/values/FunctionValue.java index 144b68789a..1b751c7a93 100644 --- a/core/interpreter/src/main/java/org/overture/interpreter/values/FunctionValue.java +++ b/core/interpreter/src/main/java/org/overture/interpreter/values/FunctionValue.java @@ -714,15 +714,30 @@ protected Value convertValueTo(PType to, Context ctxt, Set done) if (type.equals(to) || assistant.isUnknown(to)) { return this; - } else + } + else { AFunctionType restrictedType = assistant.getFunction(to); - - // Create a new function with restricted dom/rng - FunctionValue restricted = new FunctionValue(location, name, restrictedType, paramPatternList, body, precondition, postcondition, freeVariables, checkInvariants, curriedArgs, measureName, measureValues, result); - - restricted.typeValues = typeValues; - return restricted; + + if (type.equals(restrictedType)) + { + return this; + } + else if (ctxt.assistantFactory.getTypeComparator().isSubType(type, restrictedType)) + { + // Create a new function with restricted dom/rng + FunctionValue restricted = new FunctionValue(location, name, + restrictedType, paramPatternList, body, precondition, postcondition, + freeVariables, checkInvariants, curriedArgs, measureName, + measureValues, result); + + restricted.typeValues = typeValues; + return restricted; + } + else + { + return abort(4165, "Cannot convert " + this + " to " + restrictedType, ctxt); + } } } else { From 8585faee99378d9c665db064cb0c750454a49306 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Tue, 3 Mar 2015 16:29:19 +0100 Subject: [PATCH 199/323] Removed code that is not needed in the variable shadowing analyses --- .../analysis/vdm/VarOccurencesCollector.java | 20 ------------------ .../vdm/VarShadowingRenameCollector.java | 21 ++++++------------- 2 files changed, 6 insertions(+), 35 deletions(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/VarOccurencesCollector.java b/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/VarOccurencesCollector.java index 9d767f6fd4..0d91186e75 100644 --- a/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/VarOccurencesCollector.java +++ b/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/VarOccurencesCollector.java @@ -1,12 +1,10 @@ package org.overture.codegen.analysis.vdm; import java.util.HashSet; -import java.util.List; import java.util.Set; import org.overture.ast.analysis.AnalysisException; import org.overture.ast.analysis.DepthFirstAnalysisAdaptor; -import org.overture.ast.definitions.PDefinition; import org.overture.ast.expressions.AVariableExp; import org.overture.ast.intf.lex.ILexLocation; @@ -15,18 +13,11 @@ public class VarOccurencesCollector extends DepthFirstAnalysisAdaptor { private ILexLocation defLoc; private Set varOccurences; - private List defsOutsideScope; public VarOccurencesCollector(ILexLocation defLoc) - { - this(defLoc, null); - } - - public VarOccurencesCollector(ILexLocation defLoc, List defsOutsideScope) { this.defLoc = defLoc; this.varOccurences = new HashSet(); - this.defsOutsideScope = defsOutsideScope; } public Set getVars() @@ -42,17 +33,6 @@ public void caseAVariableExp(AVariableExp node) throws AnalysisException return; } - if (defsOutsideScope != null) - { - for (PDefinition d : defsOutsideScope) - { - if (d == node.getVardef()) - { - return; - } - } - } - if(node.getVardef().getLocation().equals(defLoc)) { varOccurences.add(node); diff --git a/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/VarShadowingRenameCollector.java b/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/VarShadowingRenameCollector.java index 57cc3fa975..e85a5a33e7 100644 --- a/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/VarShadowingRenameCollector.java +++ b/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/VarShadowingRenameCollector.java @@ -805,8 +805,7 @@ public void openScope(DefinitionInfo defInfo, INode defScope) { if (contains(localDef)) { - List localDefsOusideScope = defInfo.getLocalDefs(nodeDefs.subList(0, i)); - findRenamings(localDef, parentDef, defScope, localDefsOusideScope); + findRenamings(localDef, parentDef, defScope); } else { localDefsInScope.add(localDef.getName()); @@ -821,7 +820,7 @@ public void openScope(INode parentNode, List localDefs, INode defSc { if (contains(localDef)) { - findRenamings(localDef, parentNode, defScope, new LinkedList()); + findRenamings(localDef, parentNode, defScope); } else { localDefsInScope.add(localDef.getName()); @@ -839,7 +838,7 @@ public void removeLocalDefFromScope(PDefinition localDef) localDefsInScope.remove(localDef.getName()); } - private void findRenamings(PDefinition localDefToRename, INode parentNode, INode defScope, List localDefsOusideScope) + private void findRenamings(PDefinition localDefToRename, INode parentNode, INode defScope) throws AnalysisException { ILexNameToken localDefName = getName(localDefToRename); @@ -856,7 +855,7 @@ private void findRenamings(PDefinition localDefToRename, INode parentNode, INode registerRenaming(localDefName, newName); } - Set occurences = collectVarOccurences(localDefToRename.getLocation(), defScope, localDefsOusideScope); + Set occurences = collectVarOccurences(localDefToRename.getLocation(), defScope); for (AVariableExp varExp : occurences) { @@ -892,24 +891,16 @@ private boolean contains(ILexLocation loc) return false; } - private Set collectVarOccurences(ILexLocation defLoc, - INode defScope, List defsOutsideScope) + private Set collectVarOccurences(ILexLocation defLoc, INode defScope) throws AnalysisException { - VarOccurencesCollector collector = new VarOccurencesCollector(defLoc, defsOutsideScope); + VarOccurencesCollector collector = new VarOccurencesCollector(defLoc); defScope.apply(collector); return collector.getVars(); } - private Set collectVarOccurences(ILexLocation defLoc, - INode defScope) - throws AnalysisException - { - return collectVarOccurences(defLoc, defScope, null); - } - private Set collectIdOccurences(ILexNameToken name, INode parent) throws AnalysisException { IdOccurencesCollector collector = new IdOccurencesCollector(name, parent); From 133dfea6d892c9d581e68bb73a1198485af9ded7 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Tue, 3 Mar 2015 18:27:32 +0100 Subject: [PATCH 200/323] Added two tests revealing a missing case for computing renaming of variable shadowing --- .../IdStateDesignatorNestedBlocks | 27 +++++++++++++++++++ .../IdStateDesignatorSingleBlock | 13 +++++++++ 2 files changed, 40 insertions(+) create mode 100644 core/codegen/src/test/resources/var_shadowing_specs/IdStateDesignatorNestedBlocks create mode 100644 core/codegen/src/test/resources/var_shadowing_specs/IdStateDesignatorSingleBlock diff --git a/core/codegen/src/test/resources/var_shadowing_specs/IdStateDesignatorNestedBlocks b/core/codegen/src/test/resources/var_shadowing_specs/IdStateDesignatorNestedBlocks new file mode 100644 index 0000000000..0536ec5d6c --- /dev/null +++ b/core/codegen/src/test/resources/var_shadowing_specs/IdStateDesignatorNestedBlocks @@ -0,0 +1,27 @@ +class Entry + +types + +T = | | + +operations + +public Entry : () ==> Entry +Entry () == skip; + +public static Run : () ==> ? +Run () == +(dcl x : nat := 1; + dcl x : nat := x; + x := 2; + ( + dcl x : nat := x; + x := 5; + let x = x + in + skip; + return x; + ) +) + +end Entry \ No newline at end of file diff --git a/core/codegen/src/test/resources/var_shadowing_specs/IdStateDesignatorSingleBlock b/core/codegen/src/test/resources/var_shadowing_specs/IdStateDesignatorSingleBlock new file mode 100644 index 0000000000..dc97074583 --- /dev/null +++ b/core/codegen/src/test/resources/var_shadowing_specs/IdStateDesignatorSingleBlock @@ -0,0 +1,13 @@ +class Entry + +operations + +public static Run : () ==> ? +Run () == +(dcl x : nat := 1; + dcl x : nat := x; + x := 2; + return x; +) + +end Entry \ No newline at end of file From ef3b28f16345faec0cc1cbb8ec1334de3d2aead0 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Tue, 3 Mar 2015 18:29:56 +0100 Subject: [PATCH 201/323] Added an analysis to collect occurences of a definition in the form of identifier state designators --- .../vdm/IdDesignatorOccurencesCollector.java | 50 +++++++++++++++++++ 1 file changed, 50 insertions(+) create mode 100644 core/codegen/src/main/java/org/overture/codegen/analysis/vdm/IdDesignatorOccurencesCollector.java diff --git a/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/IdDesignatorOccurencesCollector.java b/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/IdDesignatorOccurencesCollector.java new file mode 100644 index 0000000000..1ba1ee659b --- /dev/null +++ b/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/IdDesignatorOccurencesCollector.java @@ -0,0 +1,50 @@ +package org.overture.codegen.analysis.vdm; + +import java.util.HashSet; +import java.util.Map; +import java.util.Set; + +import org.overture.ast.analysis.AnalysisException; +import org.overture.ast.analysis.DepthFirstAnalysisAdaptor; +import org.overture.ast.definitions.PDefinition; +import org.overture.ast.intf.lex.ILexLocation; +import org.overture.ast.statements.AIdentifierStateDesignator; +import org.overture.codegen.logging.Logger; + +public class IdDesignatorOccurencesCollector extends DepthFirstAnalysisAdaptor +{ + private ILexLocation defLoc; + private Set idOccurences; + private Map idDefs; + + public IdDesignatorOccurencesCollector(ILexLocation defLoc, Map idDefs) + { + this.defLoc = defLoc; + this.idOccurences = new HashSet(); + this.idDefs = idDefs; + } + + public Set getIds() + { + return idOccurences; + } + + @Override + public void caseAIdentifierStateDesignator( + AIdentifierStateDesignator node) throws AnalysisException + { + PDefinition def = idDefs.get(node); + + if(def == null) + { + Logger.getLog().printErrorln("Could not find definition for " + node + " in '" + this.getClass().getSimpleName() + "'"); + } + else + { + if(def.getLocation().equals(defLoc)) + { + this.idOccurences.add(node); + } + } + } +} From 96a648f73b83205e8da1db4a42b852afc8f2ff43 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Tue, 3 Mar 2015 18:46:21 +0100 Subject: [PATCH 202/323] Updated variable renaming to also use the identifier state designator collector --- .../vdm/VarShadowingRenameCollector.java | 90 ++++++++++++------- .../analysis/vdm/VarShadowingRenamer.java | 7 +- .../codegen/vdm2java/JavaCodeGen.java | 6 +- .../codegen/tests/VarShadowingTestCase.java | 8 +- 4 files changed, 71 insertions(+), 40 deletions(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/VarShadowingRenameCollector.java b/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/VarShadowingRenameCollector.java index e85a5a33e7..b752e1ea96 100644 --- a/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/VarShadowingRenameCollector.java +++ b/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/VarShadowingRenameCollector.java @@ -3,6 +3,7 @@ import java.util.Collections; import java.util.LinkedList; import java.util.List; +import java.util.Map; import java.util.Set; import java.util.Stack; import java.util.Vector; @@ -42,6 +43,7 @@ import org.overture.ast.statements.AForAllStm; import org.overture.ast.statements.AForIndexStm; import org.overture.ast.statements.AForPatternBindStm; +import org.overture.ast.statements.AIdentifierStateDesignator; import org.overture.ast.statements.ALetBeStStm; import org.overture.ast.statements.ALetStm; import org.overture.ast.statements.ATixeStm; @@ -56,45 +58,41 @@ import org.overture.typechecker.assistant.definition.AExplicitFunctionDefinitionAssistantTC; /** - * - * This analysis is used to compute new names for variables that shadow - * other variables. A renaming is suggested if a definition hides another variable - * or causes a duplicate definition. In addition to renaming the definition itself, - * occurrences of the definition must also be renamed. Occurrences include both - * variable expressions (e.g. return a) as well as identifier - * patterns (in mk_(a,a) the first 'a' is a definition whereas the second 'a' - * is an identifier pattern occurrence of the first 'a') - * - * When computed, the renamings can be applied in order to get rid of warnings - * related to hidden variables and duplicate definitions. - * - * The current version of this analysis only considers renamings in operations - * and functions. This is sufficient if the VDM AST is code generated to Java - * since Java allows hiding of class fields. + * This analysis is used to compute new names for variables that shadow other variables. A renaming is suggested if a + * definition hides another variable or causes a duplicate definition. In addition to renaming the definition itself, + * occurrences of the definition must also be renamed. Occurrences include both variable expressions (e.g. return a), + * identifier state designators (e.g. x := 5) as well as identifier patterns (in mk_(a,a) the first 'a' is a definition + * whereas the second 'a' is an identifier pattern occurrence of the first 'a') When computed, the renamings can be + * applied in order to get rid of warnings related to hidden variables and duplicate definitions. The current version of + * this analysis only considers renamings in operations and functions. This is sufficient if the VDM AST is code + * generated to Java since Java allows hiding of class fields. * * @author pvj - * */ public class VarShadowingRenameCollector extends DepthFirstAnalysisAdaptor { - private PDefinition enclosingDef = null; + private ITypeCheckerAssistantFactory af; + + private PDefinition enclosingDef; + private Map idDefs; private Stack localDefsInScope; - private List renamings; private int enclosingCounter; + + private List renamings; private List namesToAvoid; - - private ITypeCheckerAssistantFactory af; - private TempVarNameGen nameGen; - - public VarShadowingRenameCollector(ITypeCheckerAssistantFactory af) + + public VarShadowingRenameCollector(ITypeCheckerAssistantFactory af, Map idDefs) { + this.af = af; + this.enclosingDef = null; + this.idDefs = idDefs; this.localDefsInScope = new Stack(); - this.renamings = new LinkedList(); this.enclosingCounter = 0; + + this.renamings = new LinkedList(); this.namesToAvoid = new LinkedList(); - this.af = af; this.nameGen = new TempVarNameGen(); } @@ -595,20 +593,27 @@ private void openLoop(ILexNameToken var, INode varParent, PStm body) if(varParent != null) { - Set idOccurences = collectIdOccurences(var, varParent); + Set idPatterns = collectIdOccurences(var, varParent); - for(AIdentifierPattern id : idOccurences) + for(AIdentifierPattern id : idPatterns) { registerRenaming(id.getName(), newName); } } - Set varOccurences = collectVarOccurences(var.getLocation(), body); + Set vars = collectVarOccurences(var.getLocation(), body); - for (AVariableExp varExp : varOccurences) + for (AVariableExp varExp : vars) { registerRenaming(varExp.getName(), newName); } + + Set idStateDesignators = collectIdDesignatorOccurrences(var.getLocation(), body); + + for(AIdentifierStateDesignator id : idStateDesignators) + { + registerRenaming(id.getName(), newName); + } } } @@ -855,18 +860,25 @@ private void findRenamings(PDefinition localDefToRename, INode parentNode, INode registerRenaming(localDefName, newName); } - Set occurences = collectVarOccurences(localDefToRename.getLocation(), defScope); + Set vars = collectVarOccurences(localDefToRename.getLocation(), defScope); - for (AVariableExp varExp : occurences) + for (AVariableExp varExp : vars) { registerRenaming(varExp.getName(), newName); } + + Set idStateDesignators = collectIdDesignatorOccurrences(localDefToRename.getLocation(), defScope); + + for(AIdentifierStateDesignator id : idStateDesignators) + { + registerRenaming(id.getName(), newName); + } - Set patternsOcc = collectIdOccurences(localDefName, parentNode); + Set idPatterns = collectIdOccurences(localDefName, parentNode); - for (AIdentifierPattern p : patternsOcc) + for (AIdentifierPattern id : idPatterns) { - registerRenaming(p.getName(), newName); + registerRenaming(id.getName(), newName); } } @@ -901,6 +913,16 @@ private Set collectVarOccurences(ILexLocation defLoc, INode defSco return collector.getVars(); } + private Set collectIdDesignatorOccurrences( + ILexLocation defLoc, INode defScope) throws AnalysisException + { + IdDesignatorOccurencesCollector collector = new IdDesignatorOccurencesCollector(defLoc, idDefs); + + defScope.apply(collector); + + return collector.getIds(); + } + private Set collectIdOccurences(ILexNameToken name, INode parent) throws AnalysisException { IdOccurencesCollector collector = new IdOccurencesCollector(name, parent); diff --git a/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/VarShadowingRenamer.java b/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/VarShadowingRenamer.java index 0279826dce..115871233e 100644 --- a/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/VarShadowingRenamer.java +++ b/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/VarShadowingRenamer.java @@ -1,9 +1,12 @@ package org.overture.codegen.analysis.vdm; import java.util.List; +import java.util.Map; import org.overture.ast.analysis.AnalysisException; +import org.overture.ast.definitions.PDefinition; import org.overture.ast.definitions.SClassDefinition; +import org.overture.ast.statements.AIdentifierStateDesignator; import org.overture.typechecker.assistant.ITypeCheckerAssistantFactory; public class VarShadowingRenamer @@ -15,9 +18,9 @@ public void rename(SClassDefinition clazz, List renamings) } public List computeRenamings(List classes, - ITypeCheckerAssistantFactory af) throws AnalysisException + ITypeCheckerAssistantFactory af, Map idDefs) throws AnalysisException { - VarShadowingRenameCollector renamer = new VarShadowingRenameCollector(af); + VarShadowingRenameCollector renamer = new VarShadowingRenameCollector(af, idDefs); for (SClassDefinition clazz : classes) { diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java index 806b069224..8146fd8eb1 100644 --- a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java +++ b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java @@ -214,7 +214,7 @@ public GeneratedData generateJavaFromVdm( // To document any renaming of variables shadowing other variables removeUnreachableStms(mergedParseLists); - List allRenamings = performRenaming(mergedParseLists); + List allRenamings = performRenaming(mergedParseLists, getInfo().getIdStateDesignatorDefs()); for (SClassDefinition classDef : mergedParseLists) { @@ -386,12 +386,12 @@ private void removeUnreachableStms(List mergedParseLists) thro } } - private List performRenaming(List mergedParseLists) + private List performRenaming(List mergedParseLists, Map idDefs) throws AnalysisException { List allRenamings = new LinkedList(); - VarShadowingRenameCollector renamingsCollector = new VarShadowingRenameCollector(generator.getIRInfo().getTcFactory()); + VarShadowingRenameCollector renamingsCollector = new VarShadowingRenameCollector(generator.getIRInfo().getTcFactory(), idDefs); VarShadowingRenamer renamer = new VarShadowingRenamer(); for (SClassDefinition classDef : mergedParseLists) diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/VarShadowingTestCase.java b/core/codegen/src/test/java/org/overture/codegen/tests/VarShadowingTestCase.java index df01d72130..faf156af98 100644 --- a/core/codegen/src/test/java/org/overture/codegen/tests/VarShadowingTestCase.java +++ b/core/codegen/src/test/java/org/overture/codegen/tests/VarShadowingTestCase.java @@ -3,11 +3,15 @@ import java.io.File; import java.util.LinkedList; import java.util.List; +import java.util.Map; import org.junit.Assert; +import org.overture.ast.definitions.PDefinition; import org.overture.ast.definitions.SClassDefinition; import org.overture.ast.lex.Dialect; import org.overture.ast.node.INode; +import org.overture.ast.statements.AIdentifierStateDesignator; +import org.overture.codegen.analysis.vdm.IdStateDesignatorDefCollector; import org.overture.codegen.analysis.vdm.Renaming; import org.overture.codegen.analysis.vdm.VarShadowingRenamer; import org.overture.codegen.logging.Logger; @@ -64,11 +68,13 @@ public void test() throws Exception try { TypeCheckResult> originalSpecTcResult = TypeCheckerUtil.typeCheckPp(file); + Map idDefs = IdStateDesignatorDefCollector.getIdDefs(originalSpecTcResult.result); Assert.assertTrue(getName() + " has type errors", originalSpecTcResult.errors.isEmpty()); Value orgSpecResult = evalSpec(originalSpecTcResult.result); - List renamings = new VarShadowingRenamer().computeRenamings(originalSpecTcResult.result, af); + + List renamings = new VarShadowingRenamer().computeRenamings(originalSpecTcResult.result, af, idDefs); StringBuilder sb = GeneralUtils.readLines(file, "\n"); From 512367d825bb37b6afb755554d3508423660c983 Mon Sep 17 00:00:00 2001 From: gkanos Date: Wed, 4 Mar 2015 15:15:40 +0100 Subject: [PATCH 203/323] removing more FIXME tag and fixing them. +remove the ACaseAlternativeAsssistantTC as empty. Method moved to TypeCheckerExpVisitor --- .../ITypeCheckerAssistantFactory.java | 3 +- .../TypeCheckerAssistantFactory.java | 11 +-- .../ACaseAlternativeAssistantTC.java | 97 ------------------- .../visitor/TypeCheckerExpVisitor.java | 53 +++++++++- 4 files changed, 58 insertions(+), 106 deletions(-) delete mode 100644 core/typechecker/src/main/java/org/overture/typechecker/assistant/expression/ACaseAlternativeAssistantTC.java diff --git a/core/typechecker/src/main/java/org/overture/typechecker/assistant/ITypeCheckerAssistantFactory.java b/core/typechecker/src/main/java/org/overture/typechecker/assistant/ITypeCheckerAssistantFactory.java index 2fb7310bae..57e22dd697 100644 --- a/core/typechecker/src/main/java/org/overture/typechecker/assistant/ITypeCheckerAssistantFactory.java +++ b/core/typechecker/src/main/java/org/overture/typechecker/assistant/ITypeCheckerAssistantFactory.java @@ -69,7 +69,6 @@ import org.overture.typechecker.assistant.definition.PDefinitionSet; import org.overture.typechecker.assistant.definition.PTraceDefinitionAssistantTC; import org.overture.typechecker.assistant.definition.SClassDefinitionAssistantTC; -import org.overture.typechecker.assistant.expression.ACaseAlternativeAssistantTC; import org.overture.typechecker.assistant.expression.SBinaryExpAssistantTC; import org.overture.typechecker.assistant.module.AModuleImportsAssistantTC; import org.overture.typechecker.assistant.module.AModuleModulesAssistantTC; @@ -159,7 +158,7 @@ public interface ITypeCheckerAssistantFactory extends IAstAssistantFactory // expression //AApplyExpAssistantTC createAApplyExpAssistant(); - ACaseAlternativeAssistantTC createACaseAlternativeAssistant(); + //ACaseAlternativeAssistantTC createACaseAlternativeAssistant(); //PExpAssistantTC createPExpAssistant(); diff --git a/core/typechecker/src/main/java/org/overture/typechecker/assistant/TypeCheckerAssistantFactory.java b/core/typechecker/src/main/java/org/overture/typechecker/assistant/TypeCheckerAssistantFactory.java index 2456b7d294..41557d9531 100644 --- a/core/typechecker/src/main/java/org/overture/typechecker/assistant/TypeCheckerAssistantFactory.java +++ b/core/typechecker/src/main/java/org/overture/typechecker/assistant/TypeCheckerAssistantFactory.java @@ -69,7 +69,6 @@ import org.overture.typechecker.assistant.definition.PDefinitionSet; import org.overture.typechecker.assistant.definition.PTraceDefinitionAssistantTC; import org.overture.typechecker.assistant.definition.SClassDefinitionAssistantTC; -import org.overture.typechecker.assistant.expression.ACaseAlternativeAssistantTC; import org.overture.typechecker.assistant.expression.SBinaryExpAssistantTC; import org.overture.typechecker.assistant.module.AModuleImportsAssistantTC; import org.overture.typechecker.assistant.module.AModuleModulesAssistantTC; @@ -372,11 +371,11 @@ public SClassDefinitionAssistantTC createSClassDefinitionAssistant() // return new AApplyExpAssistantTC(this); // } - @Override - public ACaseAlternativeAssistantTC createACaseAlternativeAssistant() - { - return new ACaseAlternativeAssistantTC(this); - } +// @Override +// public ACaseAlternativeAssistantTC createACaseAlternativeAssistant() +// { +// return new ACaseAlternativeAssistantTC(this); +// } // @Override // public PExpAssistantTC createPExpAssistant() diff --git a/core/typechecker/src/main/java/org/overture/typechecker/assistant/expression/ACaseAlternativeAssistantTC.java b/core/typechecker/src/main/java/org/overture/typechecker/assistant/expression/ACaseAlternativeAssistantTC.java deleted file mode 100644 index 10cbf7bd89..0000000000 --- a/core/typechecker/src/main/java/org/overture/typechecker/assistant/expression/ACaseAlternativeAssistantTC.java +++ /dev/null @@ -1,97 +0,0 @@ -/* - * #%~ - * The VDM Type Checker - * %% - * Copyright (C) 2008 - 2014 Overture - * %% - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as - * published by the Free Software Foundation, either version 3 of the - * License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public - * License along with this program. If not, see - * . - * #~% - */ -package org.overture.typechecker.assistant.expression; - -import org.overture.ast.analysis.AnalysisException; -import org.overture.ast.analysis.intf.IQuestionAnswer; -import org.overture.ast.assistant.IAstAssistant; -import org.overture.ast.expressions.ACaseAlternative; -import org.overture.ast.patterns.AExpressionPattern; -import org.overture.ast.typechecker.NameScope; -import org.overture.ast.types.PType; -import org.overture.typechecker.Environment; -import org.overture.typechecker.FlatCheckedEnvironment; -import org.overture.typechecker.TypeCheckException; -import org.overture.typechecker.TypeCheckInfo; -import org.overture.typechecker.TypeCheckerErrors; -import org.overture.typechecker.assistant.ITypeCheckerAssistantFactory; - -public class ACaseAlternativeAssistantTC implements IAstAssistant -{ - protected ITypeCheckerAssistantFactory af; - - public ACaseAlternativeAssistantTC(ITypeCheckerAssistantFactory af) - { - this.af = af; - } - - //FIXME only used once. move it - public PType typeCheck(ACaseAlternative c, - IQuestionAnswer rootVisitor, - TypeCheckInfo question, PType expType) throws AnalysisException - { - - if (c.getDefs().size() == 0) - { - // c.setDefs(new ArrayList()); - af.createPPatternAssistant().typeResolve(c.getPattern(), rootVisitor, new TypeCheckInfo(question.assistantFactory, question.env)); - - if (c.getPattern() instanceof AExpressionPattern) - { - // Only expression patterns need type checking... - AExpressionPattern ep = (AExpressionPattern) c.getPattern(); - PType ptype = ep.getExp().apply(rootVisitor, new TypeCheckInfo(question.assistantFactory, question.env, question.scope)); - - if (!af.getTypeComparator().compatible(ptype, expType)) - { - TypeCheckerErrors.report(3311, "Pattern cannot match", c.getPattern().getLocation(), c.getPattern()); - } - } - - try - { - af.createPPatternAssistant().typeResolve(c.getPattern(), rootVisitor, new TypeCheckInfo(question.assistantFactory, question.env)); - c.getDefs().addAll(af.createPPatternAssistant().getDefinitions(c.getPattern(), expType, NameScope.LOCAL)); - } - catch (TypeCheckException e) - { - c.getDefs().clear(); - throw e; - } - } - - af.createPPatternAssistant().typeCheck(c.getPattern(), question, rootVisitor); - af.createPDefinitionListAssistant().typeCheck(c.getDefs(), rootVisitor, new TypeCheckInfo(question.assistantFactory, question.env, question.scope)); - - if (!af.createPPatternAssistant().matches(c.getPattern(), expType)) - { - TypeCheckerErrors.report(3311, "Pattern cannot match", c.getPattern().getLocation(), c.getPattern()); - } - - Environment local = new FlatCheckedEnvironment(af, c.getDefs(), question.env, question.scope); - question = question.newInfo(local); - c.setType(c.getResult().apply(rootVisitor, question)); - local.unusedCheck(); - return c.getType(); - } - -} diff --git a/core/typechecker/src/main/java/org/overture/typechecker/visitor/TypeCheckerExpVisitor.java b/core/typechecker/src/main/java/org/overture/typechecker/visitor/TypeCheckerExpVisitor.java index c20ca404d2..32302b0b1b 100644 --- a/core/typechecker/src/main/java/org/overture/typechecker/visitor/TypeCheckerExpVisitor.java +++ b/core/typechecker/src/main/java/org/overture/typechecker/visitor/TypeCheckerExpVisitor.java @@ -46,6 +46,7 @@ import org.overture.ast.intf.lex.ILexNameToken; import org.overture.ast.intf.lex.ILexRealToken; import org.overture.ast.lex.LexNameToken; +import org.overture.ast.patterns.AExpressionPattern; import org.overture.ast.patterns.AIdentifierPattern; import org.overture.ast.patterns.ASetBind; import org.overture.ast.patterns.ATypeBind; @@ -80,6 +81,7 @@ import org.overture.config.Settings; import org.overture.typechecker.Environment; import org.overture.typechecker.FlatCheckedEnvironment; +import org.overture.typechecker.TypeCheckException; import org.overture.typechecker.TypeCheckInfo; import org.overture.typechecker.TypeCheckerErrors; import org.overture.typechecker.assistant.definition.PDefinitionAssistantTC; @@ -1121,7 +1123,7 @@ public PType caseACasesExp(ACasesExp node, TypeCheckInfo question) for (ACaseAlternative c : node.getCases()) { - rtypes.add(question.assistantFactory.createACaseAlternativeAssistant().typeCheck(c, THIS, question, expType)); + rtypes.add(typeCheck(c, THIS, question, expType)); } if (node.getOthers() != null) @@ -3469,4 +3471,53 @@ public String getMeasureApply(AApplyExp node, ILexNameToken measure, return start + Utils.listToString(node.getArgs()) + (close ? ")" : ", "); } + + public PType typeCheck(ACaseAlternative c, + IQuestionAnswer rootVisitor, + TypeCheckInfo question, PType expType) throws AnalysisException + { + + if (c.getDefs().size() == 0) + { + // c.setDefs(new ArrayList()); + question.assistantFactory.createPPatternAssistant().typeResolve(c.getPattern(), rootVisitor, new TypeCheckInfo(question.assistantFactory, question.env)); + + if (c.getPattern() instanceof AExpressionPattern) + { + // Only expression patterns need type checking... + AExpressionPattern ep = (AExpressionPattern) c.getPattern(); + PType ptype = ep.getExp().apply(rootVisitor, new TypeCheckInfo(question.assistantFactory, question.env, question.scope)); + + if (!question.assistantFactory.getTypeComparator().compatible(ptype, expType)) + { + TypeCheckerErrors.report(3311, "Pattern cannot match", c.getPattern().getLocation(), c.getPattern()); + } + } + + try + { + question.assistantFactory.createPPatternAssistant().typeResolve(c.getPattern(), rootVisitor, new TypeCheckInfo(question.assistantFactory, question.env)); + c.getDefs().addAll(question.assistantFactory.createPPatternAssistant().getDefinitions(c.getPattern(), expType, NameScope.LOCAL)); + } + catch (TypeCheckException e) + { + c.getDefs().clear(); + throw e; + } + } + + question.assistantFactory.createPPatternAssistant().typeCheck(c.getPattern(), question, rootVisitor); + question.assistantFactory.createPDefinitionListAssistant().typeCheck(c.getDefs(), rootVisitor, new TypeCheckInfo(question.assistantFactory, question.env, question.scope)); + + if (!question.assistantFactory.createPPatternAssistant().matches(c.getPattern(), expType)) + { + TypeCheckerErrors.report(3311, "Pattern cannot match", c.getPattern().getLocation(), c.getPattern()); + } + + Environment local = new FlatCheckedEnvironment(question.assistantFactory, c.getDefs(), question.env, question.scope); + question = question.newInfo(local); + c.setType(c.getResult().apply(rootVisitor, question)); + local.unusedCheck(); + return c.getType(); + } } From a1019837404ed32e95c5b5a715299eedcf9c2436 Mon Sep 17 00:00:00 2001 From: gkanos Date: Wed, 4 Mar 2015 15:31:22 +0100 Subject: [PATCH 204/323] remove the ASetBindAssistantTC as empty. move the method to POForAllContext. --- .../pog/contexts/POForAllContext.java | 13 ++++- .../ITypeCheckerAssistantFactory.java | 3 +- .../TypeCheckerAssistantFactory.java | 11 ++-- .../pattern/ASetBindAssistantTC.java | 55 ------------------- 4 files changed, 18 insertions(+), 64 deletions(-) delete mode 100644 core/typechecker/src/main/java/org/overture/typechecker/assistant/pattern/ASetBindAssistantTC.java diff --git a/core/pog/src/main/java/org/overture/pog/contexts/POForAllContext.java b/core/pog/src/main/java/org/overture/pog/contexts/POForAllContext.java index 5dc95598ef..44ee87658f 100644 --- a/core/pog/src/main/java/org/overture/pog/contexts/POForAllContext.java +++ b/core/pog/src/main/java/org/overture/pog/contexts/POForAllContext.java @@ -39,6 +39,7 @@ import org.overture.ast.expressions.ASetCompSetExp; import org.overture.ast.expressions.PExp; import org.overture.ast.factory.AstFactory; +import org.overture.ast.patterns.ASetBind; import org.overture.ast.patterns.ATypeBind; import org.overture.ast.patterns.ATypeMultipleBind; import org.overture.ast.patterns.PMultipleBind; @@ -63,7 +64,7 @@ public POForAllContext(ASetCompSetExp exp) public POForAllContext(ASeqCompSeqExp exp, IPogAssistantFactory assistantFactory) { - this.bindings = assistantFactory.createASetBindAssistant().getMultipleBindList(exp.getSetBind()); + this.bindings = getMultipleBindList(exp.getSetBind()); } public POForAllContext(AForAllExp exp) @@ -154,4 +155,14 @@ public String getContext() return sb.toString(); } + + public List getMultipleBindList(ASetBind bind) + { + + List plist = new ArrayList(); + plist.add(bind.getPattern()); + List mblist = new Vector(); + mblist.add(AstFactory.newASetMultipleBind(plist, bind.getSet())); + return mblist; + } } diff --git a/core/typechecker/src/main/java/org/overture/typechecker/assistant/ITypeCheckerAssistantFactory.java b/core/typechecker/src/main/java/org/overture/typechecker/assistant/ITypeCheckerAssistantFactory.java index 57e22dd697..78612216a0 100644 --- a/core/typechecker/src/main/java/org/overture/typechecker/assistant/ITypeCheckerAssistantFactory.java +++ b/core/typechecker/src/main/java/org/overture/typechecker/assistant/ITypeCheckerAssistantFactory.java @@ -75,7 +75,6 @@ import org.overture.typechecker.assistant.module.PImportAssistantTC; import org.overture.typechecker.assistant.pattern.AMapletPatternMapletAssistantTC; import org.overture.typechecker.assistant.pattern.APatternTypePairAssistant; -import org.overture.typechecker.assistant.pattern.ASetBindAssistantTC; import org.overture.typechecker.assistant.pattern.ATypeBindAssistantTC; import org.overture.typechecker.assistant.pattern.PBindAssistantTC; import org.overture.typechecker.assistant.pattern.PMultipleBindAssistantTC; @@ -199,7 +198,7 @@ public interface ITypeCheckerAssistantFactory extends IAstAssistantFactory // ASeqPatternAssistantTC createASeqPatternAssistant(); - ASetBindAssistantTC createASetBindAssistant(); + //ASetBindAssistantTC createASetBindAssistant(); // ASetPatternAssistantTC createASetPatternAssistant(); diff --git a/core/typechecker/src/main/java/org/overture/typechecker/assistant/TypeCheckerAssistantFactory.java b/core/typechecker/src/main/java/org/overture/typechecker/assistant/TypeCheckerAssistantFactory.java index 41557d9531..082eb1cbc0 100644 --- a/core/typechecker/src/main/java/org/overture/typechecker/assistant/TypeCheckerAssistantFactory.java +++ b/core/typechecker/src/main/java/org/overture/typechecker/assistant/TypeCheckerAssistantFactory.java @@ -75,7 +75,6 @@ import org.overture.typechecker.assistant.module.PImportAssistantTC; import org.overture.typechecker.assistant.pattern.AMapletPatternMapletAssistantTC; import org.overture.typechecker.assistant.pattern.APatternTypePairAssistant; -import org.overture.typechecker.assistant.pattern.ASetBindAssistantTC; import org.overture.typechecker.assistant.pattern.ATypeBindAssistantTC; import org.overture.typechecker.assistant.pattern.PBindAssistantTC; import org.overture.typechecker.assistant.pattern.PMultipleBindAssistantTC; @@ -491,11 +490,11 @@ public APatternTypePairAssistant createAPatternTypePairAssistant() // return new ASeqPatternAssistantTC(this); // } - @Override - public ASetBindAssistantTC createASetBindAssistant() - { - return new ASetBindAssistantTC(this); - } +// @Override +// public ASetBindAssistantTC createASetBindAssistant() +// { +// return new ASetBindAssistantTC(this); +// } // @Override // public ASetPatternAssistantTC createASetPatternAssistant() diff --git a/core/typechecker/src/main/java/org/overture/typechecker/assistant/pattern/ASetBindAssistantTC.java b/core/typechecker/src/main/java/org/overture/typechecker/assistant/pattern/ASetBindAssistantTC.java deleted file mode 100644 index 010804d263..0000000000 --- a/core/typechecker/src/main/java/org/overture/typechecker/assistant/pattern/ASetBindAssistantTC.java +++ /dev/null @@ -1,55 +0,0 @@ -/* - * #%~ - * The VDM Type Checker - * %% - * Copyright (C) 2008 - 2014 Overture - * %% - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as - * published by the Free Software Foundation, either version 3 of the - * License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public - * License along with this program. If not, see - * . - * #~% - */ -package org.overture.typechecker.assistant.pattern; - -import java.util.ArrayList; -import java.util.List; -import java.util.Vector; - -import org.overture.ast.assistant.IAstAssistant; -import org.overture.ast.factory.AstFactory; -import org.overture.ast.patterns.ASetBind; -import org.overture.ast.patterns.PMultipleBind; -import org.overture.ast.patterns.PPattern; -import org.overture.typechecker.assistant.ITypeCheckerAssistantFactory; - -public class ASetBindAssistantTC implements IAstAssistant -{ - protected ITypeCheckerAssistantFactory af; - - public ASetBindAssistantTC(ITypeCheckerAssistantFactory af) - { - this.af = af; - } - - //FIXME only used once. move it - public List getMultipleBindList(ASetBind bind) - { - - List plist = new ArrayList(); - plist.add(bind.getPattern()); - List mblist = new Vector(); - mblist.add(AstFactory.newASetMultipleBind(plist, bind.getSet())); - return mblist; - } - -} From 4cb7081f644ed3e19d9b8d9cf65772b7221d871b Mon Sep 17 00:00:00 2001 From: gkanos Date: Wed, 4 Mar 2015 15:42:15 +0100 Subject: [PATCH 205/323] Remove PImportAsssistantTC as empty. move the method into AModuleAssistantTC. --- .../ITypeCheckerAssistantFactory.java | 3 +- .../TypeCheckerAssistantFactory.java | 11 ++-- .../module/AModuleImportsAssistantTC.java | 13 ++++- .../assistant/module/PImportAssistantTC.java | 53 ------------------- 4 files changed, 18 insertions(+), 62 deletions(-) delete mode 100644 core/typechecker/src/main/java/org/overture/typechecker/assistant/module/PImportAssistantTC.java diff --git a/core/typechecker/src/main/java/org/overture/typechecker/assistant/ITypeCheckerAssistantFactory.java b/core/typechecker/src/main/java/org/overture/typechecker/assistant/ITypeCheckerAssistantFactory.java index 78612216a0..6825d63693 100644 --- a/core/typechecker/src/main/java/org/overture/typechecker/assistant/ITypeCheckerAssistantFactory.java +++ b/core/typechecker/src/main/java/org/overture/typechecker/assistant/ITypeCheckerAssistantFactory.java @@ -72,7 +72,6 @@ import org.overture.typechecker.assistant.expression.SBinaryExpAssistantTC; import org.overture.typechecker.assistant.module.AModuleImportsAssistantTC; import org.overture.typechecker.assistant.module.AModuleModulesAssistantTC; -import org.overture.typechecker.assistant.module.PImportAssistantTC; import org.overture.typechecker.assistant.pattern.AMapletPatternMapletAssistantTC; import org.overture.typechecker.assistant.pattern.APatternTypePairAssistant; import org.overture.typechecker.assistant.pattern.ATypeBindAssistantTC; @@ -175,7 +174,7 @@ public interface ITypeCheckerAssistantFactory extends IAstAssistantFactory //PExportAssistantTC createPExportAssistant(); - PImportAssistantTC createPImportAssistant(); + //PImportAssistantTC createPImportAssistant(); // pattern // ABooleanPatternAssistantTC createABooleanPatternAssistant(); diff --git a/core/typechecker/src/main/java/org/overture/typechecker/assistant/TypeCheckerAssistantFactory.java b/core/typechecker/src/main/java/org/overture/typechecker/assistant/TypeCheckerAssistantFactory.java index 082eb1cbc0..98d5a703a9 100644 --- a/core/typechecker/src/main/java/org/overture/typechecker/assistant/TypeCheckerAssistantFactory.java +++ b/core/typechecker/src/main/java/org/overture/typechecker/assistant/TypeCheckerAssistantFactory.java @@ -72,7 +72,6 @@ import org.overture.typechecker.assistant.expression.SBinaryExpAssistantTC; import org.overture.typechecker.assistant.module.AModuleImportsAssistantTC; import org.overture.typechecker.assistant.module.AModuleModulesAssistantTC; -import org.overture.typechecker.assistant.module.PImportAssistantTC; import org.overture.typechecker.assistant.pattern.AMapletPatternMapletAssistantTC; import org.overture.typechecker.assistant.pattern.APatternTypePairAssistant; import org.overture.typechecker.assistant.pattern.ATypeBindAssistantTC; @@ -422,11 +421,11 @@ public AModuleModulesAssistantTC createAModuleModulesAssistant() // return new PExportAssistantTC(this); // } - @Override - public PImportAssistantTC createPImportAssistant() - { - return new PImportAssistantTC(this); - } +// @Override +// public PImportAssistantTC createPImportAssistant() +// { +// return new PImportAssistantTC(this); +// } // pattern diff --git a/core/typechecker/src/main/java/org/overture/typechecker/assistant/module/AModuleImportsAssistantTC.java b/core/typechecker/src/main/java/org/overture/typechecker/assistant/module/AModuleImportsAssistantTC.java index 6ece427ea7..8a0ee80424 100644 --- a/core/typechecker/src/main/java/org/overture/typechecker/assistant/module/AModuleImportsAssistantTC.java +++ b/core/typechecker/src/main/java/org/overture/typechecker/assistant/module/AModuleImportsAssistantTC.java @@ -95,7 +95,7 @@ public List getDefinitions(AFromModuleImports ifm, { for (PImport imp : ofType) { - defs.addAll(af.createPImportAssistant().getDefinitions(imp, from)); + defs.addAll(getDefinitions(imp, from)); } } @@ -119,5 +119,16 @@ public void typeCheck(AFromModuleImports ifm, ModuleEnvironment env) } } + + public List getDefinitions(PImport imp, AModuleModules from) + { + try + { + return imp.apply(af.getImportDefinitionFinder(), from); + } catch (AnalysisException e) + { + return null; + } + } } diff --git a/core/typechecker/src/main/java/org/overture/typechecker/assistant/module/PImportAssistantTC.java b/core/typechecker/src/main/java/org/overture/typechecker/assistant/module/PImportAssistantTC.java deleted file mode 100644 index df5b96912b..0000000000 --- a/core/typechecker/src/main/java/org/overture/typechecker/assistant/module/PImportAssistantTC.java +++ /dev/null @@ -1,53 +0,0 @@ -/* - * #%~ - * The VDM Type Checker - * %% - * Copyright (C) 2008 - 2014 Overture - * %% - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as - * published by the Free Software Foundation, either version 3 of the - * License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public - * License along with this program. If not, see - * . - * #~% - */ -package org.overture.typechecker.assistant.module; - -import java.util.List; - -import org.overture.ast.analysis.AnalysisException; -import org.overture.ast.assistant.IAstAssistant; -import org.overture.ast.definitions.PDefinition; -import org.overture.ast.modules.AModuleModules; -import org.overture.ast.modules.PImport; -import org.overture.typechecker.assistant.ITypeCheckerAssistantFactory; - -public class PImportAssistantTC implements IAstAssistant -{ - protected ITypeCheckerAssistantFactory af; - - public PImportAssistantTC(ITypeCheckerAssistantFactory af) - { - this.af = af; - } - - //FIXME only used once. move it - public List getDefinitions(PImport imp, AModuleModules from) - { - try - { - return imp.apply(af.getImportDefinitionFinder(), from); - } catch (AnalysisException e) - { - return null; - } - } -} From c875730525a7ba4e5338caec7ff2eecf6c731e9b Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Wed, 4 Mar 2015 17:52:52 +0100 Subject: [PATCH 206/323] Use new (broken) ast creator. [Issue: ] --- core/cgisa/pom.xml | 4 ++-- core/cgisa/src/main/resources/isacg.ast | 14 ++++++++------ 2 files changed, 10 insertions(+), 8 deletions(-) diff --git a/core/cgisa/pom.xml b/core/cgisa/pom.xml index 665f7b5341..d0e38a673d 100644 --- a/core/cgisa/pom.xml +++ b/core/cgisa/pom.xml @@ -13,7 +13,7 @@ VDM to Isabelle Translation - 1.6.4 + 1.6.7-SNAPSHOT @@ -57,7 +57,7 @@ - org.overturetool.astcreator + org.overture.astcreator astcreator-plugin ${astcreator.version} diff --git a/core/cgisa/src/main/resources/isacg.ast b/core/cgisa/src/main/resources/isacg.ast index 1ecc4db994..581cd1f109 100644 --- a/core/cgisa/src/main/resources/isacg.ast +++ b/core/cgisa/src/main/resources/isacg.ast @@ -10,10 +10,12 @@ Abstract Syntax Tree CG = #decl ; + #decl {-> package='org.overture.cgisa.extast.declarations'} - = {mrFuncGroup} - [funcs]:CG.#decl.func* - | {extClass} - [baseClass]:CG.#decl.class - [mutrecfuncs]:CG.#decl.mrFuncGroup* - ; + = {mrFuncGroup} + [funcs]:CG.#decl.func* + | {class} + [mutrecfuncs]:CG.#decl.mrFuncGroup* + | {extClass} + [baseClass]:CG.#decl.class + ; \ No newline at end of file From b6123b4754f8c7cc1648401d1a4246b285ba364b Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 4 Mar 2015 20:02:11 +0100 Subject: [PATCH 207/323] Update to existing test result related to generation of state designators --- .../complex_expressions/MapSeqStateDesignatorNesting.result | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorNesting.result b/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorNesting.result index 35da020e86..204a1f850e 100644 --- a/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorNesting.result +++ b/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorNesting.result @@ -9,7 +9,7 @@ public class Entry { public static Object Run() { A a = new A(MapUtil.map(new Maplet(1L, true))); - a.x.put(10L, false); + Utils.mapSeqUpdate(a.x, 10L, false); return Utils.clone(a.x); } From b9095ce0b6d2b0eca5814dba1fc3555483cbcf5f Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 4 Mar 2015 20:04:55 +0100 Subject: [PATCH 208/323] Added test to exercise code generation of state designators (updates to maps) --- .../MapSeqStateDesignatorMapUpdate | 16 +++++++++++++ .../MapSeqStateDesignatorMapUpdate.result | 23 +++++++++++++++++++ 2 files changed, 39 insertions(+) create mode 100644 core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapUpdate create mode 100644 core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapUpdate.result diff --git a/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapUpdate b/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapUpdate new file mode 100644 index 0000000000..bf843b74ad --- /dev/null +++ b/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapUpdate @@ -0,0 +1,16 @@ +class Entry + +instance variables + +static x : map nat to bool := {1 |-> true}; + +operations + +public static Run : () ==> ? +Run () == +( + x(4) := false; + return x; +) + +end Entry \ No newline at end of file diff --git a/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapUpdate.result b/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapUpdate.result new file mode 100644 index 0000000000..af052910ae --- /dev/null +++ b/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapUpdate.result @@ -0,0 +1,23 @@ +import org.overture.codegen.runtime.*; + +import java.util.*; + + +public class Entry { + private static VDMMap x = MapUtil.map(new Maplet(1L, true)); + + public Entry() { + } + + public static Object Run() { + Utils.mapSeqUpdate(x, 4L, false); + + return Utils.clone(x); + } + + public String toString() { + return "Entry{" + "x := " + Utils.toString(x) + "}"; + } +} + +########## From 52bc0bdeb806fcfa5bcd17c1c357472a16f46603 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 4 Mar 2015 20:06:04 +0100 Subject: [PATCH 209/323] Added test revealing problem with code generation of state designators (sequence updates) --- .../MapSeqStateDesignatorSeqUpdate | 13 +++++++++++ .../MapSeqStateDesignatorSeqUpdate.result | 22 +++++++++++++++++++ 2 files changed, 35 insertions(+) create mode 100644 core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorSeqUpdate create mode 100644 core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorSeqUpdate.result diff --git a/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorSeqUpdate b/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorSeqUpdate new file mode 100644 index 0000000000..ae0ffcc2d0 --- /dev/null +++ b/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorSeqUpdate @@ -0,0 +1,13 @@ +class Entry + +operations + +public static Run : () ==> ? +Run () == +( + dcl xs : seq of nat := [1,2,3]; + xs(2) := 5; + return xs(2); +); + +end Entry \ No newline at end of file diff --git a/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorSeqUpdate.result b/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorSeqUpdate.result new file mode 100644 index 0000000000..8b3db152e1 --- /dev/null +++ b/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorSeqUpdate.result @@ -0,0 +1,22 @@ +import org.overture.codegen.runtime.*; + +import java.util.*; + + +public class Entry { + public Entry() { + } + + public static Object Run() { + VDMSeq xs = SeqUtil.seq(1L, 2L, 3L); + Utils.mapSeqUpdate(xs, 2L, 5L); + + return ((Number) xs.get(Utils.index(2L))); + } + + public String toString() { + return "Entry{}"; + } +} + +########## From 4a1a21a231100d992bc4d1a54c248d7c54c2529c Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 4 Mar 2015 20:13:49 +0100 Subject: [PATCH 210/323] Added two IR constructs to represent reading and updates to both maps and sequences (much like VDM does it) --- .../codegen/merging/TemplateManager.java | 10 ++++---- .../trans/AssignStmTransformation.java | 24 +++++++++---------- .../conc/InstanceVarPPEvalTransformation.java | 4 ++-- .../trans/conv/StateDesignatorToExpCG.java | 24 ++++++++++--------- .../codegen/vdm2java/JavaValueSemantics.java | 16 ++++++------- .../JavaTemplates/Expressions/MapGet.vm | 5 ---- .../JavaTemplates/Expressions/MapSeqGet.vm | 5 ++++ .../JavaTemplates/Statements/MapPut.vm | 5 ---- .../JavaTemplates/Statements/MapSeqUpdate.vm | 5 ++++ core/codegen/src/main/resources/cg.astv2 | 4 ++-- .../MapSeqStateDesignatorInstanceVar | 16 ------------- .../MapSeqStateDesignatorInstanceVar.result | 23 ------------------ 12 files changed, 52 insertions(+), 89 deletions(-) delete mode 100644 core/codegen/src/main/resources/JavaTemplates/Expressions/MapGet.vm create mode 100644 core/codegen/src/main/resources/JavaTemplates/Expressions/MapSeqGet.vm delete mode 100644 core/codegen/src/main/resources/JavaTemplates/Statements/MapPut.vm create mode 100644 core/codegen/src/main/resources/JavaTemplates/Statements/MapSeqUpdate.vm delete mode 100644 core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorInstanceVar delete mode 100644 core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorInstanceVar.result diff --git a/core/codegen/src/main/java/org/overture/codegen/merging/TemplateManager.java b/core/codegen/src/main/java/org/overture/codegen/merging/TemplateManager.java index f6025e86bc..1773d946b1 100644 --- a/core/codegen/src/main/java/org/overture/codegen/merging/TemplateManager.java +++ b/core/codegen/src/main/java/org/overture/codegen/merging/TemplateManager.java @@ -63,8 +63,8 @@ import org.overture.codegen.cgast.statements.AIfStmCG; import org.overture.codegen.cgast.statements.AIncrementStmCG; import org.overture.codegen.cgast.statements.ALocalPatternAssignmentStmCG; -import org.overture.codegen.cgast.statements.AMapPutStmCG; import org.overture.codegen.cgast.statements.AMapSeqStateDesignatorCG; +import org.overture.codegen.cgast.statements.AMapSeqUpdateStmCG; import org.overture.codegen.cgast.statements.ANewObjectDesignatorCG; import org.overture.codegen.cgast.statements.ANotImplementedStmCG; import org.overture.codegen.cgast.statements.APlainCallStmCG; @@ -346,8 +346,8 @@ protected void initNodeTemplateFileNames() nodeTemplateFileNames.put(AStartlistStmCG.class, templateStructure.STM_PATH + "Startlist"); - nodeTemplateFileNames.put(AMapPutStmCG.class, templateStructure.STM_PATH - + "MapPut"); + nodeTemplateFileNames.put(AMapSeqUpdateStmCG.class, templateStructure.STM_PATH + + "MapSeqUpdate"); // Expressions @@ -432,8 +432,8 @@ protected void initNodeTemplateFileNames() nodeTemplateFileNames.put(AHistoryExpCG.class, templateStructure.EXP_PATH + "HistoryExp"); - nodeTemplateFileNames.put(AMapGetExpCG.class, templateStructure.EXP_PATH - + "MapGet"); + nodeTemplateFileNames.put(AMapSeqGetExpCG.class, templateStructure.EXP_PATH + + "MapSeqGet"); // Is expressions diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/AssignStmTransformation.java b/core/codegen/src/main/java/org/overture/codegen/trans/AssignStmTransformation.java index 074c2a6565..6186f93f6c 100644 --- a/core/codegen/src/main/java/org/overture/codegen/trans/AssignStmTransformation.java +++ b/core/codegen/src/main/java/org/overture/codegen/trans/AssignStmTransformation.java @@ -9,8 +9,8 @@ import org.overture.codegen.cgast.declarations.AClassDeclCG; import org.overture.codegen.cgast.statements.AAssignToExpStmCG; import org.overture.codegen.cgast.statements.AAssignmentStmCG; -import org.overture.codegen.cgast.statements.AMapPutStmCG; import org.overture.codegen.cgast.statements.AMapSeqStateDesignatorCG; +import org.overture.codegen.cgast.statements.AMapSeqUpdateStmCG; import org.overture.codegen.ir.IRInfo; import org.overture.codegen.logging.Logger; import org.overture.codegen.trans.assistants.TransAssistantCG; @@ -30,23 +30,23 @@ public void caseAAssignmentStmCG(AAssignmentStmCG node) throws AnalysisException { SStmCG newNode = null; + if(node.getTarget() instanceof AMapSeqStateDesignatorCG) { AMapSeqStateDesignatorCG target = (AMapSeqStateDesignatorCG) node.getTarget(); - SExpCG mapExp = target.getMapseq().apply(converter); - - SExpCG domValue = target.getExp(); - SExpCG rngValue = node.getExp(); + SExpCG col = target.getMapseq().apply(converter); + SExpCG index = target.getExp(); + SExpCG value = node.getExp(); - AMapPutStmCG mapPut = new AMapPutStmCG(); - mapPut.setMap(mapExp); - mapPut.setDomValue(domValue.clone()); - mapPut.setRngValue(rngValue.clone()); - mapPut.setSourceNode(node.getSourceNode()); - mapPut.setTag(node.getTag()); + AMapSeqUpdateStmCG mapSeqUpd = new AMapSeqUpdateStmCG(); + mapSeqUpd.setCol(col); + mapSeqUpd.setIndex(index.clone()); + mapSeqUpd.setValue(value.clone()); + mapSeqUpd.setSourceNode(node.getSourceNode()); + mapSeqUpd.setTag(node.getTag()); - newNode = mapPut; + newNode = mapSeqUpd; } else diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/conc/InstanceVarPPEvalTransformation.java b/core/codegen/src/main/java/org/overture/codegen/trans/conc/InstanceVarPPEvalTransformation.java index 502bb02724..32b53de779 100644 --- a/core/codegen/src/main/java/org/overture/codegen/trans/conc/InstanceVarPPEvalTransformation.java +++ b/core/codegen/src/main/java/org/overture/codegen/trans/conc/InstanceVarPPEvalTransformation.java @@ -14,7 +14,7 @@ import org.overture.codegen.cgast.statements.AAssignmentStmCG; import org.overture.codegen.cgast.statements.ABlockStmCG; import org.overture.codegen.cgast.statements.ACallObjectExpStmCG; -import org.overture.codegen.cgast.statements.AMapPutStmCG; +import org.overture.codegen.cgast.statements.AMapSeqUpdateStmCG; import org.overture.codegen.cgast.types.AVoidTypeCG; import org.overture.codegen.ir.IRGeneratedTag; import org.overture.codegen.ir.IRInfo; @@ -67,7 +67,7 @@ public void caseAAssignToExpStmCG(AAssignToExpStmCG node) } @Override - public void caseAMapPutStmCG(AMapPutStmCG node) throws AnalysisException + public void caseAMapSeqUpdateStmCG(AMapSeqUpdateStmCG node) throws AnalysisException { handleStateUpdate(node); } diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/conv/StateDesignatorToExpCG.java b/core/codegen/src/main/java/org/overture/codegen/trans/conv/StateDesignatorToExpCG.java index a2c23ec4d1..e01be0351a 100644 --- a/core/codegen/src/main/java/org/overture/codegen/trans/conv/StateDesignatorToExpCG.java +++ b/core/codegen/src/main/java/org/overture/codegen/trans/conv/StateDesignatorToExpCG.java @@ -8,7 +8,7 @@ import org.overture.codegen.cgast.analysis.AnswerAdaptor; import org.overture.codegen.cgast.declarations.AClassDeclCG; import org.overture.codegen.cgast.expressions.AFieldExpCG; -import org.overture.codegen.cgast.expressions.AMapGetExpCG; +import org.overture.codegen.cgast.expressions.AMapSeqGetExpCG; import org.overture.codegen.cgast.statements.AFieldStateDesignatorCG; import org.overture.codegen.cgast.statements.AIdentifierStateDesignatorCG; import org.overture.codegen.cgast.statements.AMapSeqStateDesignatorCG; @@ -62,18 +62,20 @@ public SExpCG caseAFieldStateDesignatorCG(AFieldStateDesignatorCG node) public SExpCG caseAMapSeqStateDesignatorCG(AMapSeqStateDesignatorCG node) throws AnalysisException { - SExpCG domValue = node.getExp(); - SExpCG mapSeq = node.getMapseq().apply(this); + // Reading a map or a sequence on the left hand + // side of an assignment, e.g. m(1).field := 5; + + SExpCG index = node.getExp(); + SExpCG col = node.getMapseq().apply(this); - AMapGetExpCG mapGet = new AMapGetExpCG(); - mapGet.setType(node.getType().clone()); - mapGet.setDomValue(domValue.clone()); - mapGet.setMap(mapSeq); - mapGet.setSourceNode(node.getSourceNode()); - mapGet.setTag(node.getTag()); + AMapSeqGetExpCG mapSeqGet = new AMapSeqGetExpCG(); + mapSeqGet.setType(node.getType().clone()); + mapSeqGet.setIndex(index.clone()); + mapSeqGet.setCol(col); + mapSeqGet.setSourceNode(node.getSourceNode()); + mapSeqGet.setTag(node.getTag()); - // e.g. ((Rec) m(true)).field := 2; - return mapGet; + return mapSeqGet; } @Override diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaValueSemantics.java b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaValueSemantics.java index 350235ea6e..dac110ccf9 100644 --- a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaValueSemantics.java +++ b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaValueSemantics.java @@ -43,7 +43,7 @@ import org.overture.codegen.cgast.expressions.AIndicesUnaryExpCG; import org.overture.codegen.cgast.expressions.AInstanceofExpCG; import org.overture.codegen.cgast.expressions.ALenUnaryExpCG; -import org.overture.codegen.cgast.expressions.AMapGetExpCG; +import org.overture.codegen.cgast.expressions.AMapSeqGetExpCG; import org.overture.codegen.cgast.expressions.ANewExpCG; import org.overture.codegen.cgast.expressions.ANotEqualsBinaryExpCG; import org.overture.codegen.cgast.expressions.ASetProperSubsetBinaryExpCG; @@ -52,7 +52,7 @@ import org.overture.codegen.cgast.expressions.ATupleSizeExpCG; import org.overture.codegen.cgast.statements.AAssignToExpStmCG; import org.overture.codegen.cgast.statements.AForAllStmCG; -import org.overture.codegen.cgast.statements.AMapPutStmCG; +import org.overture.codegen.cgast.statements.AMapSeqUpdateStmCG; import org.overture.codegen.cgast.types.AExternalTypeCG; import org.overture.codegen.cgast.types.AMethodTypeCG; import org.overture.codegen.cgast.types.ARecordTypeCG; @@ -229,21 +229,21 @@ private boolean cloneNotNeededMapPutGet(SExpCG exp) { INode parent = exp.parent(); - if(parent instanceof AMapPutStmCG) + if(parent instanceof AMapSeqUpdateStmCG) { - AMapPutStmCG mapPut = (AMapPutStmCG) parent; + AMapSeqUpdateStmCG mapSeqUpd = (AMapSeqUpdateStmCG) parent; - if(mapPut.getMap() == exp) + if(mapSeqUpd.getCol() == exp) { return true; } } - if(parent instanceof AMapGetExpCG) + if(parent instanceof AMapSeqGetExpCG) { - AMapGetExpCG mapGet = (AMapGetExpCG) parent; + AMapSeqGetExpCG mapSeqGet = (AMapSeqGetExpCG) parent; - if(mapGet.getMap() == exp) + if(mapSeqGet.getCol() == exp) { return true; } diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/MapGet.vm b/core/codegen/src/main/resources/JavaTemplates/Expressions/MapGet.vm deleted file mode 100644 index 2c046ae62f..0000000000 --- a/core/codegen/src/main/resources/JavaTemplates/Expressions/MapGet.vm +++ /dev/null @@ -1,5 +0,0 @@ -#set( $map = $JavaFormat.format($node.getMap()) ) -#set( $domValue = $JavaFormat.format($node.getDomValue()) ) -#set( $type = $JavaFormat.format($node.getType()) ) -## -((${type}) ${map}.get(${domValue})) \ No newline at end of file diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/MapSeqGet.vm b/core/codegen/src/main/resources/JavaTemplates/Expressions/MapSeqGet.vm new file mode 100644 index 0000000000..5e1d5de41a --- /dev/null +++ b/core/codegen/src/main/resources/JavaTemplates/Expressions/MapSeqGet.vm @@ -0,0 +1,5 @@ +#set( $col = $JavaFormat.format($node.getCol()) ) +#set( $index = $JavaFormat.format($node.getIndex()) ) +#set( $type = $JavaFormat.format($node.getType()) ) +## +((${type}) ${col}.get(${index})) \ No newline at end of file diff --git a/core/codegen/src/main/resources/JavaTemplates/Statements/MapPut.vm b/core/codegen/src/main/resources/JavaTemplates/Statements/MapPut.vm deleted file mode 100644 index 1d137ba335..0000000000 --- a/core/codegen/src/main/resources/JavaTemplates/Statements/MapPut.vm +++ /dev/null @@ -1,5 +0,0 @@ -#set( $map = $JavaFormat.format($node.getMap()) ) -#set( $domValue = $JavaFormat.format($node.getDomValue()) ) -#set( $rngValue = $JavaFormat.format($node.getRngValue()) ) -## -${map}.put(${domValue}, ${rngValue}); \ No newline at end of file diff --git a/core/codegen/src/main/resources/JavaTemplates/Statements/MapSeqUpdate.vm b/core/codegen/src/main/resources/JavaTemplates/Statements/MapSeqUpdate.vm new file mode 100644 index 0000000000..b18df116b7 --- /dev/null +++ b/core/codegen/src/main/resources/JavaTemplates/Statements/MapSeqUpdate.vm @@ -0,0 +1,5 @@ +#set( $col = $JavaFormat.format($node.getCol()) ) +#set( $index = $JavaFormat.format($node.getIndex()) ) +#set( $value = $JavaFormat.format($node.getValue()) ) +## +Utils.mapSeqUpdate(${col},${index},${value}); \ No newline at end of file diff --git a/core/codegen/src/main/resources/cg.astv2 b/core/codegen/src/main/resources/cg.astv2 index ae5e51a68c..4a45b89354 100644 --- a/core/codegen/src/main/resources/cg.astv2 +++ b/core/codegen/src/main/resources/cg.astv2 @@ -228,7 +228,7 @@ CG {-> package='org.overture.codegen.cgast' [type]:CG.#type [name]:java_String [args]:CG.#exp* - | {mapPut} [map]:CG.#exp [domValue]:CG.#exp [rngValue]:CG.#exp + | {mapSeqUpdate} [col]:CG.#exp [index]:CG.#exp [value]:CG.#exp ; #call {-> package='org.overture.codegen.cgast.statements' @@ -299,7 +299,7 @@ CG {-> package='org.overture.codegen.cgast' | {history}[histype]:java_String [opsname]:java_String [sentinelType]:CG.#type.class | {time} | {assignExp} [target]:CG.#exp [value]:CG.#exp - | {mapGet} [map]:CG.#exp [domValue]:CG.#exp + | {mapSeqGet} [col]:CG.#exp [index]:CG.#exp ; #modifier {-> package='org.overture.codegen.cgast.expressions'} diff --git a/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorInstanceVar b/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorInstanceVar deleted file mode 100644 index bf843b74ad..0000000000 --- a/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorInstanceVar +++ /dev/null @@ -1,16 +0,0 @@ -class Entry - -instance variables - -static x : map nat to bool := {1 |-> true}; - -operations - -public static Run : () ==> ? -Run () == -( - x(4) := false; - return x; -) - -end Entry \ No newline at end of file diff --git a/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorInstanceVar.result b/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorInstanceVar.result deleted file mode 100644 index 02bfea7017..0000000000 --- a/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorInstanceVar.result +++ /dev/null @@ -1,23 +0,0 @@ -import org.overture.codegen.runtime.*; - -import java.util.*; - - -public class Entry { - private static VDMMap x = MapUtil.map(new Maplet(1L, true)); - - public Entry() { - } - - public static Object Run() { - x.put(4L, false); - - return Utils.clone(x); - } - - public String toString() { - return "Entry{" + "x := " + Utils.toString(x) + "}"; - } -} - -########## From 6053aab683faa6ced76005b2ad7c0b44d3d9452a Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 4 Mar 2015 20:16:20 +0100 Subject: [PATCH 211/323] Added codegen runtime library support for updating sequences and maps --- .../org/overture/codegen/runtime/Utils.java | 32 +++++++++++++++++-- 1 file changed, 29 insertions(+), 3 deletions(-) diff --git a/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/Utils.java b/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/Utils.java index e2e9e5ca69..6e770eab35 100644 --- a/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/Utils.java +++ b/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/Utils.java @@ -41,12 +41,38 @@ public static int hashCode(Object... fields) return hashcode; } - public static int index(Number value) + @SuppressWarnings("unchecked") + public static void mapSeqUpdate(Object col, Object index, Object value) { - if(value.longValue() < 1) + if(col instanceof VDMSeq) + { + VDMSeq seq = (VDMSeq) col; + seq.set(index(index), value); + } + else if(col instanceof VDMMap) + { + VDMMap map = (VDMMap) col; + map.put(index, value); + } + else + { + throw new IllegalArgumentException("Only a map or a sequence can be updated"); + } + } + + public static int index(Object value) + { + if(!(value instanceof Number)) + { + throw new IllegalArgumentException("The value to be converted must be a java.lang.Number"); + } + + Number numberValue = (Number) value; + + if(numberValue.longValue() < 1) throw new IllegalArgumentException("VDM subscripts must be >= 1"); - return toInt(value) - 1; + return toInt(numberValue) - 1; } public static int toInt(Number value) { From 71a3349bd193cb79203b772329b9d808b27f9763 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 4 Mar 2015 20:29:10 +0100 Subject: [PATCH 212/323] Additional updates to test results related to code generation of state designators --- .../src/test/resources/classic_specs/AlarmTraces.result | 2 +- .../src/test/resources/classic_specs/CashDispenserPP.result | 4 ++-- .../src/test/resources/cloning_specs/AlarmTraces.result | 2 +- .../src/test/resources/cloning_specs/CashDispenserPP.result | 4 ++-- .../concurrency_classics_specs/POP3_LogBased_Test1.result | 2 +- 5 files changed, 7 insertions(+), 7 deletions(-) diff --git a/core/codegen/src/test/resources/classic_specs/AlarmTraces.result b/core/codegen/src/test/resources/classic_specs/AlarmTraces.result index 6770136e9a..fc0b18b50a 100644 --- a/core/codegen/src/test/resources/classic_specs/AlarmTraces.result +++ b/core/codegen/src/test/resources/classic_specs/AlarmTraces.result @@ -128,7 +128,7 @@ public class Plant { ternaryIfExp_1 = SetUtil.set(ex); } - schedule.put(p, Utils.clone(ternaryIfExp_1)); + Utils.mapSeqUpdate(schedule, p, Utils.clone(ternaryIfExp_1)); } public void RemoveExpertFromSchedule(final Token p, final Expert ex) { diff --git a/core/codegen/src/test/resources/classic_specs/CashDispenserPP.result b/core/codegen/src/test/resources/classic_specs/CashDispenserPP.result index 678c85d2a6..3da9bb3992 100644 --- a/core/codegen/src/test/resources/classic_specs/CashDispenserPP.result +++ b/core/codegen/src/test/resources/classic_specs/CashDispenserPP.result @@ -399,11 +399,11 @@ public class CentralResource { } public void ResetNumberOfTries(final Number cardId) { - numberOfTries.put(cardId, 0L); + Utils.mapSeqUpdate(numberOfTries, cardId, 0L); } public void IncrNumberOfTries(final Number cardId) { - numberOfTries.put(cardId, + Utils.mapSeqUpdate(numberOfTries, cardId, ((Number) MapUtil.get(numberOfTries, cardId)).longValue() + 1L); } diff --git a/core/codegen/src/test/resources/cloning_specs/AlarmTraces.result b/core/codegen/src/test/resources/cloning_specs/AlarmTraces.result index 568fb5eab5..7610c41f03 100644 --- a/core/codegen/src/test/resources/cloning_specs/AlarmTraces.result +++ b/core/codegen/src/test/resources/cloning_specs/AlarmTraces.result @@ -127,7 +127,7 @@ public class Plant { ternaryIfExp_1 = SetUtil.set(ex); } - schedule.put(p, ternaryIfExp_1); + Utils.mapSeqUpdate(schedule, p, ternaryIfExp_1); } public void RemoveExpertFromSchedule(final Token p, final Expert ex) { diff --git a/core/codegen/src/test/resources/cloning_specs/CashDispenserPP.result b/core/codegen/src/test/resources/cloning_specs/CashDispenserPP.result index 45306dc236..a875c9a884 100644 --- a/core/codegen/src/test/resources/cloning_specs/CashDispenserPP.result +++ b/core/codegen/src/test/resources/cloning_specs/CashDispenserPP.result @@ -394,11 +394,11 @@ public class CentralResource { } public void ResetNumberOfTries(final Number cardId) { - numberOfTries.put(cardId, 0L); + Utils.mapSeqUpdate(numberOfTries, cardId, 0L); } public void IncrNumberOfTries(final Number cardId) { - numberOfTries.put(cardId, + Utils.mapSeqUpdate(numberOfTries, cardId, ((Number) MapUtil.get(numberOfTries, cardId)).longValue() + 1L); } diff --git a/core/codegen/src/test/resources/concurrency_classics_specs/POP3_LogBased_Test1.result b/core/codegen/src/test/resources/concurrency_classics_specs/POP3_LogBased_Test1.result index 3421c13be2..b7bfb3e02c 100644 --- a/core/codegen/src/test/resources/concurrency_classics_specs/POP3_LogBased_Test1.result +++ b/core/codegen/src/test/resources/concurrency_classics_specs/POP3_LogBased_Test1.result @@ -1545,7 +1545,7 @@ public class POP3Server extends VDMThread implements EvaluatePP { recModifierExp_1.msgs = Utils.clone(newMsgs); sentinel.stateChanged(); - maildrop.put(user, Utils.clone(recModifierExp_1)); + Utils.mapSeqUpdate(maildrop, user, Utils.clone(recModifierExp_1)); sentinel.stateChanged(); } finally { sentinel.leaving(((POP3Server_sentinel) sentinel).SetUserMessages); From 8418cfca779a4b8e0a4245531ff678d4bc354f73 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 4 Mar 2015 21:05:00 +0100 Subject: [PATCH 213/323] Updates to test result related to code generation of reading of maps (state designators) --- .../MapSeqStateDesignatorChangeRecField.result | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorChangeRecField.result b/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorChangeRecField.result index 9d89860edb..959ca7cc56 100644 --- a/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorChangeRecField.result +++ b/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorChangeRecField.result @@ -10,7 +10,7 @@ public class Entry { } public void modify() { - ((Rec) m.get(true)).field = 20L; + ((Rec) Utils.get(m, true)).field = 20L; } public Number read() { From c4608c9dd68816aa4783e2dbb2de8fb4f2252548 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 4 Mar 2015 21:07:26 +0100 Subject: [PATCH 214/323] Added two tests exercising code generation of complicated use of state designators (both maps and sequences) --- .../MapSeqStateDesignatorMapSeqToSeq | 18 ++++++++++ .../MapSeqStateDesignatorMapSeqToSeq.result | 31 +++++++++++++++++ .../MapSeqStateDesignatorSeqInSeqInSeq | 18 ++++++++++ .../MapSeqStateDesignatorSeqInSeqInSeq.result | 33 +++++++++++++++++++ 4 files changed, 100 insertions(+) create mode 100644 core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapSeqToSeq create mode 100644 core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapSeqToSeq.result create mode 100644 core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorSeqInSeqInSeq create mode 100644 core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorSeqInSeqInSeq.result diff --git a/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapSeqToSeq b/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapSeqToSeq new file mode 100644 index 0000000000..ff8a19720e --- /dev/null +++ b/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapSeqToSeq @@ -0,0 +1,18 @@ +class Entry + +operations + +public static Run : () ==> ? +Run () == +( + dcl xs : map (seq of char) to (seq of char) := {['a'] |-> ['b'], ['c'] |-> ['d']}; + + xs(['a'])(1) := 'x'; + + if xs(['a'])(1) = 'x' then + return xs(['c'])(1) + else + return xs(['a'])(1); +); + +end Entry \ No newline at end of file diff --git a/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapSeqToSeq.result b/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapSeqToSeq.result new file mode 100644 index 0000000000..e7039fdf39 --- /dev/null +++ b/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapSeqToSeq.result @@ -0,0 +1,31 @@ +import org.overture.codegen.runtime.*; + +import java.util.*; + + +public class Entry { + public Entry() { + } + + public static Object Run() { + VDMMap xs = MapUtil.map(new Maplet(SeqUtil.seq('a'), SeqUtil.seq('b')), + new Maplet(SeqUtil.seq('c'), SeqUtil.seq('d'))); + Utils.mapSeqUpdate(((VDMSeq) Utils.get(xs, SeqUtil.seq('a'))), 1L, 'x'); + + if (Utils.equals( + ((Character) ((VDMSeq) MapUtil.get(xs, SeqUtil.seq('a'))).get( + Utils.index(1L))), 'x')) { + return ((Character) ((VDMSeq) MapUtil.get(xs, SeqUtil.seq('c'))).get(Utils.index( + 1L))); + } else { + return ((Character) ((VDMSeq) MapUtil.get(xs, SeqUtil.seq('a'))).get(Utils.index( + 1L))); + } + } + + public String toString() { + return "Entry{}"; + } +} + +########## diff --git a/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorSeqInSeqInSeq b/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorSeqInSeqInSeq new file mode 100644 index 0000000000..10f508afa3 --- /dev/null +++ b/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorSeqInSeqInSeq @@ -0,0 +1,18 @@ +class Entry + +operations + +public static Run : () ==> ? +Run () == +( + dcl xs : seq of seq of seq of char := [[['a', 'b'],['c','d']], [['e', 'f'], ['g', 'h']]]; + + xs(2)(1)(1) := 'x'; + + if xs(2)(1)(1) = 'x' then + return xs(2)(2)(2) + else + return xs(1)(2)(1); +); + +end Entry \ No newline at end of file diff --git a/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorSeqInSeqInSeq.result b/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorSeqInSeqInSeq.result new file mode 100644 index 0000000000..17d3a025bd --- /dev/null +++ b/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorSeqInSeqInSeq.result @@ -0,0 +1,33 @@ +import org.overture.codegen.runtime.*; + +import java.util.*; + + +public class Entry { + public Entry() { + } + + public static Object Run() { + VDMSeq xs = SeqUtil.seq(SeqUtil.seq(SeqUtil.seq('a', 'b'), + SeqUtil.seq('c', 'd')), + SeqUtil.seq(SeqUtil.seq('e', 'f'), SeqUtil.seq('g', 'h'))); + Utils.mapSeqUpdate(((VDMSeq) Utils.get(((VDMSeq) Utils.get(xs, 2L)), 1L)), + 1L, 'x'); + + if (Utils.equals( + ((Character) ((VDMSeq) ((VDMSeq) xs.get(Utils.index(2L))).get( + Utils.index(1L))).get(Utils.index(1L))), 'x')) { + return ((Character) ((VDMSeq) ((VDMSeq) xs.get(Utils.index(2L))).get(Utils.index( + 2L))).get(Utils.index(2L))); + } else { + return ((Character) ((VDMSeq) ((VDMSeq) xs.get(Utils.index(1L))).get(Utils.index( + 2L))).get(Utils.index(1L))); + } + } + + public String toString() { + return "Entry{}"; + } +} + +########## From 04e2362e0e2292273c6b35d36823f48992e7e41c Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 4 Mar 2015 21:08:41 +0100 Subject: [PATCH 215/323] Fix for code generation of reading of maps and sequences --- .../org/overture/codegen/runtime/Utils.java | 18 ++++++++++++++++++ .../JavaTemplates/Expressions/MapSeqGet.vm | 2 +- 2 files changed, 19 insertions(+), 1 deletion(-) diff --git a/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/Utils.java b/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/Utils.java index 6e770eab35..e7b8bc207e 100644 --- a/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/Utils.java +++ b/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/Utils.java @@ -41,6 +41,24 @@ public static int hashCode(Object... fields) return hashcode; } + public static Object get(Object col, Object index) + { + if(col instanceof VDMSeq) + { + VDMSeq seq = (VDMSeq) col; + return seq.get(Utils.index(index)); + } + else if(col instanceof VDMMap) + { + VDMMap map = (VDMMap) col; + return map.get(index); + } + else + { + throw new IllegalArgumentException("Only a map or a sequence can be read"); + } + } + @SuppressWarnings("unchecked") public static void mapSeqUpdate(Object col, Object index, Object value) { diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/MapSeqGet.vm b/core/codegen/src/main/resources/JavaTemplates/Expressions/MapSeqGet.vm index 5e1d5de41a..50e36323f0 100644 --- a/core/codegen/src/main/resources/JavaTemplates/Expressions/MapSeqGet.vm +++ b/core/codegen/src/main/resources/JavaTemplates/Expressions/MapSeqGet.vm @@ -2,4 +2,4 @@ #set( $index = $JavaFormat.format($node.getIndex()) ) #set( $type = $JavaFormat.format($node.getType()) ) ## -((${type}) ${col}.get(${index})) \ No newline at end of file +((${type}) Utils.get(${col},${index})) \ No newline at end of file From ea29a4dc6d0291e3d24ca5912cc5cf3db08a9465 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 4 Mar 2015 21:19:47 +0100 Subject: [PATCH 216/323] Added a test to exercise code generation of complicated use of map sequence state designators --- .../MapSeqStateDesignatorMapInMap | 18 ++++++++++ .../MapSeqStateDesignatorMapInMap.result | 35 +++++++++++++++++++ 2 files changed, 53 insertions(+) create mode 100644 core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapInMap create mode 100644 core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapInMap.result diff --git a/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapInMap b/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapInMap new file mode 100644 index 0000000000..a23acff6ed --- /dev/null +++ b/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapInMap @@ -0,0 +1,18 @@ +class Entry + +operations + +public static Run : () ==> ? +Run () == +( + dcl xs : map (map nat to nat) to (map char to char) := {{1 |-> 2} |-> {'a' |-> 'b'}, {3 |-> 4} |-> {'c' |-> 'd'}}; + + xs({3 |-> 4})('c') := 'x'; + + if xs({3 |-> 4})('c') = 'x' then + return xs({1 |-> 2})('a') + else + return xs({3 |-> 4})('c'); +); + +end Entry \ No newline at end of file diff --git a/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapInMap.result b/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapInMap.result new file mode 100644 index 0000000000..0c66704648 --- /dev/null +++ b/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapInMap.result @@ -0,0 +1,35 @@ +import org.overture.codegen.runtime.*; + +import java.util.*; + + +public class Entry { + public Entry() { + } + + public static Object Run() { + VDMMap xs = MapUtil.map(new Maplet(MapUtil.map(new Maplet(1L, 2L)), + MapUtil.map(new Maplet('a', 'b'))), + new Maplet(MapUtil.map(new Maplet(3L, 4L)), + MapUtil.map(new Maplet('c', 'd')))); + Utils.mapSeqUpdate(((VDMMap) Utils.get(xs, + MapUtil.map(new Maplet(3L, 4L)))), 'c', 'x'); + + if (Utils.equals( + ((Character) MapUtil.get( + ((VDMMap) MapUtil.get(xs, + MapUtil.map(new Maplet(3L, 4L)))), 'c')), 'x')) { + return ((Character) MapUtil.get(((VDMMap) MapUtil.get(xs, + MapUtil.map(new Maplet(1L, 2L)))), 'a')); + } else { + return ((Character) MapUtil.get(((VDMMap) MapUtil.get(xs, + MapUtil.map(new Maplet(3L, 4L)))), 'c')); + } + } + + public String toString() { + return "Entry{}"; + } +} + +########## From 8808c11ba9e4a97fe99cff683a39f20c07c6f482 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 4 Mar 2015 21:46:32 +0100 Subject: [PATCH 217/323] Updated the template used by the apply expression. This template now uses the same codegen runtime method to loop up values in maps and sequences as done for state designators --- .../classic_specs/AlarmTraces.result | 14 ++--- .../classic_specs/CashDispenserPP.result | 35 ++++++----- .../cloning_specs/AlarmTraces.result | 14 ++--- .../cloning_specs/CashDispenserPP.result | 35 ++++++----- .../ApplyObjectDesignatorClone.result | 4 +- .../ApplyObjectDesignatorMapLookup.result | 2 +- .../ApplyObjectDesignatorMapType.result | 16 ++--- ...plyObjectDesignatorWithRecFieldObj1.result | 2 +- ...plyObjectDesignatorWithRecFieldObj2.result | 2 +- ...MapSeqStateDesignatorChangeRecField.result | 2 +- .../MapSeqStateDesignatorMapInMap.result | 10 ++-- .../MapSeqStateDesignatorMapSeqToSeq.result | 12 ++-- .../MapSeqStateDesignatorSeqInSeqInSeq.result | 13 ++-- .../MapSeqStateDesignatorSeqUpdate.result | 2 +- .../RecordUsageAcrossClass.result | 2 +- .../RecursiveNamedTypeMapApply.result | 2 +- .../POP3_LogBased_Test1.result | 60 +++++++++---------- .../expressions/ApplyExpSeqEnum.result | 2 +- .../expressions/ApplyExpString.result | 2 +- .../Maps/MapApplyMapEnumExp.result | 2 +- .../expressions/Sequences/SeqIndexExp.result | 2 +- .../Sequences/SeqIndexValueTypeExp.result | 2 +- .../ApplyExpReturnedString.result | 2 +- .../specifications/MapApplyClone.result | 2 +- .../specifications/MapPhoneBook.result | 4 +- .../specifications/SeqNoteBook.result | 4 +- .../ApplyExpInElseIfStm.result | 2 +- .../ApplyExpMissingMapInOneClass.result | 2 +- .../ApplyExpMissingSeqInOneClass.result | 2 +- .../ApplyExpMissingSeqOfCharInOneClass.result | 2 +- .../union_type_specs/ApplyExpNested.result | 2 +- .../CallObjStmWithArguments.result | 2 +- .../FieldExpArgToOpCall.result | 2 +- .../FieldExpInReturnStm.result | 2 +- .../FieldExpMissingRecField.result | 4 +- .../FieldExpNotRootOfApplyExp.result | 2 +- .../union_type_specs/FieldExpOfRecord.result | 2 +- .../union_type_specs/FieldExpSeqApply.result | 2 +- .../FieldExpWithObjectAsApplyExp.result | 4 +- .../FieldNumberExpArgToApplyExp.result | 2 +- .../FieldNumberExpDifferentFieldTyps.result | 2 +- .../FieldNumberExpUnknownType.result | 2 +- .../union_type_specs/MapApply.result | 4 +- .../union_type_specs/SeqApply.result | 3 +- .../UnknownTypeInUnionType.result | 4 +- 45 files changed, 145 insertions(+), 151 deletions(-) diff --git a/core/codegen/src/test/resources/classic_specs/AlarmTraces.result b/core/codegen/src/test/resources/classic_specs/AlarmTraces.result index fc0b18b50a..50fa89b74e 100644 --- a/core/codegen/src/test/resources/classic_specs/AlarmTraces.result +++ b/core/codegen/src/test/resources/classic_specs/AlarmTraces.result @@ -78,7 +78,7 @@ public class Plant { public Expert ExpertToPage(final Alarm a, final Token p) { Expert expert = null; Boolean success_1 = false; - VDMSet set_1 = Utils.clone(((VDMSet) MapUtil.get(schedule, p))); + VDMSet set_1 = Utils.clone(((VDMSet) Utils.get(schedule, p))); for (Iterator iterator_1 = set_1.iterator(); iterator_1.hasNext() && !(success_1);) { @@ -94,7 +94,7 @@ public class Plant { } public Number NumberOfExperts(final Token p) { - return ((VDMSet) MapUtil.get(schedule, p)).size(); + return ((VDMSet) Utils.get(schedule, p)).size(); } public VDMSet ExpertIsOnDuty(final Expert ex) { @@ -104,7 +104,7 @@ public class Plant { for (Iterator iterator_2 = set_2.iterator(); iterator_2.hasNext();) { Token p = ((Token) iterator_2.next()); - if (((VDMSet) MapUtil.get(schedule, p)).contains(ex)) { + if (((VDMSet) Utils.get(schedule, p)).contains(ex)) { setCompResult_1 = SetUtil.union(Utils.clone(setCompResult_1), SetUtil.set(p)); } @@ -123,7 +123,7 @@ public class Plant { if (MapUtil.dom(Utils.clone(schedule)).contains(p)) { ternaryIfExp_1 = SetUtil.union(Utils.clone( - ((VDMSet) MapUtil.get(schedule, p))), SetUtil.set(ex)); + ((VDMSet) Utils.get(schedule, p))), SetUtil.set(ex)); } else { ternaryIfExp_1 = SetUtil.set(ex); } @@ -132,7 +132,7 @@ public class Plant { } public void RemoveExpertFromSchedule(final Token p, final Expert ex) { - VDMSet exs = Utils.clone(((VDMSet) MapUtil.get(schedule, p))); + VDMSet exs = Utils.clone(((VDMSet) Utils.get(schedule, p))); VDMMap ternaryIfExp_2 = null; @@ -158,7 +158,7 @@ public class Plant { for (Iterator iterator_3 = set_3.iterator(); iterator_3.hasNext() && forAllExpResult_1;) { Token p = ((Token) iterator_3.next()); - forAllExpResult_1 = !(((VDMSet) MapUtil.get(sch, p)).isEmpty()); + forAllExpResult_1 = !(((VDMSet) Utils.get(sch, p)).isEmpty()); } if (forAllExpResult_1) { @@ -175,7 +175,7 @@ public class Plant { iterator_5.hasNext() && forAllExpResult_3;) { Token p = ((Token) iterator_5.next()); Boolean existsExpResult_1 = false; - VDMSet set_6 = Utils.clone(((VDMSet) MapUtil.get(sch, p))); + VDMSet set_6 = Utils.clone(((VDMSet) Utils.get(sch, p))); for (Iterator iterator_6 = set_6.iterator(); iterator_6.hasNext() && !(existsExpResult_1);) { diff --git a/core/codegen/src/test/resources/classic_specs/CashDispenserPP.result b/core/codegen/src/test/resources/classic_specs/CashDispenserPP.result index 3da9bb3992..6b7ad9c186 100644 --- a/core/codegen/src/test/resources/classic_specs/CashDispenserPP.result +++ b/core/codegen/src/test/resources/classic_specs/CashDispenserPP.result @@ -49,11 +49,11 @@ public class SimpleTest { Number pglid1 = 1L; resource.AddAccount(pglid1, pglacc1); resource.AddLetterbox(clock, new Letterbox()); - ((Till) MapUtil.get(tills, 1L)).InsertCard(c1); + ((Till) Utils.get(tills, 1L)).InsertCard(c1); - if (Utils.equals(((Till) MapUtil.get(tills, 1L)).Validate( - 123456L), quotes.PinOk.getInstance())) { - return ((Till) MapUtil.get(tills, 1L)).MakeWithdrawal(800L); + if (Utils.equals(((Till) Utils.get(tills, 1L)).Validate(123456L), + quotes.PinOk.getInstance())) { + return ((Till) Utils.get(tills, 1L)).MakeWithdrawal(800L); } else { return false; } @@ -125,8 +125,8 @@ public class Account { } public Letter MakeStatement(final Number cardId, final VDMSeq date) { - VDMSeq nm = ((Cardholder) MapUtil.get(cards, cardId)).GetName(); - VDMSeq addr = ((Cardholder) MapUtil.get(cards, cardId)).GetAddress(); + VDMSeq nm = ((Cardholder) Utils.get(cards, cardId)).GetName(); + VDMSeq addr = ((Cardholder) Utils.get(cards, cardId)).GetAddress(); { Letter letter = new Letter(); @@ -158,7 +158,7 @@ public class Account { Number i = ((Number) iterator_2.next()); setCompResult_1 = SetUtil.union(Utils.clone(setCompResult_1), SetUtil.set(Utils.clone( - ((Transaction) ts.get(Utils.index(i))).date))); + ((Transaction) Utils.get(ts, i)).date))); } VDMSet set_1 = Utils.clone(setCompResult_1); @@ -180,10 +180,9 @@ public class Account { for (Iterator iterator_3 = set_3.iterator(); iterator_3.hasNext();) { Number i = ((Number) iterator_3.next()); - if (Utils.equals(((Transaction) ts.get(Utils.index(i))).date, date)) { + if (Utils.equals(((Transaction) Utils.get(ts, i)).date, date)) { seqCompResult_1 = SeqUtil.conc(Utils.clone(seqCompResult_1), - SeqUtil.seq( - ((Transaction) ts.get(Utils.index(i))).amount)); + SeqUtil.seq(((Transaction) Utils.get(ts, i)).amount)); } } @@ -346,7 +345,7 @@ public class CentralResource { public Number GetBalance(final Number accountId) { if (MapUtil.dom(Utils.clone(accounts)).contains(accountId)) { - return ((Account) MapUtil.get(accounts, accountId)).GetBalance(); + return ((Account) Utils.get(accounts, accountId)).GetBalance(); } else { return null; } @@ -355,7 +354,7 @@ public class CentralResource { public Boolean Withdrawal(final Number accountId, final Number cardId, final Number amount) { if (IsLegalCard(accountId, cardId)) { - return ((Account) MapUtil.get(accounts, accountId)).Withdrawal(cardId, + return ((Account) Utils.get(accounts, accountId)).Withdrawal(cardId, amount, clock.GetDate()); } else { return false; @@ -364,7 +363,7 @@ public class CentralResource { public Boolean PostStatement(final Number accountId, final Number cardId) { if (IsLegalCard(accountId, cardId)) { - letterbox.PostStatement(((Account) MapUtil.get(accounts, accountId)).MakeStatement( + letterbox.PostStatement(((Account) Utils.get(accounts, accountId)).MakeStatement( cardId, clock.GetDate())); return true; @@ -380,7 +379,7 @@ public class CentralResource { Boolean andResult_3 = false; if (MapUtil.dom(Utils.clone(accounts)).contains(accountId)) { - if (((Account) MapUtil.get(accounts, accountId)).GetCardIds() + if (((Account) Utils.get(accounts, accountId)).GetCardIds() .contains(cardId)) { andResult_3 = true; } @@ -395,7 +394,7 @@ public class CentralResource { } public Boolean NumberOfTriesExceeded(final Number cardId) { - return ((Number) MapUtil.get(numberOfTries, cardId)).longValue() >= maxNumberOfTries.longValue(); + return ((Number) Utils.get(numberOfTries, cardId)).longValue() >= maxNumberOfTries.longValue(); } public void ResetNumberOfTries(final Number cardId) { @@ -404,7 +403,7 @@ public class CentralResource { public void IncrNumberOfTries(final Number cardId) { Utils.mapSeqUpdate(numberOfTries, cardId, - ((Number) MapUtil.get(numberOfTries, cardId)).longValue() + 1L); + ((Number) Utils.get(numberOfTries, cardId)).longValue() + 1L); } public void AddAccount(final Number accId, final Account acc) { @@ -515,7 +514,7 @@ public class Letterbox { } public Letter GetLastStatement() { - return ((Letter) statements.get(Utils.index(statements.size()))); + return ((Letter) Utils.get(statements, statements.size())); } public String toString() { @@ -855,7 +854,7 @@ public class System { } public Till GetTill(final Number tid) { - return ((Till) MapUtil.get(tills, tid)); + return ((Till) Utils.get(tills, tid)); } public CentralResource GetResource() { diff --git a/core/codegen/src/test/resources/cloning_specs/AlarmTraces.result b/core/codegen/src/test/resources/cloning_specs/AlarmTraces.result index 7610c41f03..16940c9b4b 100644 --- a/core/codegen/src/test/resources/cloning_specs/AlarmTraces.result +++ b/core/codegen/src/test/resources/cloning_specs/AlarmTraces.result @@ -78,7 +78,7 @@ public class Plant { public Expert ExpertToPage(final Alarm a, final Token p) { Expert expert = null; Boolean success_1 = false; - VDMSet set_1 = ((VDMSet) MapUtil.get(schedule, p)); + VDMSet set_1 = ((VDMSet) Utils.get(schedule, p)); for (Iterator iterator_1 = set_1.iterator(); iterator_1.hasNext() && !(success_1);) { @@ -94,7 +94,7 @@ public class Plant { } public Number NumberOfExperts(final Token p) { - return ((VDMSet) MapUtil.get(schedule, p)).size(); + return ((VDMSet) Utils.get(schedule, p)).size(); } public VDMSet ExpertIsOnDuty(final Expert ex) { @@ -104,7 +104,7 @@ public class Plant { for (Iterator iterator_2 = set_2.iterator(); iterator_2.hasNext();) { Token p = ((Token) iterator_2.next()); - if (((VDMSet) MapUtil.get(schedule, p)).contains(ex)) { + if (((VDMSet) Utils.get(schedule, p)).contains(ex)) { setCompResult_1 = SetUtil.union(setCompResult_1, SetUtil.set(p)); } } @@ -121,7 +121,7 @@ public class Plant { VDMSet ternaryIfExp_1 = null; if (MapUtil.dom(schedule).contains(p)) { - ternaryIfExp_1 = SetUtil.union(((VDMSet) MapUtil.get(schedule, p)), + ternaryIfExp_1 = SetUtil.union(((VDMSet) Utils.get(schedule, p)), SetUtil.set(ex)); } else { ternaryIfExp_1 = SetUtil.set(ex); @@ -131,7 +131,7 @@ public class Plant { } public void RemoveExpertFromSchedule(final Token p, final Expert ex) { - VDMSet exs = ((VDMSet) MapUtil.get(schedule, p)); + VDMSet exs = ((VDMSet) Utils.get(schedule, p)); VDMMap ternaryIfExp_2 = null; @@ -155,7 +155,7 @@ public class Plant { for (Iterator iterator_3 = set_3.iterator(); iterator_3.hasNext() && forAllExpResult_1;) { Token p = ((Token) iterator_3.next()); - forAllExpResult_1 = !(((VDMSet) MapUtil.get(sch, p)).isEmpty()); + forAllExpResult_1 = !(((VDMSet) Utils.get(sch, p)).isEmpty()); } if (forAllExpResult_1) { @@ -172,7 +172,7 @@ public class Plant { iterator_5.hasNext() && forAllExpResult_3;) { Token p = ((Token) iterator_5.next()); Boolean existsExpResult_1 = false; - VDMSet set_6 = ((VDMSet) MapUtil.get(sch, p)); + VDMSet set_6 = ((VDMSet) Utils.get(sch, p)); for (Iterator iterator_6 = set_6.iterator(); iterator_6.hasNext() && !(existsExpResult_1);) { diff --git a/core/codegen/src/test/resources/cloning_specs/CashDispenserPP.result b/core/codegen/src/test/resources/cloning_specs/CashDispenserPP.result index a875c9a884..cfea080428 100644 --- a/core/codegen/src/test/resources/cloning_specs/CashDispenserPP.result +++ b/core/codegen/src/test/resources/cloning_specs/CashDispenserPP.result @@ -49,11 +49,11 @@ public class SimpleTest { Number pglid1 = 1L; resource.AddAccount(pglid1, pglacc1); resource.AddLetterbox(clock, new Letterbox()); - ((Till) MapUtil.get(tills, 1L)).InsertCard(c1); + ((Till) Utils.get(tills, 1L)).InsertCard(c1); - if (Utils.equals(((Till) MapUtil.get(tills, 1L)).Validate( - 123456L), quotes.PinOk.getInstance())) { - return ((Till) MapUtil.get(tills, 1L)).MakeWithdrawal(800L); + if (Utils.equals(((Till) Utils.get(tills, 1L)).Validate(123456L), + quotes.PinOk.getInstance())) { + return ((Till) Utils.get(tills, 1L)).MakeWithdrawal(800L); } else { return false; } @@ -124,8 +124,8 @@ public class Account { } public Letter MakeStatement(final Number cardId, final VDMSeq date) { - VDMSeq nm = ((Cardholder) MapUtil.get(cards, cardId)).GetName(); - VDMSeq addr = ((Cardholder) MapUtil.get(cards, cardId)).GetAddress(); + VDMSeq nm = ((Cardholder) Utils.get(cards, cardId)).GetName(); + VDMSeq addr = ((Cardholder) Utils.get(cards, cardId)).GetAddress(); { Letter letter = new Letter(); @@ -154,7 +154,7 @@ public class Account { for (Iterator iterator_2 = set_2.iterator(); iterator_2.hasNext();) { Number i = ((Number) iterator_2.next()); setCompResult_1 = SetUtil.union(setCompResult_1, - SetUtil.set(((Transaction) ts.get(Utils.index(i))).date)); + SetUtil.set(((Transaction) Utils.get(ts, i)).date)); } VDMSet set_1 = setCompResult_1; @@ -175,10 +175,9 @@ public class Account { for (Iterator iterator_3 = set_3.iterator(); iterator_3.hasNext();) { Number i = ((Number) iterator_3.next()); - if (Utils.equals(((Transaction) ts.get(Utils.index(i))).date, date)) { + if (Utils.equals(((Transaction) Utils.get(ts, i)).date, date)) { seqCompResult_1 = SeqUtil.conc(seqCompResult_1, - SeqUtil.seq( - ((Transaction) ts.get(Utils.index(i))).amount)); + SeqUtil.seq(((Transaction) Utils.get(ts, i)).amount)); } } @@ -341,7 +340,7 @@ public class CentralResource { public Number GetBalance(final Number accountId) { if (MapUtil.dom(accounts).contains(accountId)) { - return ((Account) MapUtil.get(accounts, accountId)).GetBalance(); + return ((Account) Utils.get(accounts, accountId)).GetBalance(); } else { return null; } @@ -350,7 +349,7 @@ public class CentralResource { public Boolean Withdrawal(final Number accountId, final Number cardId, final Number amount) { if (IsLegalCard(accountId, cardId)) { - return ((Account) MapUtil.get(accounts, accountId)).Withdrawal(cardId, + return ((Account) Utils.get(accounts, accountId)).Withdrawal(cardId, amount, clock.GetDate()); } else { return false; @@ -359,7 +358,7 @@ public class CentralResource { public Boolean PostStatement(final Number accountId, final Number cardId) { if (IsLegalCard(accountId, cardId)) { - letterbox.PostStatement(((Account) MapUtil.get(accounts, accountId)).MakeStatement( + letterbox.PostStatement(((Account) Utils.get(accounts, accountId)).MakeStatement( cardId, clock.GetDate())); return true; @@ -375,7 +374,7 @@ public class CentralResource { Boolean andResult_3 = false; if (MapUtil.dom(accounts).contains(accountId)) { - if (((Account) MapUtil.get(accounts, accountId)).GetCardIds() + if (((Account) Utils.get(accounts, accountId)).GetCardIds() .contains(cardId)) { andResult_3 = true; } @@ -390,7 +389,7 @@ public class CentralResource { } public Boolean NumberOfTriesExceeded(final Number cardId) { - return ((Number) MapUtil.get(numberOfTries, cardId)).longValue() >= maxNumberOfTries.longValue(); + return ((Number) Utils.get(numberOfTries, cardId)).longValue() >= maxNumberOfTries.longValue(); } public void ResetNumberOfTries(final Number cardId) { @@ -399,7 +398,7 @@ public class CentralResource { public void IncrNumberOfTries(final Number cardId) { Utils.mapSeqUpdate(numberOfTries, cardId, - ((Number) MapUtil.get(numberOfTries, cardId)).longValue() + 1L); + ((Number) Utils.get(numberOfTries, cardId)).longValue() + 1L); } public void AddAccount(final Number accId, final Account acc) { @@ -509,7 +508,7 @@ public class Letterbox { } public Letter GetLastStatement() { - return ((Letter) statements.get(Utils.index(statements.size()))); + return ((Letter) Utils.get(statements, statements.size())); } public String toString() { @@ -849,7 +848,7 @@ public class System { } public Till GetTill(final Number tid) { - return ((Till) MapUtil.get(tills, tid)); + return ((Till) Utils.get(tills, tid)); } public CentralResource GetResource() { diff --git a/core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorClone.result b/core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorClone.result index af5c0856c2..0d3cc75e0a 100644 --- a/core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorClone.result +++ b/core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorClone.result @@ -17,14 +17,14 @@ public class A { public Number op1() { Tuple a = Tuple.mk_(1L, 2L); - return ((A) MapUtil.get(x, a)).no(); + return ((A) Utils.get(x, a)).no(); } public Number op2() { Tuple a = Tuple.mk_('x', 'y'); Tuple b = Tuple.mk_(1L, 2L); - return ((A) MapUtil.get(m(Utils.clone(a), Utils.clone(a)), b)).no(); + return ((A) Utils.get(m(Utils.clone(a), Utils.clone(a)), b)).no(); } public VDMMap m(final Tuple p, final Tuple q) { diff --git a/core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorMapLookup.result b/core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorMapLookup.result index dcbcb01dce..6cde749f67 100644 --- a/core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorMapLookup.result +++ b/core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorMapLookup.result @@ -48,7 +48,7 @@ public class Entry { public static Object Run() { Storage s = new Storage(); - return ((X) MapUtil.get(s.getXs(), 1L)).fun(); + return ((X) Utils.get(s.getXs(), 1L)).fun(); } public String toString() { diff --git a/core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorMapType.result b/core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorMapType.result index a1a2ebbe54..0bc7698d3f 100644 --- a/core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorMapType.result +++ b/core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorMapType.result @@ -15,16 +15,16 @@ public class X { } public Number m1() { - return ((X) MapUtil.get(xs, 1L)).f(); + return ((X) Utils.get(xs, 1L)).f(); } public Number m2() { - return ((X) MapUtil.get(((VDMMap) MapUtil.get(ys, 1L)), 1L)).f(); + return ((X) Utils.get(((VDMMap) Utils.get(ys, 1L)), 1L)).f(); } public Number m3() { - return ((X) MapUtil.get(((VDMMap) MapUtil.get( - ((VDMMap) MapUtil.get(zs, 1L)), 1L)), 1L)).f(); + return ((X) Utils.get(((VDMMap) Utils.get( + ((VDMMap) Utils.get(zs, 1L)), 1L)), 1L)).f(); } public Number m4() { @@ -32,16 +32,16 @@ public class X { } public Number m5() { - return ((X) MapUtil.get(map_xs(1L, 2L), 1L)).f(); + return ((X) Utils.get(map_xs(1L, 2L), 1L)).f(); } public Number m6() { - return ((X) MapUtil.get(((VDMMap) MapUtil.get(map_ys(1L, 2L), 1L)), 1L)).f(); + return ((X) Utils.get(((VDMMap) Utils.get(map_ys(1L, 2L), 1L)), 1L)).f(); } public Number m7() { - return ((X) MapUtil.get(((VDMMap) MapUtil.get( - ((VDMMap) MapUtil.get(map_zs(1L, 2L), 1L)), 1L)), 1L)).f(); + return ((X) Utils.get(((VDMMap) Utils.get( + ((VDMMap) Utils.get(map_zs(1L, 2L), 1L)), 1L)), 1L)).f(); } public VDMMap map_xs(final Number pa, final Number pb) { diff --git a/core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorWithRecFieldObj1.result b/core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorWithRecFieldObj1.result index 3ef5f80dd5..273c97266c 100644 --- a/core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorWithRecFieldObj1.result +++ b/core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorWithRecFieldObj1.result @@ -14,7 +14,7 @@ public class Entry { } public static Number op(final A a) { - return ((Entry) a.es.get(Utils.index(1L))).getConst(); + return ((Entry) Utils.get(a.es, 1L)).getConst(); } public Number getConst() { diff --git a/core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorWithRecFieldObj2.result b/core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorWithRecFieldObj2.result index 2b54f7dc66..97c0e62145 100644 --- a/core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorWithRecFieldObj2.result +++ b/core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorWithRecFieldObj2.result @@ -14,7 +14,7 @@ public class Entry { } public static Number op(final A a) { - return ((B) a.bs.get(Utils.index(1L))).c.e.getConst(); + return ((B) Utils.get(a.bs, 1L)).c.e.getConst(); } public Number getConst() { diff --git a/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorChangeRecField.result b/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorChangeRecField.result index 959ca7cc56..2e6b370b64 100644 --- a/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorChangeRecField.result +++ b/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorChangeRecField.result @@ -14,7 +14,7 @@ public class Entry { } public Number read() { - return ((Rec) MapUtil.get(m, true)).field; + return ((Rec) Utils.get(m, true)).field; } public static Object Run() { diff --git a/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapInMap.result b/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapInMap.result index 0c66704648..917f7c29b3 100644 --- a/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapInMap.result +++ b/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapInMap.result @@ -16,13 +16,13 @@ public class Entry { MapUtil.map(new Maplet(3L, 4L)))), 'c', 'x'); if (Utils.equals( - ((Character) MapUtil.get( - ((VDMMap) MapUtil.get(xs, - MapUtil.map(new Maplet(3L, 4L)))), 'c')), 'x')) { - return ((Character) MapUtil.get(((VDMMap) MapUtil.get(xs, + ((Character) Utils.get( + ((VDMMap) Utils.get(xs, MapUtil.map(new Maplet(3L, 4L)))), + 'c')), 'x')) { + return ((Character) Utils.get(((VDMMap) Utils.get(xs, MapUtil.map(new Maplet(1L, 2L)))), 'a')); } else { - return ((Character) MapUtil.get(((VDMMap) MapUtil.get(xs, + return ((Character) Utils.get(((VDMMap) Utils.get(xs, MapUtil.map(new Maplet(3L, 4L)))), 'c')); } } diff --git a/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapSeqToSeq.result b/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapSeqToSeq.result index e7039fdf39..845ded73af 100644 --- a/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapSeqToSeq.result +++ b/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapSeqToSeq.result @@ -13,13 +13,13 @@ public class Entry { Utils.mapSeqUpdate(((VDMSeq) Utils.get(xs, SeqUtil.seq('a'))), 1L, 'x'); if (Utils.equals( - ((Character) ((VDMSeq) MapUtil.get(xs, SeqUtil.seq('a'))).get( - Utils.index(1L))), 'x')) { - return ((Character) ((VDMSeq) MapUtil.get(xs, SeqUtil.seq('c'))).get(Utils.index( - 1L))); + ((Character) Utils.get( + ((VDMSeq) Utils.get(xs, SeqUtil.seq('a'))), 1L)), 'x')) { + return ((Character) Utils.get(((VDMSeq) Utils.get(xs, + SeqUtil.seq('c'))), 1L)); } else { - return ((Character) ((VDMSeq) MapUtil.get(xs, SeqUtil.seq('a'))).get(Utils.index( - 1L))); + return ((Character) Utils.get(((VDMSeq) Utils.get(xs, + SeqUtil.seq('a'))), 1L)); } } diff --git a/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorSeqInSeqInSeq.result b/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorSeqInSeqInSeq.result index 17d3a025bd..c2d8400bd0 100644 --- a/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorSeqInSeqInSeq.result +++ b/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorSeqInSeqInSeq.result @@ -15,13 +15,14 @@ public class Entry { 1L, 'x'); if (Utils.equals( - ((Character) ((VDMSeq) ((VDMSeq) xs.get(Utils.index(2L))).get( - Utils.index(1L))).get(Utils.index(1L))), 'x')) { - return ((Character) ((VDMSeq) ((VDMSeq) xs.get(Utils.index(2L))).get(Utils.index( - 2L))).get(Utils.index(2L))); + ((Character) Utils.get( + ((VDMSeq) Utils.get(((VDMSeq) Utils.get(xs, 2L)), 1L)), + 1L)), 'x')) { + return ((Character) Utils.get(((VDMSeq) Utils.get( + ((VDMSeq) Utils.get(xs, 2L)), 2L)), 2L)); } else { - return ((Character) ((VDMSeq) ((VDMSeq) xs.get(Utils.index(1L))).get(Utils.index( - 2L))).get(Utils.index(1L))); + return ((Character) Utils.get(((VDMSeq) Utils.get( + ((VDMSeq) Utils.get(xs, 1L)), 2L)), 1L)); } } diff --git a/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorSeqUpdate.result b/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorSeqUpdate.result index 8b3db152e1..06651b2bc9 100644 --- a/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorSeqUpdate.result +++ b/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorSeqUpdate.result @@ -11,7 +11,7 @@ public class Entry { VDMSeq xs = SeqUtil.seq(1L, 2L, 3L); Utils.mapSeqUpdate(xs, 2L, 5L); - return ((Number) xs.get(Utils.index(2L))); + return ((Number) Utils.get(xs, 2L)); } public String toString() { diff --git a/core/codegen/src/test/resources/complex_expressions/RecordUsageAcrossClass.result b/core/codegen/src/test/resources/complex_expressions/RecordUsageAcrossClass.result index 342bb76064..81688c6e48 100644 --- a/core/codegen/src/test/resources/complex_expressions/RecordUsageAcrossClass.result +++ b/core/codegen/src/test/resources/complex_expressions/RecordUsageAcrossClass.result @@ -45,7 +45,7 @@ public class Entry { public static Object Run() { VDMSeq recs = SeqUtil.seq(new A.Rec()); - A.Rec r = Utils.clone(((A.Rec) recs.get(Utils.index(1L)))); + A.Rec r = Utils.clone(((A.Rec) Utils.get(recs, 1L))); return 42L; } diff --git a/core/codegen/src/test/resources/complex_expressions/RecursiveNamedTypeMapApply.result b/core/codegen/src/test/resources/complex_expressions/RecursiveNamedTypeMapApply.result index 1eb09e0822..de153db1ed 100644 --- a/core/codegen/src/test/resources/complex_expressions/RecursiveNamedTypeMapApply.result +++ b/core/codegen/src/test/resources/complex_expressions/RecursiveNamedTypeMapApply.result @@ -11,7 +11,7 @@ public class Entry { } public Object app(final Token id, final Token index) { - return MapUtil.get(((VDMMap) MapUtil.get(m, id)), index); + return Utils.get(((VDMMap) Utils.get(m, id)), index); } public static Object Run() { diff --git a/core/codegen/src/test/resources/concurrency_classics_specs/POP3_LogBased_Test1.result b/core/codegen/src/test/resources/concurrency_classics_specs/POP3_LogBased_Test1.result index b7bfb3e02c..a545d99a90 100644 --- a/core/codegen/src/test/resources/concurrency_classics_specs/POP3_LogBased_Test1.result +++ b/core/codegen/src/test/resources/concurrency_classics_specs/POP3_LogBased_Test1.result @@ -940,10 +940,10 @@ public class POP3ClientHandler extends VDMThread implements EvaluatePP { Number i = ((Number) iterator_3.next()); seqCompResult_1 = SeqUtil.conc(Utils.clone(seqCompResult_1), SeqUtil.seq(int2string( - ((POP3Server.MessageInfo) msgSeq.get(Utils.index(i))).index) + + ((POP3Server.MessageInfo) Utils.get(msgSeq, i)).index) + " " + int2string( - ((POP3Server.MessageInfo) msgSeq.get(Utils.index(i))).size))); + ((POP3Server.MessageInfo) Utils.get(msgSeq, i)).size))); } return MakeMultilineResponse(Utils.clone(seqCompResult_1)); @@ -1513,8 +1513,7 @@ public class POP3Server extends VDMThread implements EvaluatePP { Boolean andResult_2 = false; if (MapUtil.dom(Utils.clone(passwords)).contains(user)) { - if (Utils.equals(((String) MapUtil.get(passwords, user)), - password)) { + if (Utils.equals(((String) Utils.get(passwords, user)), password)) { andResult_2 = true; } } @@ -1539,7 +1538,7 @@ public class POP3Server extends VDMThread implements EvaluatePP { sentinel.entering(((POP3Server_sentinel) sentinel).SetUserMessages); try { - MailBox recModifierExp_1 = Utils.clone(((MailBox) MapUtil.get( + MailBox recModifierExp_1 = Utils.clone(((MailBox) Utils.get( maildrop, user))); recModifierExp_1.msgs = Utils.clone(newMsgs); @@ -1556,7 +1555,7 @@ public class POP3Server extends VDMThread implements EvaluatePP { sentinel.entering(((POP3Server_sentinel) sentinel).GetUserMail); try { - return Utils.clone(((MailBox) MapUtil.get(maildrop, user))); + return Utils.clone(((MailBox) Utils.get(maildrop, user))); } finally { sentinel.leaving(((POP3Server_sentinel) sentinel).GetUserMail); } @@ -1583,10 +1582,9 @@ public class POP3Server extends VDMThread implements EvaluatePP { for (Iterator iterator_5 = set_5.iterator(); iterator_5.hasNext();) { Number i = ((Number) iterator_5.next()); - if (!(((POP3Message) oldMsgs.get(Utils.index(i))).IsDeleted())) { + if (!(((POP3Message) Utils.get(oldMsgs, i)).IsDeleted())) { seqCompResult_2 = SeqUtil.conc(Utils.clone(seqCompResult_2), - SeqUtil.seq( - ((POP3Message) oldMsgs.get(Utils.index(i))))); + SeqUtil.seq(((POP3Message) Utils.get(oldMsgs, i)))); } } @@ -1652,7 +1650,7 @@ public class POP3Server extends VDMThread implements EvaluatePP { Boolean andResult_4 = false; if (SeqUtil.inds(mb).contains(index)) { - if (!(((POP3Message) mb.get(Utils.index(index))).IsDeleted())) { + if (!(((POP3Message) Utils.get(mb, index)).IsDeleted())) { andResult_4 = true; } } @@ -1671,7 +1669,7 @@ public class POP3Server extends VDMThread implements EvaluatePP { Boolean andResult_5 = false; if (SeqUtil.inds(mb).contains(index)) { - if (((POP3Message) mb.get(Utils.index(index))).IsDeleted()) { + if (((POP3Message) Utils.get(mb, index)).IsDeleted()) { andResult_5 = true; } } @@ -1686,8 +1684,8 @@ public class POP3Server extends VDMThread implements EvaluatePP { sentinel.entering(((POP3Server_sentinel) sentinel).DeleteMessage); try { - POP3Message oldMsg = ((POP3Message) GetUserMessages(user) - .get(Utils.index(index))); + POP3Message oldMsg = ((POP3Message) Utils.get(GetUserMessages(user), + index)); POP3Message newMsg = oldMsg.Delete(); SetUserMessages(user, @@ -1704,7 +1702,7 @@ public class POP3Server extends VDMThread implements EvaluatePP { try { VDMSeq mb = GetUserMessages(user); - return ((POP3Message) mb.get(Utils.index(index))).GetHeader(); + return ((POP3Message) Utils.get(mb, index)).GetHeader(); } finally { sentinel.leaving(((POP3Server_sentinel) sentinel).GetMsgHeader); } @@ -1716,7 +1714,7 @@ public class POP3Server extends VDMThread implements EvaluatePP { try { VDMSeq mb = GetUserMessages(user); - return ((POP3Message) mb.get(Utils.index(index))).GetBody(); + return ((POP3Message) Utils.get(mb, index)).GetBody(); } finally { sentinel.leaving(((POP3Server_sentinel) sentinel).GetMsgBody); } @@ -1734,7 +1732,7 @@ public class POP3Server extends VDMThread implements EvaluatePP { Number i = ((Number) iterator_6.next()); seqCompResult_3 = SeqUtil.conc(Utils.clone(seqCompResult_3), SeqUtil.seq( - ((POP3Message) oldMsgs.get(Utils.index(i))).Undelete())); + ((POP3Message) Utils.get(oldMsgs, i)).Undelete())); } VDMSeq newMsgs = Utils.clone(seqCompResult_3); @@ -1748,7 +1746,7 @@ public class POP3Server extends VDMThread implements EvaluatePP { sentinel.entering(((POP3Server_sentinel) sentinel).GetMessageText); try { - return ((POP3Message) GetUserMessages(user).get(Utils.index(index))).GetText(); + return ((POP3Message) Utils.get(GetUserMessages(user), index)).GetText(); } finally { sentinel.leaving(((POP3Server_sentinel) sentinel).GetMessageText); } @@ -1758,7 +1756,7 @@ public class POP3Server extends VDMThread implements EvaluatePP { sentinel.entering(((POP3Server_sentinel) sentinel).GetMessageSize); try { - return ((POP3Message) GetUserMessages(user).get(Utils.index(index))).GetSize(); + return ((POP3Message) Utils.get(GetUserMessages(user), index)).GetSize(); } finally { sentinel.leaving(((POP3Server_sentinel) sentinel).GetMessageSize); } @@ -1778,7 +1776,7 @@ public class POP3Server extends VDMThread implements EvaluatePP { iterator_7.hasNext();) { Number i = ((Number) iterator_7.next()); - if (!(((POP3Message) mb.get(Utils.index(i))).IsDeleted())) { + if (!(((POP3Message) Utils.get(mb, i)).IsDeleted())) { seqCompResult_4 = SeqUtil.conc(Utils.clone( seqCompResult_4), SeqUtil.seq( @@ -1803,7 +1801,7 @@ public class POP3Server extends VDMThread implements EvaluatePP { VDMSeq mb = GetUserMessages(user); return POP3ClientHandler.int2string(index) + " " + - ((POP3Message) mb.get(Utils.index(index))).GetUniqueId(); + ((POP3Message) Utils.get(mb, index)).GetUniqueId(); } finally { sentinel.leaving(((POP3Server_sentinel) sentinel).GetUidl); } @@ -1851,7 +1849,7 @@ public class POP3Server extends VDMThread implements EvaluatePP { Number i = ((Number) iterator_9.next()); seqCompResult_6 = SeqUtil.conc(Utils.clone(seqCompResult_6), SeqUtil.seq( - ((POP3Message) mb.msgs.get(Utils.index(i))).GetSize())); + ((POP3Message) Utils.get(mb.msgs, i)).GetSize())); } return sumseq(Utils.clone(seqCompResult_6)); @@ -2260,8 +2258,8 @@ public class POP3Test implements EvaluatePP { Number i = ((Number) iterator_10.next()); mapCompResult_1 = MapUtil.munion(Utils.clone(mapCompResult_1), MapUtil.map( - new Maplet(((String) users.get(Utils.index(i))), - ((String) passwords.get(Utils.index(i)))))); + new Maplet(((String) Utils.get(users, i)), + ((String) Utils.get(passwords, i))))); } return Utils.clone(mapCompResult_1); @@ -2275,9 +2273,9 @@ public class POP3Test implements EvaluatePP { Number i = ((Number) iterator_11.next()); mapCompResult_2 = MapUtil.munion(Utils.clone(mapCompResult_2), MapUtil.map( - new Maplet(((String) users.get(Utils.index(i))), + new Maplet(((String) Utils.get(users, i)), new POP3Server.MailBox(MakeMessages( - ((String) users.get(Utils.index(i)))), false)))); + ((String) Utils.get(users, i))), false)))); } return Utils.clone(mapCompResult_2); @@ -2291,19 +2289,17 @@ public class POP3Test implements EvaluatePP { Number i = ((Number) iterator_12.next()); seqCompResult_7 = SeqUtil.conc(Utils.clone(seqCompResult_7), SeqUtil.seq( - new POP3Message( - ((String) headers.get(Utils.index(i))), - ((String) bodies.get(Utils.index(i))) + " to " + - user, user + POP3ClientHandler.int2string(i)))); + new POP3Message(((String) Utils.get(headers, i)), + ((String) Utils.get(bodies, i)) + " to " + user, + user + POP3ClientHandler.int2string(i)))); } return Utils.clone(seqCompResult_7); } private static VDMSeq TestRun1() { - return SeqUtil.seq(new POP3Types.USER( - ((String) users.get(Utils.index(1L)))), - new POP3Types.PASS(((String) passwords.get(Utils.index(1L)))), + return SeqUtil.seq(new POP3Types.USER(((String) Utils.get(users, 1L))), + new POP3Types.PASS(((String) Utils.get(passwords, 1L))), new POP3Types.STAT(), new POP3Types.LIST(null), new POP3Types.RETR(1L), new POP3Types.DELE(1L), new POP3Types.RETR(1L), new POP3Types.RSET(), new POP3Types.NOOP(), diff --git a/core/codegen/src/test/resources/expressions/ApplyExpSeqEnum.result b/core/codegen/src/test/resources/expressions/ApplyExpSeqEnum.result index 3c0e7b8d90..376bd2009b 100644 --- a/core/codegen/src/test/resources/expressions/ApplyExpSeqEnum.result +++ b/core/codegen/src/test/resources/expressions/ApplyExpSeqEnum.result @@ -1 +1 @@ -((Number) SeqUtil.seq(1L, 2L).get(Utils.index(2L))) \ No newline at end of file +((Number) Utils.get(SeqUtil.seq(1L, 2L),2L)) \ No newline at end of file diff --git a/core/codegen/src/test/resources/expressions/ApplyExpString.result b/core/codegen/src/test/resources/expressions/ApplyExpString.result index a6cfa63774..85a00081f0 100644 --- a/core/codegen/src/test/resources/expressions/ApplyExpString.result +++ b/core/codegen/src/test/resources/expressions/ApplyExpString.result @@ -1 +1 @@ -((Character) SeqUtil.seq('k', 'i', 't', 't', 'e', 'n').get(Utils.index(1L))) \ No newline at end of file +((Character) Utils.get(SeqUtil.seq('k', 'i', 't', 't', 'e', 'n'),1L)) \ No newline at end of file diff --git a/core/codegen/src/test/resources/expressions/Maps/MapApplyMapEnumExp.result b/core/codegen/src/test/resources/expressions/Maps/MapApplyMapEnumExp.result index a9f47b7b9f..246e2eb6cb 100644 --- a/core/codegen/src/test/resources/expressions/Maps/MapApplyMapEnumExp.result +++ b/core/codegen/src/test/resources/expressions/Maps/MapApplyMapEnumExp.result @@ -1 +1 @@ -((Boolean) MapUtil.get(MapUtil.map(new Maplet(Tuple.mk_(3L, true), true)),Tuple.mk_(3L, true))) \ No newline at end of file +((Boolean) Utils.get(MapUtil.map(new Maplet(Tuple.mk_(3L, true), true)),Tuple.mk_(3L, true))) \ No newline at end of file diff --git a/core/codegen/src/test/resources/expressions/Sequences/SeqIndexExp.result b/core/codegen/src/test/resources/expressions/Sequences/SeqIndexExp.result index 27e720071f..063a8bd241 100644 --- a/core/codegen/src/test/resources/expressions/Sequences/SeqIndexExp.result +++ b/core/codegen/src/test/resources/expressions/Sequences/SeqIndexExp.result @@ -1 +1 @@ -((Number) SeqUtil.seq(1L, 2L, 3L).get(Utils.index(1L))) \ No newline at end of file +((Number) Utils.get(SeqUtil.seq(1L, 2L, 3L),1L)) \ No newline at end of file diff --git a/core/codegen/src/test/resources/expressions/Sequences/SeqIndexValueTypeExp.result b/core/codegen/src/test/resources/expressions/Sequences/SeqIndexValueTypeExp.result index 76fc1cb7e3..6b99dba356 100644 --- a/core/codegen/src/test/resources/expressions/Sequences/SeqIndexValueTypeExp.result +++ b/core/codegen/src/test/resources/expressions/Sequences/SeqIndexValueTypeExp.result @@ -1 +1 @@ -Utils.clone(((Tuple) SeqUtil.seq(Tuple.mk_(1L, 2L)).get(Utils.index(1L)))) \ No newline at end of file +Utils.clone(((Tuple) Utils.get(SeqUtil.seq(Tuple.mk_(1L, 2L)),1L))) \ No newline at end of file diff --git a/core/codegen/src/test/resources/specifications/ApplyExpReturnedString.result b/core/codegen/src/test/resources/specifications/ApplyExpReturnedString.result index f6aa89516f..cc26247ea4 100644 --- a/core/codegen/src/test/resources/specifications/ApplyExpReturnedString.result +++ b/core/codegen/src/test/resources/specifications/ApplyExpReturnedString.result @@ -8,7 +8,7 @@ public class A { } public Character op() { - return ((Character) s().get(Utils.index(1L))); + return ((Character) Utils.get(s(), 1L)); } public VDMSeq s() { diff --git a/core/codegen/src/test/resources/specifications/MapApplyClone.result b/core/codegen/src/test/resources/specifications/MapApplyClone.result index 88ebc564cb..e5f642b8dc 100644 --- a/core/codegen/src/test/resources/specifications/MapApplyClone.result +++ b/core/codegen/src/test/resources/specifications/MapApplyClone.result @@ -4,7 +4,7 @@ import java.util.*; public class A { - private static final Tuple a = Utils.clone(((Tuple) MapUtil.get(op(), + private static final Tuple a = Utils.clone(((Tuple) Utils.get(op(), Tuple.mk_(1L, true)))); public A() { diff --git a/core/codegen/src/test/resources/specifications/MapPhoneBook.result b/core/codegen/src/test/resources/specifications/MapPhoneBook.result index 4625f5a845..c1c06841a9 100644 --- a/core/codegen/src/test/resources/specifications/MapPhoneBook.result +++ b/core/codegen/src/test/resources/specifications/MapPhoneBook.result @@ -189,11 +189,11 @@ public class PhoneBook { } public VDMSeq getNumber(final VDMSeq name) { - return Utils.clone(((VDMSeq) MapUtil.get(phoneNumbers, name))); + return Utils.clone(((VDMSeq) Utils.get(phoneNumbers, name))); } public VDMSeq getName(final VDMSeq number) { - return Utils.clone(((VDMSeq) MapUtil.get(MapUtil.inverse(Utils.clone( + return Utils.clone(((VDMSeq) Utils.get(MapUtil.inverse(Utils.clone( phoneNumbers)), number))); } diff --git a/core/codegen/src/test/resources/specifications/SeqNoteBook.result b/core/codegen/src/test/resources/specifications/SeqNoteBook.result index 5ae6fa2c2a..824a3f2568 100644 --- a/core/codegen/src/test/resources/specifications/SeqNoteBook.result +++ b/core/codegen/src/test/resources/specifications/SeqNoteBook.result @@ -120,7 +120,7 @@ public class NoteBook { for (Long i = 1L; i <= toVar_1; i++) { VDMSeq reversed = nb1.getReverseMessages(); - IO.println(Utils.clone(((VDMSeq) reversed.get(Utils.index(i))))); + IO.println(Utils.clone(((VDMSeq) Utils.get(reversed, i)))); } IO.print(SeqUtil.seq('\n')); @@ -214,7 +214,7 @@ public class NoteBook { } public VDMSeq getMessage(final Number index) { - return Utils.clone(((VDMSeq) messages.get(Utils.index(index)))); + return Utils.clone(((VDMSeq) Utils.get(messages, index))); } public Boolean isMessage(final Number index, final VDMSeq message) { diff --git a/core/codegen/src/test/resources/union_type_specs/ApplyExpInElseIfStm.result b/core/codegen/src/test/resources/union_type_specs/ApplyExpInElseIfStm.result index 69beaa66c6..c1049dc7dc 100644 --- a/core/codegen/src/test/resources/union_type_specs/ApplyExpInElseIfStm.result +++ b/core/codegen/src/test/resources/union_type_specs/ApplyExpInElseIfStm.result @@ -53,7 +53,7 @@ public class Entry { } else if (Utils.equals(2L, 3L)) { return false; } else { - Object obj_1 = MapUtil.get(m, 1L); + Object obj_1 = Utils.get(m, 1L); Tuple apply_1 = null; diff --git a/core/codegen/src/test/resources/union_type_specs/ApplyExpMissingMapInOneClass.result b/core/codegen/src/test/resources/union_type_specs/ApplyExpMissingMapInOneClass.result index fffac51352..b38e5869c2 100644 --- a/core/codegen/src/test/resources/union_type_specs/ApplyExpMissingMapInOneClass.result +++ b/core/codegen/src/test/resources/union_type_specs/ApplyExpMissingMapInOneClass.result @@ -50,7 +50,7 @@ public class Entry { Number apply_1 = null; if (x instanceof A) { - apply_1 = ((Number) MapUtil.get(((A) x).xs, 1L)); + apply_1 = ((Number) Utils.get(((A) x).xs, 1L)); } else { throw new RuntimeException("Missing member: xs"); } diff --git a/core/codegen/src/test/resources/union_type_specs/ApplyExpMissingSeqInOneClass.result b/core/codegen/src/test/resources/union_type_specs/ApplyExpMissingSeqInOneClass.result index 54c62c4952..5f57a20ec9 100644 --- a/core/codegen/src/test/resources/union_type_specs/ApplyExpMissingSeqInOneClass.result +++ b/core/codegen/src/test/resources/union_type_specs/ApplyExpMissingSeqInOneClass.result @@ -50,7 +50,7 @@ public class Entry { Number apply_1 = null; if (x instanceof A) { - apply_1 = ((Number) ((A) x).xs.get(Utils.index(1L))); + apply_1 = ((Number) Utils.get(((A) x).xs, 1L)); } else { throw new RuntimeException("Missing member: xs"); } diff --git a/core/codegen/src/test/resources/union_type_specs/ApplyExpMissingSeqOfCharInOneClass.result b/core/codegen/src/test/resources/union_type_specs/ApplyExpMissingSeqOfCharInOneClass.result index d903701ac0..7b5355bfba 100644 --- a/core/codegen/src/test/resources/union_type_specs/ApplyExpMissingSeqOfCharInOneClass.result +++ b/core/codegen/src/test/resources/union_type_specs/ApplyExpMissingSeqOfCharInOneClass.result @@ -50,7 +50,7 @@ public class Entry { Character apply_1 = null; if (x instanceof A) { - apply_1 = ((Character) ((A) x).xs.get(Utils.index(1L))); + apply_1 = ((Character) Utils.get(((A) x).xs, 1L)); } else { throw new RuntimeException("Missing member: xs"); } diff --git a/core/codegen/src/test/resources/union_type_specs/ApplyExpNested.result b/core/codegen/src/test/resources/union_type_specs/ApplyExpNested.result index 4e629ddd66..cd9b0f60f3 100644 --- a/core/codegen/src/test/resources/union_type_specs/ApplyExpNested.result +++ b/core/codegen/src/test/resources/union_type_specs/ApplyExpNested.result @@ -47,7 +47,7 @@ public class Entry { public static Number Run() { VDMMap xs = MapUtil.map(new Maplet(1L, new A()), new Maplet(2L, new B())); - Object x = MapUtil.get(xs, 1L); + Object x = Utils.get(xs, 1L); Number apply_1 = null; diff --git a/core/codegen/src/test/resources/union_type_specs/CallObjStmWithArguments.result b/core/codegen/src/test/resources/union_type_specs/CallObjStmWithArguments.result index 836aa0fdf0..696fedbaf1 100644 --- a/core/codegen/src/test/resources/union_type_specs/CallObjStmWithArguments.result +++ b/core/codegen/src/test/resources/union_type_specs/CallObjStmWithArguments.result @@ -94,7 +94,7 @@ public class Entry { ternaryIfExp_1 = ternaryIfExp_2; } - Object callStmObj_1 = objs.get(Utils.index(i)); + Object callStmObj_1 = Utils.get(objs, i); if (callStmObj_1 instanceof A) { ((A) callStmObj_1).op(((Number) a), ((Boolean) b), diff --git a/core/codegen/src/test/resources/union_type_specs/FieldExpArgToOpCall.result b/core/codegen/src/test/resources/union_type_specs/FieldExpArgToOpCall.result index fd308eca9e..af43fe330a 100644 --- a/core/codegen/src/test/resources/union_type_specs/FieldExpArgToOpCall.result +++ b/core/codegen/src/test/resources/union_type_specs/FieldExpArgToOpCall.result @@ -52,7 +52,7 @@ public class Entry { long toVar_1 = hr.size(); for (Long i = 1L; i <= toVar_1; i++) { - Object obj_1 = hr.get(Utils.index(i)); + Object obj_1 = Utils.get(hr, i); Number apply_1 = null; diff --git a/core/codegen/src/test/resources/union_type_specs/FieldExpInReturnStm.result b/core/codegen/src/test/resources/union_type_specs/FieldExpInReturnStm.result index 39235b4572..e045b524a6 100644 --- a/core/codegen/src/test/resources/union_type_specs/FieldExpInReturnStm.result +++ b/core/codegen/src/test/resources/union_type_specs/FieldExpInReturnStm.result @@ -44,7 +44,7 @@ public class Entry { } public static Object Run() { - Object obj_1 = hr.get(Utils.index(hr.size())); + Object obj_1 = Utils.get(hr, hr.size()); Number apply_1 = null; diff --git a/core/codegen/src/test/resources/union_type_specs/FieldExpMissingRecField.result b/core/codegen/src/test/resources/union_type_specs/FieldExpMissingRecField.result index 602767ee27..866ecdfa82 100644 --- a/core/codegen/src/test/resources/union_type_specs/FieldExpMissingRecField.result +++ b/core/codegen/src/test/resources/union_type_specs/FieldExpMissingRecField.result @@ -9,7 +9,7 @@ public class Entry { public static Object Run() { VDMSeq inlines = SeqUtil.seq(new R1(4L), new R2(5L)); - Object obj_1 = inlines.get(Utils.index(1L)); + Object obj_1 = Utils.get(inlines, 1L); Number apply_1 = null; @@ -19,7 +19,7 @@ public class Entry { throw new RuntimeException("Missing member: x"); } - Object obj_2 = inlines.get(Utils.index(2L)); + Object obj_2 = Utils.get(inlines, 2L); Number apply_2 = null; diff --git a/core/codegen/src/test/resources/union_type_specs/FieldExpNotRootOfApplyExp.result b/core/codegen/src/test/resources/union_type_specs/FieldExpNotRootOfApplyExp.result index 805e3c5ff9..5a62cf18e6 100644 --- a/core/codegen/src/test/resources/union_type_specs/FieldExpNotRootOfApplyExp.result +++ b/core/codegen/src/test/resources/union_type_specs/FieldExpNotRootOfApplyExp.result @@ -31,7 +31,7 @@ public class Entry { for (Iterator iterator_1 = set_1.iterator(); iterator_1.hasNext();) { VDMSeq hr = ((VDMSeq) iterator_1.next()); - Object obj_1 = hr.get(Utils.index(hr.size())); + Object obj_1 = Utils.get(hr, hr.size()); Rec apply_1 = null; diff --git a/core/codegen/src/test/resources/union_type_specs/FieldExpOfRecord.result b/core/codegen/src/test/resources/union_type_specs/FieldExpOfRecord.result index 30e9db6e48..345e2dd14d 100644 --- a/core/codegen/src/test/resources/union_type_specs/FieldExpOfRecord.result +++ b/core/codegen/src/test/resources/union_type_specs/FieldExpOfRecord.result @@ -22,7 +22,7 @@ public class Entry { for (Iterator iterator_1 = set_1.iterator(); iterator_1.hasNext();) { VDMSeq ss = ((VDMSeq) iterator_1.next()); - Object obj_1 = ss.get(Utils.index(1L)); + Object obj_1 = Utils.get(ss, 1L); Number apply_1 = null; diff --git a/core/codegen/src/test/resources/union_type_specs/FieldExpSeqApply.result b/core/codegen/src/test/resources/union_type_specs/FieldExpSeqApply.result index 5760e9b2d9..e050550866 100644 --- a/core/codegen/src/test/resources/union_type_specs/FieldExpSeqApply.result +++ b/core/codegen/src/test/resources/union_type_specs/FieldExpSeqApply.result @@ -49,7 +49,7 @@ public class Entry { for (Long i = 1L; i <= toVar_1; i++) { if (!(Utils.equals(i, 3L))) { - Object obj_1 = hr.get(Utils.index(i)); + Object obj_1 = Utils.get(hr, i); Number apply_1 = null; diff --git a/core/codegen/src/test/resources/union_type_specs/FieldExpWithObjectAsApplyExp.result b/core/codegen/src/test/resources/union_type_specs/FieldExpWithObjectAsApplyExp.result index 8155c400ee..e3788812f7 100644 --- a/core/codegen/src/test/resources/union_type_specs/FieldExpWithObjectAsApplyExp.result +++ b/core/codegen/src/test/resources/union_type_specs/FieldExpWithObjectAsApplyExp.result @@ -23,9 +23,9 @@ public class Entry { } VDMSeq ss = Utils.clone(ternaryIfExp_1); - VDMSeq s = Utils.clone(((VDMSeq) ss.get(Utils.index(1L)))); + VDMSeq s = Utils.clone(((VDMSeq) Utils.get(ss, 1L))); - Number y = S(((Entry) s.get(Utils.index(s.size())))).x; + Number y = S(((Entry) Utils.get(s, s.size()))).x; return y; } diff --git a/core/codegen/src/test/resources/union_type_specs/FieldNumberExpArgToApplyExp.result b/core/codegen/src/test/resources/union_type_specs/FieldNumberExpArgToApplyExp.result index dc646320fb..2a903ec3fc 100644 --- a/core/codegen/src/test/resources/union_type_specs/FieldNumberExpArgToApplyExp.result +++ b/core/codegen/src/test/resources/union_type_specs/FieldNumberExpArgToApplyExp.result @@ -9,7 +9,7 @@ public class Entry { public static Object Run() { VDMSeq xs = SeqUtil.seq(Tuple.mk_(5L, true), Tuple.mk_(true, 2L, 3L)); - Object x = xs.get(Utils.index(2L)); + Object x = Utils.get(xs, 2L); Object apply_1 = null; diff --git a/core/codegen/src/test/resources/union_type_specs/FieldNumberExpDifferentFieldTyps.result b/core/codegen/src/test/resources/union_type_specs/FieldNumberExpDifferentFieldTyps.result index 3348c519ee..4ea4027d8f 100644 --- a/core/codegen/src/test/resources/union_type_specs/FieldNumberExpDifferentFieldTyps.result +++ b/core/codegen/src/test/resources/union_type_specs/FieldNumberExpDifferentFieldTyps.result @@ -16,7 +16,7 @@ public class Entry { long toVar_1 = 3L; for (Long i = 1L; i <= toVar_1; i++) { - Object obj_1 = s.get(Utils.index(i)); + Object obj_1 = Utils.get(s, i); Object apply_1 = null; diff --git a/core/codegen/src/test/resources/union_type_specs/FieldNumberExpUnknownType.result b/core/codegen/src/test/resources/union_type_specs/FieldNumberExpUnknownType.result index 873daaacae..d77448ea46 100644 --- a/core/codegen/src/test/resources/union_type_specs/FieldNumberExpUnknownType.result +++ b/core/codegen/src/test/resources/union_type_specs/FieldNumberExpUnknownType.result @@ -22,7 +22,7 @@ public class Entry { for (Iterator iterator_1 = set_1.iterator(); iterator_1.hasNext();) { VDMSeq ss = ((VDMSeq) iterator_1.next()); - Object obj_1 = ss.get(Utils.index(1L)); + Object obj_1 = Utils.get(ss, 1L); Boolean apply_1 = null; diff --git a/core/codegen/src/test/resources/union_type_specs/MapApply.result b/core/codegen/src/test/resources/union_type_specs/MapApply.result index a084ca62c6..c5ad3dfc81 100644 --- a/core/codegen/src/test/resources/union_type_specs/MapApply.result +++ b/core/codegen/src/test/resources/union_type_specs/MapApply.result @@ -6,8 +6,8 @@ import java.util.*; public class Entry { private static final VDMMap x = MapUtil.map(new Maplet(1L, MapUtil.map(new Maplet(2L, 3L)))); - private static final Number b = ((Number) MapUtil.get(((VDMMap) MapUtil.get( - x, 1L)), 2L)); + private static final Number b = ((Number) Utils.get(((VDMMap) Utils.get(x, + 1L)), 2L)); public Entry() { } diff --git a/core/codegen/src/test/resources/union_type_specs/SeqApply.result b/core/codegen/src/test/resources/union_type_specs/SeqApply.result index 8c0bf718cd..6933e8ca0b 100644 --- a/core/codegen/src/test/resources/union_type_specs/SeqApply.result +++ b/core/codegen/src/test/resources/union_type_specs/SeqApply.result @@ -12,8 +12,7 @@ public class Entry { public static Object Run() { Entry e = new Entry(); - return ((Object) ((VDMSeq) ((VDMSeq) e.xs).get(Utils.index(1L))).get(Utils.index( - 1L))); + return ((Object) Utils.get(((VDMSeq) Utils.get(((VDMSeq) e.xs), 1L)), 1L)); } public String toString() { diff --git a/core/codegen/src/test/resources/union_type_specs/UnknownTypeInUnionType.result b/core/codegen/src/test/resources/union_type_specs/UnknownTypeInUnionType.result index 20723a2b71..4bc13edd44 100644 --- a/core/codegen/src/test/resources/union_type_specs/UnknownTypeInUnionType.result +++ b/core/codegen/src/test/resources/union_type_specs/UnknownTypeInUnionType.result @@ -19,9 +19,9 @@ public class Entry { } VDMSeq m = Utils.clone(ternaryIfExp_1); - VDMSeq s = Utils.clone(((VDMSeq) m.get(Utils.index(1L)))); + VDMSeq s = Utils.clone(((VDMSeq) Utils.get(m, 1L))); - Object obj_1 = s.get(Utils.index(s.size())); + Object obj_1 = Utils.get(s, s.size()); Number apply_1 = null; From c0ebb0f5ab48e0d0c1a0579eee473552825a7af5 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 4 Mar 2015 21:48:13 +0100 Subject: [PATCH 218/323] Updated the template for the apply expression to use the same functionality in the codegen rutnime as the state designator templates do --- .../src/main/resources/JavaTemplates/Expressions/Apply.vm | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Apply.vm b/core/codegen/src/main/resources/JavaTemplates/Expressions/Apply.vm index f7abb1af71..ed95a3a6b7 100644 --- a/core/codegen/src/main/resources/JavaTemplates/Expressions/Apply.vm +++ b/core/codegen/src/main/resources/JavaTemplates/Expressions/Apply.vm @@ -10,9 +10,9 @@ #set( $index = $JavaFormat.format($node.getArgs().get(0))) #set ( $seqRead = "" ) #if ($JavaFormat.castNotNeeded($node.getType())) - #set ( $seqRead = "${root}.get(Utils.index($index))" ) + #set ( $seqRead = "Utils.get(${root},${index})" ) #else - #set ( $seqRead = "(($JavaFormat.format($node.getType())) ${root}.get(Utils.index($index)))" ) + #set ( $seqRead = "(($JavaFormat.format($node.getType())) Utils.get(${root},${index}))" ) #end ## #if ($ValueSemantics.shouldClone($node)) @@ -25,9 +25,9 @@ #set( $key = $JavaFormat.format($node.getArgs().get(0))) #set ( $mapRead = "" ) #if ($JavaFormat.castNotNeeded($node.getType())) - #set ( $mapRead = "MapUtil.get(${root},${key})" ) + #set ( $mapRead = "Utils.get(${root},${key})" ) #else - #set ( $mapRead = "(($JavaFormat.format($node.getType())) MapUtil.get(${root},${key}))" ) + #set ( $mapRead = "(($JavaFormat.format($node.getType())) Utils.get(${root},${key}))" ) #end #if ($ValueSemantics.shouldClone($node)) Utils.clone(${mapRead}) From f5e24e63bf4780d004074e7e908856edddee526c Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 4 Mar 2015 21:49:18 +0100 Subject: [PATCH 219/323] Corrected the way that the codegen runtime handles map lookups --- .../src/main/java/org/overture/codegen/runtime/Utils.java | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/Utils.java b/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/Utils.java index e7b8bc207e..a3ec4307f1 100644 --- a/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/Utils.java +++ b/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/Utils.java @@ -50,8 +50,7 @@ public static Object get(Object col, Object index) } else if(col instanceof VDMMap) { - VDMMap map = (VDMMap) col; - return map.get(index); + return MapUtil.get((VDMMap) col, index); } else { From b46ff0994c04475a2e3b75cba5a119f0716cbb9a Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 4 Mar 2015 22:29:53 +0100 Subject: [PATCH 220/323] Small teak to the 'toString' in the codegen 'VDMSeq' runtime library class --- .../src/main/java/org/overture/codegen/runtime/VDMSeq.java | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/VDMSeq.java b/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/VDMSeq.java index db0c4020da..71db539fd4 100644 --- a/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/VDMSeq.java +++ b/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/VDMSeq.java @@ -73,7 +73,10 @@ public String toString() while (iterator.hasNext()) { Object element = iterator.next(); - sb.append(Utils.toString(element)); + + // Do not use Utils.toString(..) to avoid single quotes + // around the chars + sb.append(element); } return sb.toString(); From 06f8de188100163293f1db86ef60e0b42345bd1c Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Wed, 4 Mar 2015 23:06:46 +0100 Subject: [PATCH 221/323] Updated some VDM files used in testing of core/codegen. The VDM specs won't type check due to recent updates to type checking of function types --- .../resources/function_value_specs/FunctionComposeCurried1 | 4 ++-- .../src/test/resources/function_value_specs/MapUncurried | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/core/codegen/src/test/resources/function_value_specs/FunctionComposeCurried1 b/core/codegen/src/test/resources/function_value_specs/FunctionComposeCurried1 index fd020647ea..31b32ce883 100644 --- a/core/codegen/src/test/resources/function_value_specs/FunctionComposeCurried1 +++ b/core/codegen/src/test/resources/function_value_specs/FunctionComposeCurried1 @@ -11,8 +11,8 @@ operations public static Run : () ==> ? Run () == -let f = (lambda x : int & x + 1), - g = (lambda x : int & x + 2), +let f = (lambda x : nat & x + 1), + g = (lambda x : nat & x + 2), h = func_compose(f)(g) in return h(2); diff --git a/core/codegen/src/test/resources/function_value_specs/MapUncurried b/core/codegen/src/test/resources/function_value_specs/MapUncurried index 1b59dd593b..280b02841b 100644 --- a/core/codegen/src/test/resources/function_value_specs/MapUncurried +++ b/core/codegen/src/test/resources/function_value_specs/MapUncurried @@ -17,6 +17,6 @@ Run () == let xs = [1,2,3], func = (lambda x : int & x + 1) in - return seq_map[nat,nat](xs,func); + return seq_map[int,int](xs,func); end Entry \ No newline at end of file From 7edd25c88b0f25647ee2ade765ab996104599d9b Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Thu, 5 Mar 2015 16:08:11 +0100 Subject: [PATCH 222/323] Add naive reporting of operation execution times. [Issue: ] --- .../interpreter/values/OperationValue.java | 30 ++++++++++++++----- 1 file changed, 22 insertions(+), 8 deletions(-) diff --git a/core/interpreter/src/main/java/org/overture/interpreter/values/OperationValue.java b/core/interpreter/src/main/java/org/overture/interpreter/values/OperationValue.java index d7f1cab83f..05cb134b20 100644 --- a/core/interpreter/src/main/java/org/overture/interpreter/values/OperationValue.java +++ b/core/interpreter/src/main/java/org/overture/interpreter/values/OperationValue.java @@ -256,23 +256,37 @@ public void prepareGuard(ObjectContext ctxt) public Value eval(ILexLocation from, ValueList argValues, Context ctxt) throws AnalysisException { - // Note args cannot be Updateable, so we convert them here. This means - // that TransactionValues pass the local "new" value to the far end. - ValueList constValues = argValues.getConstant(); + long start = System.currentTimeMillis(); - if (Settings.dialect == Dialect.VDM_RT) + try { - if (!isStatic && (ctxt.threadState.CPU != self.getCPU() || isAsync)) + + // Note args cannot be Updateable, so we convert them here. This means + // that TransactionValues pass the local "new" value to the far end. + ValueList constValues = argValues.getConstant(); + + if (Settings.dialect == Dialect.VDM_RT) { - return asyncEval(constValues, ctxt); + if (!isStatic + && (ctxt.threadState.CPU != self.getCPU() || isAsync)) + { + return asyncEval(constValues, ctxt); + } else + { + return localEval(from, constValues, ctxt, true); + } } else { return localEval(from, constValues, ctxt, true); } - } else + } finally { - return localEval(from, constValues, ctxt, true); + System.err.println("timecheck," + + this.expldef.getName().getClassName().getFullName() + +"." + this.expldef.getName().getFullName() + "," + + (System.currentTimeMillis() - start)); } + } public Value localEval(ILexLocation from, ValueList argValues, From 0f945b4b620be34193aa9946cd1ed177bd553aad Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Thu, 5 Mar 2015 17:21:54 +0100 Subject: [PATCH 223/323] Updates to test results related to code generation of quotes --- .../classic_specs/AlarmTraces.result | 19 ++++++----- .../classic_specs/CashDispenserPP.result | 10 +++--- .../cloning_specs/AlarmTraces.result | 19 ++++++----- .../cloning_specs/CashDispenserPP.result | 10 +++--- ...ExpNamedTypeInvariantRecursiveTypes.result | 3 +- ...sExpNamedTypeInvariantUnionOfQuotes.result | 33 ++++++++++--------- .../complex_expressions/IsExpQuoteType.result | 8 ++--- .../QuoteLitComparison.result | 4 +-- .../RecursiveNamedTypeMapApply.result | 5 +-- .../POP3_LogBased_Test1.result | 30 ++++++++--------- .../pattern_specs/CasesStmQuote.result | 17 +++++----- .../test/resources/pattern_specs/Quote.result | 29 +++++++++------- .../specifications/UnionOfQuotes.result | 6 ++-- .../union_type_specs/UnionOfQuotes.result | 6 ++-- 14 files changed, 105 insertions(+), 94 deletions(-) diff --git a/core/codegen/src/test/resources/classic_specs/AlarmTraces.result b/core/codegen/src/test/resources/classic_specs/AlarmTraces.result index 50fa89b74e..8bd2137cd0 100644 --- a/core/codegen/src/test/resources/classic_specs/AlarmTraces.result +++ b/core/codegen/src/test/resources/classic_specs/AlarmTraces.result @@ -220,19 +220,20 @@ public class Entry { private static final Token p4 = new Token(SeqUtil.seq('T', 'u', 'e', 's', 'd', 'a', 'y', ' ', 'n', 'i', 'g', 'h', 't')); private static final VDMSet ps = SetUtil.set(p1, p2, p3, p4); - private Alarm a1 = new Alarm(quotes.Mech.getInstance(), + private Alarm a1 = new Alarm(quotes.MechQuote.getInstance(), SeqUtil.seq('M', 'e', 'c', 'h', 'a', 'n', 'i', 'c', 'a', 'l', ' ', 'f', 'a', 'u', 'l', 't')); - private Alarm a2 = new Alarm(quotes.Chem.getInstance(), + private Alarm a2 = new Alarm(quotes.ChemQuote.getInstance(), SeqUtil.seq('T', 'a', 'n', 'k', ' ', 'o', 'v', 'e', 'r', 'f', 'l', 'o', 'w')); - private Expert ex1 = new Expert(SetUtil.set(quotes.Mech.getInstance(), - quotes.Bio.getInstance())); - private Expert ex2 = new Expert(SetUtil.set(quotes.Elec.getInstance())); - private Expert ex3 = new Expert(SetUtil.set(quotes.Chem.getInstance(), - quotes.Bio.getInstance(), quotes.Mech.getInstance())); - private Expert ex4 = new Expert(SetUtil.set(quotes.Elec.getInstance(), - quotes.Chem.getInstance())); + private Expert ex1 = new Expert(SetUtil.set( + quotes.MechQuote.getInstance(), quotes.BioQuote.getInstance())); + private Expert ex2 = new Expert(SetUtil.set(quotes.ElecQuote.getInstance())); + private Expert ex3 = new Expert(SetUtil.set( + quotes.ChemQuote.getInstance(), quotes.BioQuote.getInstance(), + quotes.MechQuote.getInstance())); + private Expert ex4 = new Expert(SetUtil.set( + quotes.ElecQuote.getInstance(), quotes.ChemQuote.getInstance())); private Plant plant = new Plant(SetUtil.set(a1), MapUtil.map(new Maplet(p1, SetUtil.set(ex1, ex4)), new Maplet(p2, SetUtil.set(ex2, ex3)))); diff --git a/core/codegen/src/test/resources/classic_specs/CashDispenserPP.result b/core/codegen/src/test/resources/classic_specs/CashDispenserPP.result index 6b7ad9c186..66499af13e 100644 --- a/core/codegen/src/test/resources/classic_specs/CashDispenserPP.result +++ b/core/codegen/src/test/resources/classic_specs/CashDispenserPP.result @@ -52,7 +52,7 @@ public class SimpleTest { ((Till) Utils.get(tills, 1L)).InsertCard(c1); if (Utils.equals(((Till) Utils.get(tills, 1L)).Validate(123456L), - quotes.PinOk.getInstance())) { + quotes.PinOkQuote.getInstance())) { return ((Till) Utils.get(tills, 1L)).MakeWithdrawal(800L); } else { return false; @@ -571,7 +571,7 @@ public class Till { SetUtil.set(curCard)); curCard = null; - return quotes.Retained.getInstance(); + return quotes.RetainedQuote.getInstance(); } else if (codeOk) { resource.ResetNumberOfTries(cardId); } else { @@ -583,14 +583,14 @@ public class Till { cardOk = false; curCard = null; - return quotes.Retained.getInstance(); + return quotes.RetainedQuote.getInstance(); } } if (cardOk) { - return quotes.PinOk.getInstance(); + return quotes.PinOkQuote.getInstance(); } else { - return quotes.PinNotOk.getInstance(); + return quotes.PinNotOkQuote.getInstance(); } } } diff --git a/core/codegen/src/test/resources/cloning_specs/AlarmTraces.result b/core/codegen/src/test/resources/cloning_specs/AlarmTraces.result index 16940c9b4b..1694026ce7 100644 --- a/core/codegen/src/test/resources/cloning_specs/AlarmTraces.result +++ b/core/codegen/src/test/resources/cloning_specs/AlarmTraces.result @@ -217,19 +217,20 @@ public class Entry { private static final Token p4 = new Token(SeqUtil.seq('T', 'u', 'e', 's', 'd', 'a', 'y', ' ', 'n', 'i', 'g', 'h', 't')); private static final VDMSet ps = SetUtil.set(p1, p2, p3, p4); - private Alarm a1 = new Alarm(quotes.Mech.getInstance(), + private Alarm a1 = new Alarm(quotes.MechQuote.getInstance(), SeqUtil.seq('M', 'e', 'c', 'h', 'a', 'n', 'i', 'c', 'a', 'l', ' ', 'f', 'a', 'u', 'l', 't')); - private Alarm a2 = new Alarm(quotes.Chem.getInstance(), + private Alarm a2 = new Alarm(quotes.ChemQuote.getInstance(), SeqUtil.seq('T', 'a', 'n', 'k', ' ', 'o', 'v', 'e', 'r', 'f', 'l', 'o', 'w')); - private Expert ex1 = new Expert(SetUtil.set(quotes.Mech.getInstance(), - quotes.Bio.getInstance())); - private Expert ex2 = new Expert(SetUtil.set(quotes.Elec.getInstance())); - private Expert ex3 = new Expert(SetUtil.set(quotes.Chem.getInstance(), - quotes.Bio.getInstance(), quotes.Mech.getInstance())); - private Expert ex4 = new Expert(SetUtil.set(quotes.Elec.getInstance(), - quotes.Chem.getInstance())); + private Expert ex1 = new Expert(SetUtil.set( + quotes.MechQuote.getInstance(), quotes.BioQuote.getInstance())); + private Expert ex2 = new Expert(SetUtil.set(quotes.ElecQuote.getInstance())); + private Expert ex3 = new Expert(SetUtil.set( + quotes.ChemQuote.getInstance(), quotes.BioQuote.getInstance(), + quotes.MechQuote.getInstance())); + private Expert ex4 = new Expert(SetUtil.set( + quotes.ElecQuote.getInstance(), quotes.ChemQuote.getInstance())); private Plant plant = new Plant(SetUtil.set(a1), MapUtil.map(new Maplet(p1, SetUtil.set(ex1, ex4)), new Maplet(p2, SetUtil.set(ex2, ex3)))); diff --git a/core/codegen/src/test/resources/cloning_specs/CashDispenserPP.result b/core/codegen/src/test/resources/cloning_specs/CashDispenserPP.result index cfea080428..dd5d109023 100644 --- a/core/codegen/src/test/resources/cloning_specs/CashDispenserPP.result +++ b/core/codegen/src/test/resources/cloning_specs/CashDispenserPP.result @@ -52,7 +52,7 @@ public class SimpleTest { ((Till) Utils.get(tills, 1L)).InsertCard(c1); if (Utils.equals(((Till) Utils.get(tills, 1L)).Validate(123456L), - quotes.PinOk.getInstance())) { + quotes.PinOkQuote.getInstance())) { return ((Till) Utils.get(tills, 1L)).MakeWithdrawal(800L); } else { return false; @@ -565,7 +565,7 @@ public class Till { SetUtil.set(curCard)); curCard = null; - return quotes.Retained.getInstance(); + return quotes.RetainedQuote.getInstance(); } else if (codeOk) { resource.ResetNumberOfTries(cardId); } else { @@ -577,14 +577,14 @@ public class Till { cardOk = false; curCard = null; - return quotes.Retained.getInstance(); + return quotes.RetainedQuote.getInstance(); } } if (cardOk) { - return quotes.PinOk.getInstance(); + return quotes.PinOkQuote.getInstance(); } else { - return quotes.PinNotOk.getInstance(); + return quotes.PinNotOkQuote.getInstance(); } } } diff --git a/core/codegen/src/test/resources/complex_expressions/IsExpNamedTypeInvariantRecursiveTypes.result b/core/codegen/src/test/resources/complex_expressions/IsExpNamedTypeInvariantRecursiveTypes.result index a019eeed20..0b0109e846 100644 --- a/core/codegen/src/test/resources/complex_expressions/IsExpNamedTypeInvariantRecursiveTypes.result +++ b/core/codegen/src/test/resources/complex_expressions/IsExpNamedTypeInvariantRecursiveTypes.result @@ -8,7 +8,8 @@ public class Entry { } public static Object Run() { - return Utils.equals(quotes.C.getInstance(), quotes.C.getInstance()); + return Utils.equals(quotes.CQuote.getInstance(), + quotes.CQuote.getInstance()); } public String toString() { diff --git a/core/codegen/src/test/resources/complex_expressions/IsExpNamedTypeInvariantUnionOfQuotes.result b/core/codegen/src/test/resources/complex_expressions/IsExpNamedTypeInvariantUnionOfQuotes.result index cb26d9ebbb..1c65577218 100644 --- a/core/codegen/src/test/resources/complex_expressions/IsExpNamedTypeInvariantUnionOfQuotes.result +++ b/core/codegen/src/test/resources/complex_expressions/IsExpNamedTypeInvariantUnionOfQuotes.result @@ -8,23 +8,24 @@ public class Entry { } public static Object Run() { - quotes.Q isExpSubject_1 = quotes.Q.getInstance(); - quotes.A isExpSubject_2 = quotes.A.getInstance(); - quotes.A isExpSubject_3 = quotes.A.getInstance(); - quotes.D isExpSubject_4 = quotes.D.getInstance(); + quotes.QQuote isExpSubject_1 = quotes.QQuote.getInstance(); + quotes.AQuote isExpSubject_2 = quotes.AQuote.getInstance(); + quotes.AQuote isExpSubject_3 = quotes.AQuote.getInstance(); + quotes.DQuote isExpSubject_4 = quotes.DQuote.getInstance(); - return SeqUtil.seq((Utils.equals(isExpSubject_1, quotes.A.getInstance())) || - (Utils.equals(isExpSubject_1, quotes.B.getInstance())) || - (Utils.equals(isExpSubject_1, quotes.C.getInstance())) || - (Utils.equals(isExpSubject_1, quotes.D.getInstance())), - (Utils.equals(isExpSubject_2, quotes.A.getInstance())) || - (Utils.equals(isExpSubject_2, quotes.B.getInstance())) || - (Utils.equals(isExpSubject_2, quotes.C.getInstance())) || - (Utils.equals(isExpSubject_2, quotes.D.getInstance())), - (Utils.equals(isExpSubject_3, quotes.C.getInstance())) || - (Utils.equals(isExpSubject_3, quotes.D.getInstance())), - (Utils.equals(isExpSubject_4, quotes.C.getInstance())) || - (Utils.equals(isExpSubject_4, quotes.D.getInstance()))); + return SeqUtil.seq((Utils.equals(isExpSubject_1, + quotes.AQuote.getInstance())) || + (Utils.equals(isExpSubject_1, quotes.BQuote.getInstance())) || + (Utils.equals(isExpSubject_1, quotes.CQuote.getInstance())) || + (Utils.equals(isExpSubject_1, quotes.DQuote.getInstance())), + (Utils.equals(isExpSubject_2, quotes.AQuote.getInstance())) || + (Utils.equals(isExpSubject_2, quotes.BQuote.getInstance())) || + (Utils.equals(isExpSubject_2, quotes.CQuote.getInstance())) || + (Utils.equals(isExpSubject_2, quotes.DQuote.getInstance())), + (Utils.equals(isExpSubject_3, quotes.CQuote.getInstance())) || + (Utils.equals(isExpSubject_3, quotes.DQuote.getInstance())), + (Utils.equals(isExpSubject_4, quotes.CQuote.getInstance())) || + (Utils.equals(isExpSubject_4, quotes.DQuote.getInstance()))); } public String toString() { diff --git a/core/codegen/src/test/resources/complex_expressions/IsExpQuoteType.result b/core/codegen/src/test/resources/complex_expressions/IsExpQuoteType.result index fab6610e14..298ac318d4 100644 --- a/core/codegen/src/test/resources/complex_expressions/IsExpQuoteType.result +++ b/core/codegen/src/test/resources/complex_expressions/IsExpQuoteType.result @@ -8,11 +8,11 @@ public class Entry { } public static Object Run() { - quotes.A x = quotes.A.getInstance(); - quotes.B y = quotes.B.getInstance(); + quotes.AQuote x = quotes.AQuote.getInstance(); + quotes.BQuote y = quotes.BQuote.getInstance(); - return SeqUtil.seq(Utils.equals(x, quotes.A.getInstance()), - Utils.equals(y, quotes.A.getInstance())); + return SeqUtil.seq(Utils.equals(x, quotes.AQuote.getInstance()), + Utils.equals(y, quotes.AQuote.getInstance())); } public String toString() { diff --git a/core/codegen/src/test/resources/complex_expressions/QuoteLitComparison.result b/core/codegen/src/test/resources/complex_expressions/QuoteLitComparison.result index 38d19735d6..d30c03c596 100644 --- a/core/codegen/src/test/resources/complex_expressions/QuoteLitComparison.result +++ b/core/codegen/src/test/resources/complex_expressions/QuoteLitComparison.result @@ -8,9 +8,9 @@ public class Entry { } public static Object Run() { - quotes.A a = quotes.A.getInstance(); + quotes.AQuote a = quotes.AQuote.getInstance(); - return Utils.equals(a, quotes.A.getInstance()); + return Utils.equals(a, quotes.AQuote.getInstance()); } public String toString() { diff --git a/core/codegen/src/test/resources/complex_expressions/RecursiveNamedTypeMapApply.result b/core/codegen/src/test/resources/complex_expressions/RecursiveNamedTypeMapApply.result index de153db1ed..299be8940d 100644 --- a/core/codegen/src/test/resources/complex_expressions/RecursiveNamedTypeMapApply.result +++ b/core/codegen/src/test/resources/complex_expressions/RecursiveNamedTypeMapApply.result @@ -5,7 +5,8 @@ import java.util.*; public class Entry { private VDMMap m = MapUtil.map(new Maplet(new Token(1L), - MapUtil.map(new Maplet(new Token(1L), quotes.A.getInstance())))); + MapUtil.map( + new Maplet(new Token(1L), quotes.AQuote.getInstance())))); public Entry() { } @@ -17,7 +18,7 @@ public class Entry { public static Object Run() { Entry e = new Entry(); - return Utils.equals(quotes.A.getInstance(), + return Utils.equals(quotes.AQuote.getInstance(), e.app(new Token(1L), new Token(1L))); } diff --git a/core/codegen/src/test/resources/concurrency_classics_specs/POP3_LogBased_Test1.result b/core/codegen/src/test/resources/concurrency_classics_specs/POP3_LogBased_Test1.result index a545d99a90..4991902e69 100644 --- a/core/codegen/src/test/resources/concurrency_classics_specs/POP3_LogBased_Test1.result +++ b/core/codegen/src/test/resources/concurrency_classics_specs/POP3_LogBased_Test1.result @@ -452,7 +452,7 @@ public class POP3ClientHandler extends VDMThread implements EvaluatePP { public void cg_init_POP3ClientHandler_1(final POP3Server nparent, final MessageChannel nch) { - ss = quotes.Authorization.getInstance(); + ss = quotes.AuthorizationQuote.getInstance(); parent = nparent; msgChannel = nch; } @@ -610,19 +610,19 @@ public class POP3ClientHandler extends VDMThread implements EvaluatePP { Object response = null; Object quotePattern_1 = ss; Boolean success_4 = Utils.equals(quotePattern_1, - quotes.Authorization.getInstance()); + quotes.AuthorizationQuote.getInstance()); if (!(success_4)) { Object quotePattern_2 = ss; success_4 = Utils.equals(quotePattern_2, - quotes.Transaction.getInstance()); + quotes.TransactionQuote.getInstance()); if (success_4) { { Boolean b = parent.RemoveDeletedMessages(user); { - ss = quotes.Update.getInstance(); + ss = quotes.UpdateQuote.getInstance(); sentinel.stateChanged(); parent.ReleaseLock(id); @@ -655,7 +655,7 @@ public class POP3ClientHandler extends VDMThread implements EvaluatePP { sentinel.entering(((POP3ClientHandler_sentinel) sentinel).ReceiveSTAT); try { - if (Utils.equals(ss, quotes.Transaction.getInstance())) { + if (Utils.equals(ss, quotes.TransactionQuote.getInstance())) { return new POP3Types.OkResponse(" " + int2string(parent.GetNumberOfMessages(user)) + " " + int2string(parent.GetMailBoxSize(user))); @@ -671,7 +671,7 @@ public class POP3ClientHandler extends VDMThread implements EvaluatePP { sentinel.entering(((POP3ClientHandler_sentinel) sentinel).ReceiveLIST); try { - if (Utils.equals(ss, quotes.Transaction.getInstance())) { + if (Utils.equals(ss, quotes.TransactionQuote.getInstance())) { Boolean orResult_1 = false; if (Utils.equals(list.messageNumber, null)) { @@ -702,7 +702,7 @@ public class POP3ClientHandler extends VDMThread implements EvaluatePP { sentinel.entering(((POP3ClientHandler_sentinel) sentinel).ReceiveRETR); try { - if (Utils.equals(ss, quotes.Transaction.getInstance())) { + if (Utils.equals(ss, quotes.TransactionQuote.getInstance())) { if (parent.IsValidMessageNumber(user, retr.messageNumber)) { String msgText = parent.GetMessageText(user, retr.messageNumber); @@ -725,7 +725,7 @@ public class POP3ClientHandler extends VDMThread implements EvaluatePP { sentinel.entering(((POP3ClientHandler_sentinel) sentinel).ReceiveDELE); try { - if (Utils.equals(ss, quotes.Transaction.getInstance())) { + if (Utils.equals(ss, quotes.TransactionQuote.getInstance())) { if (parent.IsValidMessageNumber(user, retr.messageNumber)) { parent.DeleteMessage(user, retr.messageNumber); @@ -750,7 +750,7 @@ public class POP3ClientHandler extends VDMThread implements EvaluatePP { sentinel.entering(((POP3ClientHandler_sentinel) sentinel).ReceiveNOOP); try { - if (Utils.equals(ss, quotes.Transaction.getInstance())) { + if (Utils.equals(ss, quotes.TransactionQuote.getInstance())) { return new POP3Types.OkResponse(""); } else { return new POP3Types.ErrResponse(negativeStatusMsg); @@ -764,7 +764,7 @@ public class POP3ClientHandler extends VDMThread implements EvaluatePP { sentinel.entering(((POP3ClientHandler_sentinel) sentinel).ReceiveRSET); try { - if (Utils.equals(ss, quotes.Transaction.getInstance())) { + if (Utils.equals(ss, quotes.TransactionQuote.getInstance())) { parent.ResetDeletedMessages(user); return new POP3Types.OkResponse("maildrop has " + @@ -781,7 +781,7 @@ public class POP3ClientHandler extends VDMThread implements EvaluatePP { sentinel.entering(((POP3ClientHandler_sentinel) sentinel).ReceiveTOP); try { - if (Utils.equals(ss, quotes.Transaction.getInstance())) { + if (Utils.equals(ss, quotes.TransactionQuote.getInstance())) { if (parent.IsValidMessageNumber(user, top.messageNumber)) { String header = parent.GetMsgHeader(user, top.messageNumber); String body = parent.GetMsgBody(user, top.messageNumber); @@ -805,7 +805,7 @@ public class POP3ClientHandler extends VDMThread implements EvaluatePP { sentinel.entering(((POP3ClientHandler_sentinel) sentinel).ReceiveUIDL); try { - if (Utils.equals(ss, quotes.Transaction.getInstance())) { + if (Utils.equals(ss, quotes.TransactionQuote.getInstance())) { if (Utils.equals(uidl.messageNumber, null)) { VDMSeq uidlTxt = parent.GetAllUidls(user); @@ -829,7 +829,7 @@ public class POP3ClientHandler extends VDMThread implements EvaluatePP { sentinel.entering(((POP3ClientHandler_sentinel) sentinel).ReceiveUSER); try { - if (Utils.equals(ss, quotes.Authorization.getInstance())) { + if (Utils.equals(ss, quotes.AuthorizationQuote.getInstance())) { user = usercmd.name; sentinel.stateChanged(); @@ -848,7 +848,7 @@ public class POP3ClientHandler extends VDMThread implements EvaluatePP { try { Boolean andResult_1 = false; - if (Utils.equals(ss, quotes.Authorization.getInstance())) { + if (Utils.equals(ss, quotes.AuthorizationQuote.getInstance())) { if (lastWasUser) { andResult_1 = true; } @@ -863,7 +863,7 @@ public class POP3ClientHandler extends VDMThread implements EvaluatePP { return new POP3Types.ErrResponse(maildropLockedMsg); } else { parent.AcquireLock(id, user); - ss = quotes.Transaction.getInstance(); + ss = quotes.TransactionQuote.getInstance(); sentinel.stateChanged(); return new POP3Types.OkResponse(maildropReadyMsg); diff --git a/core/codegen/src/test/resources/pattern_specs/CasesStmQuote.result b/core/codegen/src/test/resources/pattern_specs/CasesStmQuote.result index 13fbad0b36..2c985ec6d3 100644 --- a/core/codegen/src/test/resources/pattern_specs/CasesStmQuote.result +++ b/core/codegen/src/test/resources/pattern_specs/CasesStmQuote.result @@ -9,26 +9,27 @@ public class Entry { public static Object casesQuote(final Object e) { Object quotePattern_1 = e; - Boolean success_1 = Utils.equals(quotePattern_1, quotes.A.getInstance()); + Boolean success_1 = Utils.equals(quotePattern_1, + quotes.AQuote.getInstance()); if (!(success_1)) { Object quotePattern_2 = e; - success_1 = Utils.equals(quotePattern_2, quotes.B.getInstance()); + success_1 = Utils.equals(quotePattern_2, quotes.BQuote.getInstance()); if (success_1) { - return quotes.B.getInstance(); + return quotes.BQuote.getInstance(); } else { - return quotes.C.getInstance(); + return quotes.CQuote.getInstance(); } } else { - return quotes.A.getInstance(); + return quotes.AQuote.getInstance(); } } public static Object Run() { - return SeqUtil.seq(casesQuote(quotes.A.getInstance()), - casesQuote(quotes.B.getInstance()), - casesQuote(quotes.C.getInstance())); + return SeqUtil.seq(casesQuote(quotes.AQuote.getInstance()), + casesQuote(quotes.BQuote.getInstance()), + casesQuote(quotes.CQuote.getInstance())); } public String toString() { diff --git a/core/codegen/src/test/resources/pattern_specs/Quote.result b/core/codegen/src/test/resources/pattern_specs/Quote.result index 4533bedeea..dbb19ef07e 100644 --- a/core/codegen/src/test/resources/pattern_specs/Quote.result +++ b/core/codegen/src/test/resources/pattern_specs/Quote.result @@ -7,38 +7,43 @@ public class A { public A() { } - public quotes.T1 quotePatternOp(final quotes.T1 quotePattern_1) { - Boolean success_1 = Utils.equals(quotePattern_1, quotes.T1.getInstance()); + public quotes.T1Quote quotePatternOp(final quotes.T1Quote quotePattern_1) { + Boolean success_1 = Utils.equals(quotePattern_1, + quotes.T1Quote.getInstance()); if (!(success_1)) { throw new RuntimeException("Quote pattern match failed"); } - quotes.T1 quotePattern_2 = quotes.T1.getInstance(); - Boolean success_2 = Utils.equals(quotePattern_2, quotes.T1.getInstance()); + quotes.T1Quote quotePattern_2 = quotes.T1Quote.getInstance(); + Boolean success_2 = Utils.equals(quotePattern_2, + quotes.T1Quote.getInstance()); if (!(success_2)) { throw new RuntimeException("Quote pattern match failed"); } - return quotes.T1.getInstance(); + return quotes.T1Quote.getInstance(); } - public static quotes.T1 quotePatternFun(final quotes.T1 quotePattern_3) { - Boolean success_3 = Utils.equals(quotePattern_3, quotes.T1.getInstance()); + public static quotes.T1Quote quotePatternFun( + final quotes.T1Quote quotePattern_3) { + Boolean success_3 = Utils.equals(quotePattern_3, + quotes.T1Quote.getInstance()); if (!(success_3)) { throw new RuntimeException("Quote pattern match failed"); } - quotes.T1 quotePattern_4 = quotes.T1.getInstance(); - Boolean success_4 = Utils.equals(quotePattern_4, quotes.T1.getInstance()); + quotes.T1Quote quotePattern_4 = quotes.T1Quote.getInstance(); + Boolean success_4 = Utils.equals(quotePattern_4, + quotes.T1Quote.getInstance()); if (!(success_4)) { throw new RuntimeException("Quote pattern match failed"); } - return quotes.T1.getInstance(); + return quotes.T1Quote.getInstance(); } public String toString() { @@ -57,8 +62,8 @@ public class Entry { } public static Object Run() { - return SeqUtil.seq(new A().quotePatternOp(quotes.T1.getInstance()), - A.quotePatternFun(quotes.T1.getInstance())); + return SeqUtil.seq(new A().quotePatternOp(quotes.T1Quote.getInstance()), + A.quotePatternFun(quotes.T1Quote.getInstance())); } public String toString() { diff --git a/core/codegen/src/test/resources/specifications/UnionOfQuotes.result b/core/codegen/src/test/resources/specifications/UnionOfQuotes.result index 5e1d3bfe2f..2376e2047c 100644 --- a/core/codegen/src/test/resources/specifications/UnionOfQuotes.result +++ b/core/codegen/src/test/resources/specifications/UnionOfQuotes.result @@ -8,19 +8,19 @@ public class A { } public void op(final Object v) { - if (Utils.equals(v, quotes.Red.getInstance())) { + if (Utils.equals(v, quotes.RedQuote.getInstance())) { //Skip; } } public void op2(final Object v) { - if (Utils.equals(v, quotes.A.getInstance())) { + if (Utils.equals(v, quotes.AQuote.getInstance())) { //Skip; } } public Object op3() { - return quotes.Red.getInstance(); + return quotes.RedQuote.getInstance(); } public String toString() { diff --git a/core/codegen/src/test/resources/union_type_specs/UnionOfQuotes.result b/core/codegen/src/test/resources/union_type_specs/UnionOfQuotes.result index c149e2b446..dee756e1cb 100644 --- a/core/codegen/src/test/resources/union_type_specs/UnionOfQuotes.result +++ b/core/codegen/src/test/resources/union_type_specs/UnionOfQuotes.result @@ -8,7 +8,7 @@ public class A { } public static Object f() { - return quotes.T.getInstance(); + return quotes.TQuote.getInstance(); } public String toString() { @@ -27,7 +27,7 @@ public class B { } public static Object f() { - return quotes.T.getInstance(); + return quotes.TQuote.getInstance(); } public String toString() { @@ -60,7 +60,7 @@ public class Entry { throw new RuntimeException("Missing member: f"); } - if (Utils.equals(apply_1, quotes.A.getInstance())) { + if (Utils.equals(apply_1, quotes.AQuote.getInstance())) { return 1L; } } From ffaca1517dcd5059da3bd048b94bf7cd895ea62e Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Thu, 5 Mar 2015 17:30:07 +0100 Subject: [PATCH 224/323] Issue #425. Slight changes to the way quotes are code generated to Java. Now the name of a quote (say) gets appended with 'Quote' so it becomes 'AQuote' --- .../java/org/overture/codegen/runtime/IO.java | 2 +- .../codegen/vdm2java/JavaCodeGen.java | 23 ++++++++----------- .../JavaTemplates/Expressions/QuoteLiteral.vm | 2 +- .../resources/JavaTemplates/Types/Quote.vm | 2 +- .../codegen/tests/utils/ComparisonCG.java | 3 ++- 5 files changed, 14 insertions(+), 18 deletions(-) diff --git a/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/IO.java b/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/IO.java index 4f9efaec9a..ce37a29265 100644 --- a/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/IO.java +++ b/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/IO.java @@ -101,7 +101,7 @@ public boolean fecho(String filename, String text, Object fdir) { try { File file = getFile(filename); - FileOutputStream fos = new FileOutputStream(file, fdir.getClass().getName().equals("quotes.append")); + FileOutputStream fos = new FileOutputStream(file, fdir.getClass().getName().equals("quotes.appendQuote")); fos.write(text.getBytes(Charset.defaultCharset().name())); fos.close(); diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java index 8146fd8eb1..3958e403d4 100644 --- a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java +++ b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java @@ -87,6 +87,7 @@ public class JavaCodeGen extends CodeGenBase "Utils", "Record", "Long", "Double", "Character", "String", "List", "Set" }; + public static final String JAVA_QUOTE_NAME_SUFFIX = "Quote"; public static final String JAVA_MAIN_CLASS_NAME = "Main"; private JavaFormat javaFormat; @@ -163,28 +164,22 @@ public List generateJavaFromVdmQuotes() javaFormat.init(); - JavaQuoteValueCreator quoteValueCreator = new JavaQuoteValueCreator(generator.getIRInfo(), transAssistant); + JavaQuoteValueCreator quoteValueCreator = new JavaQuoteValueCreator(generator.getIRInfo(), + transAssistant); - List quoteDecls = new LinkedList(); - - for(String qv : quoteValues) - { - quoteDecls.add(quoteValueCreator.consQuoteValue(qv)); - } - List modules = new LinkedList(); - - for (AClassDeclCG q : quoteDecls) + for(String quoteNameVdm : quoteValues) { + AClassDeclCG quoteDecl = quoteValueCreator.consQuoteValue(quoteNameVdm + JAVA_QUOTE_NAME_SUFFIX); + StringWriter writer = new StringWriter(); - q.apply(javaFormat.getMergeVisitor(), writer); + quoteDecl.apply(javaFormat.getMergeVisitor(), writer); String code = writer.toString(); String formattedJavaCode = JavaCodeGenUtil.formatJavaCode(code); - modules.add(new GeneratedModule(q.getName(), q, formattedJavaCode)); + modules.add(new GeneratedModule(quoteNameVdm, quoteDecl, formattedJavaCode)); } - - + return modules; } catch (org.overture.codegen.cgast.analysis.AnalysisException e) diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/QuoteLiteral.vm b/core/codegen/src/main/resources/JavaTemplates/Expressions/QuoteLiteral.vm index 4bc36713fd..606ff12007 100644 --- a/core/codegen/src/main/resources/JavaTemplates/Expressions/QuoteLiteral.vm +++ b/core/codegen/src/main/resources/JavaTemplates/Expressions/QuoteLiteral.vm @@ -1 +1 @@ -quotes.${node.getValue()}.getInstance() \ No newline at end of file +quotes.${node.getValue()}Quote.getInstance() \ No newline at end of file diff --git a/core/codegen/src/main/resources/JavaTemplates/Types/Quote.vm b/core/codegen/src/main/resources/JavaTemplates/Types/Quote.vm index f0653c0bd7..4e0e39cead 100644 --- a/core/codegen/src/main/resources/JavaTemplates/Types/Quote.vm +++ b/core/codegen/src/main/resources/JavaTemplates/Types/Quote.vm @@ -1 +1 @@ -quotes.$node.getValue() \ No newline at end of file +quotes.${node.getValue()}Quote \ No newline at end of file diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/ComparisonCG.java b/core/codegen/src/test/java/org/overture/codegen/tests/utils/ComparisonCG.java index 93ff76bc04..2e60492a71 100644 --- a/core/codegen/src/test/java/org/overture/codegen/tests/utils/ComparisonCG.java +++ b/core/codegen/src/test/java/org/overture/codegen/tests/utils/ComparisonCG.java @@ -223,7 +223,8 @@ private boolean handleQuote(Object cgValue, Value vdmValue) return false; } - return cgValue.toString().equals(vdmValue.toString()); + // For example, the replacement constructs from + return cgValue.toString().replace("Quote>", ">").equals(vdmValue.toString()); } private boolean handleToken(Object cgValue, Value vdmValue) From 9028afb8ddab56c40bf8a11986118d04131c8228 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Thu, 5 Mar 2015 23:47:01 +0100 Subject: [PATCH 225/323] Added test to exercise code generation to a user specified Java package --- .../overture/codegen/tests/PackageTest.java | 30 +++++++++++++++++++ .../codegen/tests/PackageTestCase.java | 27 +++++++++++++++++ .../org/overture/codegen/tests/TestFlags.java | 1 + 3 files changed, 58 insertions(+) create mode 100644 core/codegen/src/test/java/org/overture/codegen/tests/PackageTest.java create mode 100644 core/codegen/src/test/java/org/overture/codegen/tests/PackageTestCase.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/PackageTest.java b/core/codegen/src/test/java/org/overture/codegen/tests/PackageTest.java new file mode 100644 index 0000000000..a81179ff5c --- /dev/null +++ b/core/codegen/src/test/java/org/overture/codegen/tests/PackageTest.java @@ -0,0 +1,30 @@ +package org.overture.codegen.tests; + +import java.io.File; +import java.io.IOException; +import java.lang.reflect.InvocationTargetException; + +import junit.framework.Test; +import junit.framework.TestSuite; + +import org.overture.ast.lex.LexLocation; +import org.overture.test.framework.BaseTestSuite; +import org.overture.test.framework.Properties; + +public class PackageTest extends BaseTestSuite +{ + public static final String ROOT = "src" + File.separatorChar + "test" + + File.separatorChar + "resources" + File.separatorChar + "package_specs"; + + public static Test suite() throws IllegalArgumentException, + SecurityException, InstantiationException, IllegalAccessException, + InvocationTargetException, NoSuchMethodException, IOException + { + LexLocation.absoluteToStringLocation = false; + Properties.recordTestResults = TestFlags.PACKAGE_TESTS_ON; + + String name = "Package test case"; + TestSuite test = createTestCompleteFile(name, ROOT, PackageTestCase.class, ""); + return test; + } +} diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/PackageTestCase.java b/core/codegen/src/test/java/org/overture/codegen/tests/PackageTestCase.java new file mode 100644 index 0000000000..0b2fd0d5cf --- /dev/null +++ b/core/codegen/src/test/java/org/overture/codegen/tests/PackageTestCase.java @@ -0,0 +1,27 @@ +package org.overture.codegen.tests; + +import java.io.File; + +import org.overture.codegen.vdm2java.JavaSettings; + +public class PackageTestCase extends SpecificationTestCase +{ + public PackageTestCase() + { + + } + + public PackageTestCase(File file) + { + super(file); + } + + @Override + public JavaSettings getJavaSettings() + { + JavaSettings javaSettings = super.getJavaSettings(); + javaSettings.setJavaRootPackage("my.model"); + + return javaSettings; + } +} diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/TestFlags.java b/core/codegen/src/test/java/org/overture/codegen/tests/TestFlags.java index 67747ac269..d08bfec051 100644 --- a/core/codegen/src/test/java/org/overture/codegen/tests/TestFlags.java +++ b/core/codegen/src/test/java/org/overture/codegen/tests/TestFlags.java @@ -37,4 +37,5 @@ public class TestFlags public static final boolean BIND_TESTS_ON = false; public static final boolean PRE_POST_TESTS_ON = false; public static final boolean RT_TESTS_ON = false; + public static final boolean PACKAGE_TESTS_ON = false; } From 60cc09907b8cff9371c0aa1f7217732351100ae1 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Thu, 5 Mar 2015 23:50:45 +0100 Subject: [PATCH 226/323] Updated the Java code generation test execution system to handle the "package tests" --- .../codegen/tests/utils/CompileTests.java | 29 ++++++++++++++++++- .../utils/ExecutableSpecTestHandler.java | 22 +++++++++----- .../tests/utils/ExpressionTestHandler.java | 2 +- .../utils/NonExecutableSpecTestHandler.java | 4 +-- .../codegen/tests/utils/TestHandler.java | 2 +- .../codegen/tests/utils/TestUtils.java | 3 +- 6 files changed, 48 insertions(+), 14 deletions(-) diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/CompileTests.java b/core/codegen/src/test/java/org/overture/codegen/tests/utils/CompileTests.java index aa96a636ac..4acd974661 100644 --- a/core/codegen/src/test/java/org/overture/codegen/tests/utils/CompileTests.java +++ b/core/codegen/src/test/java/org/overture/codegen/tests/utils/CompileTests.java @@ -41,6 +41,7 @@ import org.overture.codegen.tests.ConfiguredStringGenerationTest; import org.overture.codegen.tests.ExpressionTest; import org.overture.codegen.tests.FunctionValueTest; +import org.overture.codegen.tests.PackageTest; import org.overture.codegen.tests.PatternTest; import org.overture.codegen.tests.PrePostTest; import org.overture.codegen.tests.RtTest; @@ -82,6 +83,7 @@ public class CompileTests public static final boolean RUN_CONCURRENCY_TESTS = true; public static final boolean RUN_CONCURRENCY_CLASSIC_TESTS = true; public static final boolean RUN_RT_TESTS = true; + public static final boolean RUN_PACKAGE_TESTS = true; public static final boolean RUN_BIND_TESTS = true; public static final boolean PRE_POST_TESTS = true; public static final boolean RUN_EXECUTING_CLASSIC_SPEC_TESTS = true; @@ -163,6 +165,11 @@ private void runTests() throws IOException runRtTests(); } + if(RUN_PACKAGE_TESTS) + { + runPackageTests(); + } + if (RUN_BIND_TESTS) { runBindTests(); @@ -194,6 +201,20 @@ private void runTests() throws IOException + String.format("%02d:%02d", minutes, seconds) + "."); } + private void runPackageTests() throws IOException + { + System.out.println("Beginning package tests..\n"); + + testInputFiles = TestUtils.getTestInputFiles(new File(PackageTest.ROOT)); + resultFiles = TestUtils.getFiles(new File(PackageTest.ROOT), RESULT_FILE_EXTENSION); + + runTests(testInputFiles, resultFiles, new ExecutableSpecTestHandler(Release.VDM_10, Dialect.VDM_RT), false, "my.model"); + + System.out.println("\n********"); + System.out.println("Finished with package tests"); + System.out.println("********\n"); + } + private void runRtTests() throws IOException { System.out.println("Beginning RT tests..\n"); @@ -410,6 +431,12 @@ private void addPath(File f) public void runTests(List testInputFiles, List resultFiles, TestHandler testHandler, boolean printInput) throws IOException + { + runTests(testInputFiles, resultFiles, testHandler, printInput, null); + } + + public void runTests(List testInputFiles, List resultFiles, + TestHandler testHandler, boolean printInput, String rootPackage) throws IOException { if (testInputFiles.size() != resultFiles.size()) { @@ -444,7 +471,7 @@ public void runTests(List testInputFiles, List resultFiles, // Calculating the Java result: File file = resultFiles.get(i); - testHandler.writeGeneratedCode(parent, file); + testHandler.writeGeneratedCode(parent, file, rootPackage); boolean compileOk = JavaCommandLineCompiler.compile(parent, null); System.out.println("Test:" + testNumber + " (" + (1 + i) + "). Name: " + file.getName() diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExecutableSpecTestHandler.java b/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExecutableSpecTestHandler.java index 7c69b94511..723a1ac95e 100644 --- a/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExecutableSpecTestHandler.java +++ b/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExecutableSpecTestHandler.java @@ -28,6 +28,7 @@ import org.overture.ast.lex.Dialect; import org.overture.codegen.ir.CodeGenBase; import org.overture.codegen.ir.IRConstants; +import org.overture.codegen.utils.GeneralCodeGenUtils; import org.overture.config.Release; public class ExecutableSpecTestHandler extends EntryBasedTestHandler @@ -38,12 +39,10 @@ public ExecutableSpecTestHandler(Release release, Dialect dialect) } @Override - public void writeGeneratedCode(File parent, File resultFile) + public void writeGeneratedCode(File parent, File resultFile, String rootPackage) throws IOException { - injectArgIntoMainClassFile(parent, JAVA_ENTRY_CALL); - - List content = TestUtils.readJavaModulesFromResultFile(resultFile); + List content = TestUtils.readJavaModulesFromResultFile(resultFile, rootPackage); if (content.isEmpty()) { @@ -51,15 +50,22 @@ public void writeGeneratedCode(File parent, File resultFile) return; } + injectArgIntoMainClassFile(parent, rootPackage != null ? (rootPackage + "." + JAVA_ENTRY_CALL) : JAVA_ENTRY_CALL); + + if (rootPackage != null) + { + parent = new File(parent, GeneralCodeGenUtils.getFolderFromJavaRootPackage(rootPackage)); + } + parent.mkdirs(); - + + for (StringBuffer classCgStr : content) { String className = TestUtils.getJavaModuleName(classCgStr); - - + File out = null; - if(classCgStr.toString().contains("package quotes;")) + if(classCgStr.toString().contains("quotes;")) { out = new File(parent, "quotes"); } diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExpressionTestHandler.java b/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExpressionTestHandler.java index edf4d2ef8c..03dc06f5f6 100644 --- a/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExpressionTestHandler.java +++ b/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExpressionTestHandler.java @@ -37,7 +37,7 @@ public ExpressionTestHandler(Release release, Dialect dialect) super(release, dialect); } - public void writeGeneratedCode(File parent, File resultFile) + public void writeGeneratedCode(File parent, File resultFile, String rootPackage) throws IOException { String generatedExpression = readFromFile(resultFile); diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/NonExecutableSpecTestHandler.java b/core/codegen/src/test/java/org/overture/codegen/tests/utils/NonExecutableSpecTestHandler.java index cca104e55a..7eabbe5ebd 100644 --- a/core/codegen/src/test/java/org/overture/codegen/tests/utils/NonExecutableSpecTestHandler.java +++ b/core/codegen/src/test/java/org/overture/codegen/tests/utils/NonExecutableSpecTestHandler.java @@ -28,10 +28,10 @@ public class NonExecutableSpecTestHandler extends TestHandler { @Override - public void writeGeneratedCode(File parent, File resultFile) + public void writeGeneratedCode(File parent, File resultFile, String rootPackage) throws IOException { - List content = TestUtils.readJavaModulesFromResultFile(resultFile); + List content = TestUtils.readJavaModulesFromResultFile(resultFile, rootPackage); if (content.size() == 0) { diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/TestHandler.java b/core/codegen/src/test/java/org/overture/codegen/tests/utils/TestHandler.java index d70f9ebaaa..ddb27f9265 100644 --- a/core/codegen/src/test/java/org/overture/codegen/tests/utils/TestHandler.java +++ b/core/codegen/src/test/java/org/overture/codegen/tests/utils/TestHandler.java @@ -85,7 +85,7 @@ public void initVdmEnv() Settings.dialect = Dialect.VDM_PP; } - public abstract void writeGeneratedCode(File parent, File resultFile) + public abstract void writeGeneratedCode(File parent, File resultFile, String rootPackage) throws IOException; public void injectArgIntoMainClassFile(File parent, String argument) diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/TestUtils.java b/core/codegen/src/test/java/org/overture/codegen/tests/utils/TestUtils.java index d892dbe853..477b329ba1 100644 --- a/core/codegen/src/test/java/org/overture/codegen/tests/utils/TestUtils.java +++ b/core/codegen/src/test/java/org/overture/codegen/tests/utils/TestUtils.java @@ -97,7 +97,7 @@ public static String getJavaModuleName(StringBuffer moduleContent) return className; } - public static List readJavaModulesFromResultFile(File file) + public static List readJavaModulesFromResultFile(File file, String rootPackage) throws IOException { final char DELIMITER_CHAR = '#'; @@ -124,6 +124,7 @@ public static List readJavaModulesFromResultFile(File file) String[] quotes = dataStr.replace(QUOTES_INDICATOR, "").trim().split(","); JavaCodeGen javaCodeGen = new JavaCodeGen(); + javaCodeGen.getJavaSettings().setJavaRootPackage(rootPackage); for(String q : quotes) { From 92c915e63afa631210774fa0413314f31f691880 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Thu, 5 Mar 2015 23:51:44 +0100 Subject: [PATCH 227/323] Added three test to exercise generation to a user specified Java package --- .../package_specs/OneClassUsesQuotes | 12 ++++++ .../package_specs/OneClassUsesQuotes.result | 27 ++++++++++++ .../test/resources/package_specs/TwoClasses | 19 +++++++++ .../resources/package_specs/TwoClasses.result | 42 +++++++++++++++++++ .../resources/package_specs/UsesRuntimeLib | 11 +++++ .../package_specs/UsesRuntimeLib.result | 23 ++++++++++ 6 files changed, 134 insertions(+) create mode 100644 core/codegen/src/test/resources/package_specs/OneClassUsesQuotes create mode 100644 core/codegen/src/test/resources/package_specs/OneClassUsesQuotes.result create mode 100644 core/codegen/src/test/resources/package_specs/TwoClasses create mode 100644 core/codegen/src/test/resources/package_specs/TwoClasses.result create mode 100644 core/codegen/src/test/resources/package_specs/UsesRuntimeLib create mode 100644 core/codegen/src/test/resources/package_specs/UsesRuntimeLib.result diff --git a/core/codegen/src/test/resources/package_specs/OneClassUsesQuotes b/core/codegen/src/test/resources/package_specs/OneClassUsesQuotes new file mode 100644 index 0000000000..cd68ec8b7c --- /dev/null +++ b/core/codegen/src/test/resources/package_specs/OneClassUsesQuotes @@ -0,0 +1,12 @@ +class Entry + +operations + +public static Run : () ==> ? +Run () == +let q : = , + b = q +in + return b = q; + +end Entry \ No newline at end of file diff --git a/core/codegen/src/test/resources/package_specs/OneClassUsesQuotes.result b/core/codegen/src/test/resources/package_specs/OneClassUsesQuotes.result new file mode 100644 index 0000000000..7afc5bfdd9 --- /dev/null +++ b/core/codegen/src/test/resources/package_specs/OneClassUsesQuotes.result @@ -0,0 +1,27 @@ +package my.model; + +import org.overture.codegen.runtime.*; + +import java.util.*; + + +public class Entry { + public Entry() { + } + + public static Object Run() { + my.model.quotes.AQuote q = my.model.quotes.AQuote.getInstance(); + my.model.quotes.AQuote b = q; + + return Utils.equals(b, q); + } + + public String toString() { + return "Entry{}"; + } +} + +########## +*Quotes* +A +########## diff --git a/core/codegen/src/test/resources/package_specs/TwoClasses b/core/codegen/src/test/resources/package_specs/TwoClasses new file mode 100644 index 0000000000..86dac802a1 --- /dev/null +++ b/core/codegen/src/test/resources/package_specs/TwoClasses @@ -0,0 +1,19 @@ +class A + +instance variables + +public x : nat := 42; + +end A + +class Entry + +operations + +public static Run : () ==> ? +Run () == +let a = new A() +in + return a.x; + +end Entry \ No newline at end of file diff --git a/core/codegen/src/test/resources/package_specs/TwoClasses.result b/core/codegen/src/test/resources/package_specs/TwoClasses.result new file mode 100644 index 0000000000..6afda889fa --- /dev/null +++ b/core/codegen/src/test/resources/package_specs/TwoClasses.result @@ -0,0 +1,42 @@ +package my.model; + +import org.overture.codegen.runtime.*; + +import java.util.*; + + +public class A { + public Number x = 42L; + + public A() { + } + + public String toString() { + return "A{" + "x := " + Utils.toString(x) + "}"; + } +} + +########## +package my.model; + +import org.overture.codegen.runtime.*; + +import java.util.*; + + +public class Entry { + public Entry() { + } + + public static Object Run() { + A a = new A(); + + return a.x; + } + + public String toString() { + return "Entry{}"; + } +} + +########## diff --git a/core/codegen/src/test/resources/package_specs/UsesRuntimeLib b/core/codegen/src/test/resources/package_specs/UsesRuntimeLib new file mode 100644 index 0000000000..f47eacc24c --- /dev/null +++ b/core/codegen/src/test/resources/package_specs/UsesRuntimeLib @@ -0,0 +1,11 @@ +class Entry + +operations + +public static Run : () ==> ? +Run () == +let xs = [3,4,5] +in + return xs(3); + +end Entry \ No newline at end of file diff --git a/core/codegen/src/test/resources/package_specs/UsesRuntimeLib.result b/core/codegen/src/test/resources/package_specs/UsesRuntimeLib.result new file mode 100644 index 0000000000..a6cc8c7c8f --- /dev/null +++ b/core/codegen/src/test/resources/package_specs/UsesRuntimeLib.result @@ -0,0 +1,23 @@ +package my.model; + +import org.overture.codegen.runtime.*; + +import java.util.*; + + +public class Entry { + public Entry() { + } + + public static Object Run() { + VDMSeq xs = SeqUtil.seq(3L, 4L, 5L); + + return ((Number) Utils.get(xs, 3L)); + } + + public String toString() { + return "Entry{}"; + } +} + +########## From 5d954f2145d5bb7009539846c85c1755e6d8dc33 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Thu, 5 Mar 2015 23:54:20 +0100 Subject: [PATCH 228/323] Updated codegen utilities with functionality to support code generation to a user specified Java package This include: - Validation of a java package (using regex) - Constructing a folder that corresponds to the package --- .../codegen/utils/GeneralCodeGenUtils.java | 27 +++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/core/codegen/src/main/java/org/overture/codegen/utils/GeneralCodeGenUtils.java b/core/codegen/src/main/java/org/overture/codegen/utils/GeneralCodeGenUtils.java index 615eb84629..23a688369e 100644 --- a/core/codegen/src/main/java/org/overture/codegen/utils/GeneralCodeGenUtils.java +++ b/core/codegen/src/main/java/org/overture/codegen/utils/GeneralCodeGenUtils.java @@ -32,6 +32,7 @@ import java.io.OutputStream; import java.util.LinkedList; import java.util.List; +import java.util.regex.Pattern; import org.overture.ast.analysis.AnalysisException; import org.overture.ast.definitions.SClassDefinition; @@ -363,4 +364,30 @@ public static List getClassesToSkip(String userInput) return classesToSkip; } + + public static boolean isValidJavaPackage(String pack) + { + if(pack == null) + { + return false; + } + + pack = pack.trim(); + + Pattern pattern = Pattern.compile("^[a-zA-Z_\\$][\\w\\$]*(?:\\.[a-zA-Z_\\$][\\w\\$]*)*$"); + + return pattern.matcher(pack).matches(); + } + + public static String getFolderFromJavaRootPackage(String pack) + { + if(!isValidJavaPackage(pack)) + { + return null; + } + else + { + return pack.replaceAll("\\.", "/"); + } + } } From 08a43db26ce3839ae5405e345d36d647ae35448d Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Thu, 5 Mar 2015 23:54:54 +0100 Subject: [PATCH 229/323] Testing of regex used to validate a java package name --- .../org/overture/codegen/tests/UtilsTest.java | 58 +++++++++++++++++++ 1 file changed, 58 insertions(+) create mode 100644 core/codegen/src/test/java/org/overture/codegen/tests/UtilsTest.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/UtilsTest.java b/core/codegen/src/test/java/org/overture/codegen/tests/UtilsTest.java new file mode 100644 index 0000000000..5c302cab76 --- /dev/null +++ b/core/codegen/src/test/java/org/overture/codegen/tests/UtilsTest.java @@ -0,0 +1,58 @@ +package org.overture.codegen.tests; + +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; + +import org.junit.Test; +import org.overture.codegen.utils.GeneralCodeGenUtils; + +public class UtilsTest +{ + @Test + public void testValidPackage1() + { + assertTrue(GeneralCodeGenUtils.isValidJavaPackage("org.overture.codegen.tests")); + } + + @Test + public void testStartWithCapLetter() + { + assertTrue(GeneralCodeGenUtils.isValidJavaPackage("Hello.hello")); + } + + @Test + public void testEmptyPackage() + { + assertFalse(GeneralCodeGenUtils.isValidJavaPackage("")); + } + + @Test + public void testTwoDotsInPackage() + { + assertFalse(GeneralCodeGenUtils.isValidJavaPackage("org..overture")); + } + + @Test + public void testNoDotsPackage() + { + assertTrue(GeneralCodeGenUtils.isValidJavaPackage("myPackage")); + } + + @Test + public void spaceAroundPackage() + { + assertTrue(GeneralCodeGenUtils.isValidJavaPackage(" org.overture ")); + } + + @Test + public void spaceInPackage() + { + assertFalse(GeneralCodeGenUtils.isValidJavaPackage("org. overture")); + } + + @Test + public void testNumberNamePackage() + { + assertFalse(GeneralCodeGenUtils.isValidJavaPackage("2be.or.not.to.be")); + } +} From 4226025fdd4ab583e515c6656ae8db4edac0644d Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Thu, 5 Mar 2015 23:56:41 +0100 Subject: [PATCH 230/323] Added the root package to the Java settings --- .../overture/codegen/vdm2java/JavaSettings.java | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaSettings.java b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaSettings.java index 19124afe93..4478ad5ebc 100644 --- a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaSettings.java +++ b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaSettings.java @@ -24,17 +24,21 @@ import java.util.LinkedList; import java.util.List; +import org.overture.codegen.utils.GeneralCodeGenUtils; + public class JavaSettings { private boolean disableCloning; private List classesToSkip; private String vdmEntryExp; + private String javaRootPackage; public JavaSettings() { this.disableCloning = false; this.classesToSkip = new LinkedList(); this.vdmEntryExp = null; + this.javaRootPackage = null; } public List getClassesToSkip() @@ -69,4 +73,17 @@ public void setVdmEntryExp(String vdmLaunchConfigEntryExp) { this.vdmEntryExp = vdmLaunchConfigEntryExp; } + + public String getJavaRootPackage() + { + return javaRootPackage; + } + + public void setJavaRootPackage(String javaRootPackage) + { + if (GeneralCodeGenUtils.isValidJavaPackage(javaRootPackage)) + { + this.javaRootPackage = javaRootPackage; + } + } } From 886c5505e1b8c5d0449b8dd3f348c04b5e98e9e6 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Thu, 5 Mar 2015 23:57:53 +0100 Subject: [PATCH 231/323] Updated code generation of quotes to take the user specified Java package into account --- .../org/overture/codegen/vdm2java/JavaFormat.java | 15 +++++++++++++++ .../JavaTemplates/Expressions/QuoteLiteral.vm | 4 +++- .../main/resources/JavaTemplates/Types/Quote.vm | 4 +++- 3 files changed, 21 insertions(+), 2 deletions(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaFormat.java b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaFormat.java index b76ce05112..972c494f34 100644 --- a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaFormat.java +++ b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaFormat.java @@ -87,6 +87,7 @@ import org.overture.codegen.cgast.types.SMapTypeCG; import org.overture.codegen.cgast.types.SSeqTypeCG; import org.overture.codegen.cgast.types.SSetTypeCG; +import org.overture.codegen.ir.CodeGenBase; import org.overture.codegen.ir.IRAnalysis; import org.overture.codegen.ir.IRInfo; import org.overture.codegen.ir.SourceNode; @@ -902,4 +903,18 @@ public static boolean isMainClass(AClassDeclCG clazz) { return clazz != null && clazz.getTag() instanceof JavaMainTag; } + + public String getQuotePackagePrefix() + { + String settings = getJavaSettings().getJavaRootPackage(); + + if(settings != null && !settings.trim().isEmpty()) + { + return settings + "." + CodeGenBase.QUOTES + "."; + } + else + { + return CodeGenBase.QUOTES + "."; + } + } } diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/QuoteLiteral.vm b/core/codegen/src/main/resources/JavaTemplates/Expressions/QuoteLiteral.vm index 606ff12007..aabd761627 100644 --- a/core/codegen/src/main/resources/JavaTemplates/Expressions/QuoteLiteral.vm +++ b/core/codegen/src/main/resources/JavaTemplates/Expressions/QuoteLiteral.vm @@ -1 +1,3 @@ -quotes.${node.getValue()}Quote.getInstance() \ No newline at end of file +#set( $packagePrefix = $JavaFormat.getQuotePackagePrefix() ) +## +${packagePrefix}${node.getValue()}Quote.getInstance() \ No newline at end of file diff --git a/core/codegen/src/main/resources/JavaTemplates/Types/Quote.vm b/core/codegen/src/main/resources/JavaTemplates/Types/Quote.vm index 4e0e39cead..9e1c93a417 100644 --- a/core/codegen/src/main/resources/JavaTemplates/Types/Quote.vm +++ b/core/codegen/src/main/resources/JavaTemplates/Types/Quote.vm @@ -1 +1,3 @@ -quotes.${node.getValue()}Quote \ No newline at end of file +#set( $packagePrefix = $JavaFormat.getQuotePackagePrefix() ) +## +${packagePrefix}${node.getValue()}Quote \ No newline at end of file From d333bca3bc4bb9eba4f30c7591eb62493b09ed8e Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Fri, 6 Mar 2015 00:00:35 +0100 Subject: [PATCH 232/323] Updated core/codegen to support code generation to a user specified Java package --- .../org/overture/codegen/vdm2java/JavaCodeGen.java | 12 +++++++++++- .../codegen/vdm2java/JavaQuoteValueCreator.java | 14 ++++++++++++-- 2 files changed, 23 insertions(+), 3 deletions(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java index 3958e403d4..c4c838cc43 100644 --- a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java +++ b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java @@ -170,7 +170,8 @@ public List generateJavaFromVdmQuotes() List modules = new LinkedList(); for(String quoteNameVdm : quoteValues) { - AClassDeclCG quoteDecl = quoteValueCreator.consQuoteValue(quoteNameVdm + JAVA_QUOTE_NAME_SUFFIX); + AClassDeclCG quoteDecl = quoteValueCreator.consQuoteValue(quoteNameVdm + + JAVA_QUOTE_NAME_SUFFIX, getJavaSettings().getJavaRootPackage()); StringWriter writer = new StringWriter(); quoteDecl.apply(javaFormat.getMergeVisitor(), writer); @@ -228,6 +229,15 @@ public GeneratedData generateJavaFromVdm( { statuses.add(generator.generateFrom(classDef)); } + + if(getJavaSettings().getJavaRootPackage() != null) + { + for(IRClassDeclStatus irStatus : statuses) + { + irStatus.getClassCg().setPackage(getJavaSettings().getJavaRootPackage()); + } + } + List classes = getClassDecls(statuses); javaFormat.setClasses(classes); diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaQuoteValueCreator.java b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaQuoteValueCreator.java index ae3cfb6bc5..427d7cf69d 100644 --- a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaQuoteValueCreator.java +++ b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaQuoteValueCreator.java @@ -26,6 +26,7 @@ import org.overture.codegen.ir.CodeGenBase; import org.overture.codegen.ir.IRInfo; import org.overture.codegen.trans.assistants.TransAssistantCG; +import org.overture.codegen.utils.GeneralCodeGenUtils; public class JavaQuoteValueCreator extends JavaClassCreatorBase { @@ -45,7 +46,7 @@ public JavaQuoteValueCreator(IRInfo info, TransAssistantCG transformationAssista this.transformationAssistant = transformationAssistant; } - public AClassDeclCG consQuoteValue(String name) + public AClassDeclCG consQuoteValue(String name, String userCodePackage) { AClassDeclCG decl = new AClassDeclCG(); decl.setAbstract(false); @@ -53,7 +54,16 @@ public AClassDeclCG consQuoteValue(String name) decl.setName(name); decl.setStatic(false); - decl.setPackage(CodeGenBase.QUOTES); + // The package where the quotes are put is userCode.quotes + if(GeneralCodeGenUtils.isValidJavaPackage(userCodePackage)) + { + String quotePackage = userCodePackage + "." + CodeGenBase.QUOTES; + decl.setPackage(quotePackage); + } + else + { + decl.setPackage(CodeGenBase.QUOTES); + } decl.getFields().add(consHashcodeField()); decl.getFields().add(consInstanceField(name)); From e0300e271364f4a9806831724a70cf8ab5b50812 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Fri, 6 Mar 2015 00:10:59 +0100 Subject: [PATCH 233/323] Issue #425. Updated the Java code generator plugin with support for code generation to a user specified package --- .../codegen/vdm2java/JavaSettings.java | 2 +- .../ide/plugins/codegen/Activator.java | 14 ++++- .../plugins/codegen/ICodeGenConstants.java | 4 +- .../codegen/commands/Vdm2JavaCommand.java | 8 +++ .../WorkbenchPreferencePageJavaCodeGen.java | 53 +++++++++++++++++-- 5 files changed, 74 insertions(+), 7 deletions(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaSettings.java b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaSettings.java index 4478ad5ebc..bd15d5948c 100644 --- a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaSettings.java +++ b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaSettings.java @@ -83,7 +83,7 @@ public void setJavaRootPackage(String javaRootPackage) { if (GeneralCodeGenUtils.isValidJavaPackage(javaRootPackage)) { - this.javaRootPackage = javaRootPackage; + this.javaRootPackage = javaRootPackage.trim(); } } } diff --git a/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/Activator.java b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/Activator.java index 471f3036b0..682fdda7f4 100644 --- a/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/Activator.java +++ b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/Activator.java @@ -98,16 +98,26 @@ protected void initializeDefaultPreferences(IPreferenceStore store) store.setDefault(ICodeGenConstants.DISABLE_CLONING, ICodeGenConstants.DISABLE_CLONING_DEFAULT); store.setDefault(ICodeGenConstants.GENERATE_CONCURRENCY_MECHANISMS, ICodeGenConstants.GENERATE_CONCURRENCY_MECHANISMS_DEFAULT); store.setDefault(ICodeGenConstants.CLASSES_TO_SKIP, ICodeGenConstants.CLASSES_TO_SKIP_DEFAULT); + store.setDefault(ICodeGenConstants.JAVA_PACKAGE, ICodeGenConstants.JAVA_PACKAGE_DEFAULT); } public static void savePluginSettings(boolean disableCloning, - boolean generateAsStrings, boolean generateConc, String userSpecifiedClassesToSkip) + boolean generateAsStrings, boolean generateConc, String userSpecifiedClassesToSkip, String javaPackage) { Preferences prefs = InstanceScope.INSTANCE.getNode(ICodeGenConstants.PLUGIN_ID); prefs.put(ICodeGenConstants.DISABLE_CLONING, new Boolean(disableCloning).toString()); prefs.put(ICodeGenConstants.GENERATE_CHAR_SEQUENCES_AS_STRINGS, new Boolean(generateAsStrings).toString()); prefs.put(ICodeGenConstants.GENERATE_CONCURRENCY_MECHANISMS, new Boolean(generateConc).toString()); - prefs.put(ICodeGenConstants.CLASSES_TO_SKIP, userSpecifiedClassesToSkip); + + if (userSpecifiedClassesToSkip != null) + { + prefs.put(ICodeGenConstants.CLASSES_TO_SKIP, userSpecifiedClassesToSkip); + } + + if (javaPackage != null) + { + prefs.put(ICodeGenConstants.JAVA_PACKAGE, javaPackage); + } try { diff --git a/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/ICodeGenConstants.java b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/ICodeGenConstants.java index be57f008ba..8bc1101c2d 100644 --- a/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/ICodeGenConstants.java +++ b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/ICodeGenConstants.java @@ -38,5 +38,7 @@ public interface ICodeGenConstants public static final String CLASSES_TO_SKIP = PLUGIN_ID + ".classes_to_skip"; public static final String CLASSES_TO_SKIP_DEFAULT = ""; - + + public static final String JAVA_PACKAGE = PLUGIN_ID + ".java_package"; + public static final String JAVA_PACKAGE_DEFAULT = ""; } diff --git a/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaCommand.java b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaCommand.java index b7ac42e5d9..ee7aeee400 100644 --- a/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaCommand.java +++ b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaCommand.java @@ -318,10 +318,18 @@ public JavaSettings getJavaSettings(final IProject project, List classes Preferences preferences = InstanceScope.INSTANCE.getNode(ICodeGenConstants.PLUGIN_ID); boolean disableCloning = preferences.getBoolean(ICodeGenConstants.DISABLE_CLONING, ICodeGenConstants.DISABLE_CLONING_DEFAULT); + String javaPackage = preferences.get(ICodeGenConstants.JAVA_PACKAGE, ICodeGenConstants.JAVA_PACKAGE_DEFAULT); JavaSettings javaSettings = new JavaSettings(); javaSettings.setDisableCloning(disableCloning); javaSettings.setClassesToSkip(classesToSkip); + javaSettings.setJavaRootPackage(javaPackage); + + if (!GeneralCodeGenUtils.isValidJavaPackage(javaSettings.getJavaRootPackage())) + { + javaSettings.setJavaRootPackage(project.getName()); + + } return javaSettings; } diff --git a/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/preferences/WorkbenchPreferencePageJavaCodeGen.java b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/preferences/WorkbenchPreferencePageJavaCodeGen.java index 77b8d58dbb..e09d7429e3 100644 --- a/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/preferences/WorkbenchPreferencePageJavaCodeGen.java +++ b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/preferences/WorkbenchPreferencePageJavaCodeGen.java @@ -31,10 +31,14 @@ import org.eclipse.swt.widgets.Composite; import org.eclipse.swt.widgets.Control; import org.eclipse.swt.widgets.Label; +import org.eclipse.swt.widgets.MessageBox; +import org.eclipse.swt.widgets.Shell; import org.eclipse.swt.widgets.Text; import org.eclipse.ui.IWorkbench; import org.eclipse.ui.IWorkbenchPreferencePage; +import org.eclipse.ui.PlatformUI; import org.osgi.service.prefs.Preferences; +import org.overture.codegen.utils.GeneralCodeGenUtils; import org.overture.ide.plugins.codegen.Activator; import org.overture.ide.plugins.codegen.ICodeGenConstants; import org.overture.ide.plugins.codegen.util.PluginVdm2JavaUtil; @@ -46,7 +50,8 @@ public class WorkbenchPreferencePageJavaCodeGen extends PreferencePage implement private Button generateAsStrCheckBox; private Button generateConcMechanismsCheckBox; private Text classesToSkipField; - + private Text packageField; + @Override protected IPreferenceStore doGetPreferenceStore() { @@ -68,6 +73,15 @@ protected Control createContents(Composite parent) generateConcMechanismsCheckBox = new Button(composite, SWT.CHECK); generateConcMechanismsCheckBox.setText("Generate concurrency mechanisms"); + Label packageLabel = new Label(composite, SWT.NULL); + packageLabel.setText("Output package of the generated Java code (e.g. my.pack)"); + final GridData gridData2 = new GridData(); + gridData2.horizontalAlignment = GridData.FILL; + gridData2.verticalAlignment = GridData.FILL; + packageField = new Text(composite, SWT.BORDER); + packageField.setLayoutData(gridData2); + packageField.setText(""); + GridData gridData = new GridData(); gridData.horizontalAlignment = GridData.FILL; gridData.verticalAlignment = GridData.FILL; @@ -114,8 +128,32 @@ private void apply() String userSpecifiedClassesToSkip = classesToSkipField.getText(); store.setDefault(ICodeGenConstants.CLASSES_TO_SKIP, userSpecifiedClassesToSkip); + + String javaPackage = packageField.getText().trim(); + + if(javaPackage.isEmpty()) + { + // The project name will be used as the package + } + else if(GeneralCodeGenUtils.isValidJavaPackage(javaPackage)) + { + store.setDefault(ICodeGenConstants.JAVA_PACKAGE, javaPackage); + } + else + { + Shell shell = PlatformUI.getWorkbench().getDisplay().getActiveShell(); + MessageBox messageBox = new MessageBox(shell, SWT.ICON_WARNING + | SWT.OK); + + messageBox.setText("Not a valid Java package!"); + messageBox.setMessage("Please specify a valid java package (e.g. my.pack)."); + messageBox.open(); + + // To indicate that we do not want the user specified package to be saved + javaPackage = null; + } - Activator.savePluginSettings(disableCloning, generateAsStrings, generateConcMechanisms, userSpecifiedClassesToSkip);; + Activator.savePluginSettings(disableCloning, generateAsStrings, generateConcMechanisms, userSpecifiedClassesToSkip, javaPackage); refreshControls(); } @@ -144,6 +182,11 @@ protected void performDefaults() { classesToSkipField.setText(ICodeGenConstants.CLASSES_TO_SKIP_DEFAULT); } + + if(packageField != null) + { + packageField.setText(ICodeGenConstants.JAVA_PACKAGE_DEFAULT); + } } @Override @@ -175,6 +218,10 @@ private void refreshControls() { classesToSkipField.setText(preferences.get(ICodeGenConstants.CLASSES_TO_SKIP, ICodeGenConstants.CLASSES_TO_SKIP_DEFAULT)); } + + if(packageField != null) + { + packageField.setText(preferences.get(ICodeGenConstants.JAVA_PACKAGE, ICodeGenConstants.JAVA_PACKAGE_DEFAULT)); + } } - } \ No newline at end of file From 9e6f11ce598b1c4ea35566b00d01ae4c1de564bc Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Fri, 6 Mar 2015 09:54:28 +0100 Subject: [PATCH 234/323] Added a test to exercise record use across classes when the user code is output to a user specified java package --- .../RecordUsageAcrossClassSimple | 19 ++++++ .../RecordUsageAcrossClassSimple.result | 68 +++++++++++++++++++ 2 files changed, 87 insertions(+) create mode 100644 core/codegen/src/test/resources/package_specs/RecordUsageAcrossClassSimple create mode 100644 core/codegen/src/test/resources/package_specs/RecordUsageAcrossClassSimple.result diff --git a/core/codegen/src/test/resources/package_specs/RecordUsageAcrossClassSimple b/core/codegen/src/test/resources/package_specs/RecordUsageAcrossClassSimple new file mode 100644 index 0000000000..a0065ff180 --- /dev/null +++ b/core/codegen/src/test/resources/package_specs/RecordUsageAcrossClassSimple @@ -0,0 +1,19 @@ +class A + +types + +public +Rec :: + n : int; + +end A + +class Entry + +operations + +public static Run : () ==> ? +Run () == + return mk_A`Rec(15).n; + +end Entry \ No newline at end of file diff --git a/core/codegen/src/test/resources/package_specs/RecordUsageAcrossClassSimple.result b/core/codegen/src/test/resources/package_specs/RecordUsageAcrossClassSimple.result new file mode 100644 index 0000000000..5642aa0ee3 --- /dev/null +++ b/core/codegen/src/test/resources/package_specs/RecordUsageAcrossClassSimple.result @@ -0,0 +1,68 @@ +package my.model; + +import org.overture.codegen.runtime.*; + +import java.util.*; + + +public class A { + public A() { + } + + public String toString() { + return "A{}"; + } + + public static class Rec implements Record { + public Number n; + + public Rec(final Number _n) { + n = _n; + } + + public boolean equals(final Object obj) { + if (!(obj instanceof Rec)) { + return false; + } + + Rec other = ((Rec) obj); + + return Utils.equals(n, other.n); + } + + public int hashCode() { + return Utils.hashCode(n); + } + + public Rec clone() { + return new Rec(n); + } + + public String toString() { + return "mk_A`Rec" + Utils.formatFields(n); + } + } +} + +########## +package my.model; + +import org.overture.codegen.runtime.*; + +import java.util.*; + + +public class Entry { + public Entry() { + } + + public static Object Run() { + return new A.Rec(15L).n; + } + + public String toString() { + return "Entry{}"; + } +} + +########## From 5f9c27c67f51d2fc9759979da041ebf8bc330001 Mon Sep 17 00:00:00 2001 From: Kenneth Lausdahl Date: Fri, 6 Mar 2015 11:43:44 +0100 Subject: [PATCH 235/323] updated the io package native part with sprintf --- core/interpreter/src/main/java/IO.java | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/core/interpreter/src/main/java/IO.java b/core/interpreter/src/main/java/IO.java index 8347682541..d01a582a86 100644 --- a/core/interpreter/src/main/java/IO.java +++ b/core/interpreter/src/main/java/IO.java @@ -231,6 +231,13 @@ public static Value printf(Value fv, Value vs) throws ValueException Console.out.flush(); return new VoidValue(); } + + public static Value sprintf(Value fv, Value vs) throws ValueException + { + String format = stringOf(fv); + ValueList values = vs.seqValue(null); + return new SeqValue(String.format(format, values.toArray())); + } public static Value toString(Value v) { From 2657aea19ccf3265e4f0d5de82906d5b5b75cc08 Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Fri, 6 Mar 2015 17:48:53 +0100 Subject: [PATCH 236/323] Use new leaf extension mechanism. Seems to be working for now... --- core/cgisa/pom.xml | 4 ++-- .../org/overturetool/cgisa/transformations/GroupMutRecs.java | 4 ++-- core/cgisa/src/main/resources/isacg.ast | 5 +++-- core/codegen/pom.xml | 2 +- 4 files changed, 8 insertions(+), 7 deletions(-) diff --git a/core/cgisa/pom.xml b/core/cgisa/pom.xml index d0e38a673d..d46b150f52 100644 --- a/core/cgisa/pom.xml +++ b/core/cgisa/pom.xml @@ -57,7 +57,7 @@ - org.overture.astcreator + org.overturetool.astcreator astcreator-plugin ${astcreator.version} @@ -72,7 +72,7 @@ cg.astv2 isacg.ast - Ext + Isa true false diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/transformations/GroupMutRecs.java b/core/cgisa/src/main/java/org/overturetool/cgisa/transformations/GroupMutRecs.java index b7744ccb69..79178b4700 100644 --- a/core/cgisa/src/main/java/org/overturetool/cgisa/transformations/GroupMutRecs.java +++ b/core/cgisa/src/main/java/org/overturetool/cgisa/transformations/GroupMutRecs.java @@ -1,10 +1,10 @@ package org.overturetool.cgisa.transformations; +import org.overture.cgisa.extast.analysis.DepthFirstAnalysisIsaAdaptor; import org.overture.cgisa.extast.declarations.AExtClassDeclCG; import org.overture.codegen.cgast.analysis.AnalysisException; -import org.overturetool.cgisa.extast.analysis.DepthFirstAnalysisExtAdaptor; -public class GroupMutRecs extends DepthFirstAnalysisExtAdaptor +public class GroupMutRecs extends DepthFirstAnalysisIsaAdaptor { diff --git a/core/cgisa/src/main/resources/isacg.ast b/core/cgisa/src/main/resources/isacg.ast index 581cd1f109..3a4ef5b4cb 100644 --- a/core/cgisa/src/main/resources/isacg.ast +++ b/core/cgisa/src/main/resources/isacg.ast @@ -1,7 +1,7 @@ Packages -base org.overturetool.cgisa.extast.node; -analysis org.overturetool.cgisa.extast.analysis; +base org.overture.cgisa.extast.node; +analysis org.overture.cgisa.extast.analysis; Tokens @@ -18,4 +18,5 @@ CG = #decl [mutrecfuncs]:CG.#decl.mrFuncGroup* | {extClass} [baseClass]:CG.#decl.class + [mutrecfuncs]:CG.#decl.mrFuncGroup* ; \ No newline at end of file diff --git a/core/codegen/pom.xml b/core/codegen/pom.xml index 2a3ce708cc..1e2c528c4c 100644 --- a/core/codegen/pom.xml +++ b/core/codegen/pom.xml @@ -13,7 +13,7 @@ VDM Code Generator - 1.6.4 + 1.6.7-SNAPSHOT From ec5140faa0700186fe0f1a5b790efcb302f55df1 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Fri, 6 Mar 2015 19:08:23 +0100 Subject: [PATCH 237/323] Added convenience methods to access different folders in the generated Eclipse project --- .../codegen/commands/AboutCommand.java | 4 +- .../codegen/util/PluginVdm2JavaUtil.java | 67 +++++++++++++------ 2 files changed, 47 insertions(+), 24 deletions(-) diff --git a/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/AboutCommand.java b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/AboutCommand.java index cae7db51c4..fa67ffeaee 100644 --- a/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/AboutCommand.java +++ b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/AboutCommand.java @@ -47,9 +47,9 @@ public Object execute(ExecutionEvent event) throws ExecutionException Shell shell = HandlerUtil.getActiveWorkbenchWindow(event).getShell(); String title = "VDM++ to Java Code Generator"; String about = GeneralUtils.readFromInputStream(fileStream).toString(); - about = String.format(about, PluginVdm2JavaUtil.CODEGEN_RUNTIME_BIN_FILE_NAME, + about = String.format(about, PluginVdm2JavaUtil.CODEGEN_RUNTIME_BIN_FILE, PluginVdm2JavaUtil.CODEGEN_RUNTIME_SOURCES_FILE_NAME, - PluginVdm2JavaUtil.CODEGEN_RUNTIME_LIB_FOLDER_NAME); + PluginVdm2JavaUtil.CODEGEN_RUNTIME_LIB_FOLDER); MessageDialog.openInformation(shell, title, about); diff --git a/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/util/PluginVdm2JavaUtil.java b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/util/PluginVdm2JavaUtil.java index 1c8a12763f..e15e735220 100644 --- a/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/util/PluginVdm2JavaUtil.java +++ b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/util/PluginVdm2JavaUtil.java @@ -60,6 +60,7 @@ import org.overture.codegen.ir.VdmNodeInfo; import org.overture.codegen.utils.GeneralCodeGenUtils; import org.overture.codegen.vdm2java.JavaCodeGenUtil; +import org.overture.codegen.vdm2java.JavaSettings; import org.overture.ide.core.resources.IVdmProject; import org.overture.ide.core.resources.IVdmSourceUnit; import org.overture.ide.core.utility.FileUtility; @@ -70,18 +71,21 @@ public class PluginVdm2JavaUtil { - public static final String JAVA_FOLDER = "java"; public static final String QUOTES_FOLDER = "quotes"; public static final String UTILS_FOLDER = "utils"; - public static final String CODEGEN_RUNTIME_BIN_FILE_NAME = "codegen-runtime.jar"; - public static final String CODEGEN_RUNTIME_SOURCES_FILE_NAME = "codegen-runtime-sources.jar"; - public static final String ECLIPSE_CLASSPATH_TEMPLATE_FILE_NAME = "cg.classpath"; - public static final String ECLIPSE_PROJECT_TEMPLATE_FILE_NAME = "cg.project"; - public static final String ECLIPSE_CLASSPATH_FILE_NAME = ".classpath"; - public static final String ECLIPSE_PROJECT_FILE_NAME = ".project"; - public static final String ECLIPSE_RES_FILES_FOLDER_NAME = "eclipsefiles"; - public static final String CODEGEN_RUNTIME_SRC_FOLDER_NAME = "src"; - public static final String CODEGEN_RUNTIME_LIB_FOLDER_NAME = "lib"; + + public static final String CODEGEN_RUNTIME_BIN_FILE = "codegen-runtime.jar"; + public static final String CODEGEN_RUNTIME_SOURCES_FILE = "codegen-runtime-sources.jar"; + public static final String CODEGEN_RUNTIME_LIB_FOLDER = "lib"; + + public static final String ECLIPSE_CLASSPATH_TEMPLATE_FILE = "cg.classpath"; + public static final String ECLIPSE_PROJECT_TEMPLATE_FILE = "cg.project"; + + public static final String ECLIPSE_PROJECT_ROOT_FOLDER = "java"; + public static final String ECLIPSE_CLASSPATH_FILE = ".classpath"; + public static final String ECLIPSE_PROJECT_FILE = ".project"; + public static final String ECLIPSE_RES_FILES_FOLDER = "eclipsefiles"; + public static final String ECLIPSE_PROJECT_SRC_FOLDER = "src"; private PluginVdm2JavaUtil() { @@ -91,9 +95,9 @@ public static IFile convert(File file) { IWorkspace workspace = ResourcesPlugin.getWorkspace(); IPath location = Path.fromOSString(file.getAbsolutePath()); - IFile ifile = workspace.getRoot().getFileForLocation(location); + IFile iFile = workspace.getRoot().getFileForLocation(location); - return ifile; + return iFile; } public static boolean isSupportedVdmDialect(IVdmProject vdmProject) @@ -145,24 +149,42 @@ public static List mergeParseLists( return mergedParseLists; } - public static File getOutputFolder(IVdmProject project) + public static File getEclipseProjectFolder(IVdmProject project) + { + return new File(getProjectDir(project), ECLIPSE_PROJECT_ROOT_FOLDER); + } + + + public static File getCodeGenRuntimeLibFolder(IVdmProject project) + { + return getFolder(getEclipseProjectFolder(project), CODEGEN_RUNTIME_LIB_FOLDER); + } + + public static File getJavaCodeOutputFolder(IVdmProject project, JavaSettings settings) throws CoreException { - File outputDir = getProjectDir(project); - outputDir = new File(outputDir, JAVA_FOLDER); - outputDir.mkdirs(); + File outputDir = getEclipseProjectFolder(project); + outputDir = getFolder(outputDir, ECLIPSE_PROJECT_SRC_FOLDER); + + String javaPackage = settings.getJavaRootPackage(); + if(GeneralCodeGenUtils.isValidJavaPackage(javaPackage)) + { + outputDir = getFolder(outputDir, GeneralCodeGenUtils + .getFolderFromJavaRootPackage(javaPackage)); + } + return outputDir; } - public static File getQuotesFolder(IVdmProject project) + public static File getQuotesFolder(IVdmProject project, JavaSettings settings) throws CoreException { - return getFolder(getOutputFolder(project), QUOTES_FOLDER); + return getFolder(getJavaCodeOutputFolder(project, settings), QUOTES_FOLDER); } - public static File getUtilsFolder(IVdmProject project) throws CoreException + public static File getUtilsFolder(IVdmProject project, JavaSettings settings) throws CoreException { - return getFolder(getOutputFolder(project), UTILS_FOLDER); + return getFolder(getJavaCodeOutputFolder(project, settings), UTILS_FOLDER); } public static void addMarkers(String generalMessage, @@ -172,7 +194,7 @@ public static void addMarkers(String generalMessage, for (Violation violation : list) { - IFile ifile = PluginVdm2JavaUtil.convert(violation.getLocation().getFile()); + IFile ifile = convert(violation.getLocation().getFile()); FileUtility.addMarker(ifile, generalMessage + ": " + violation.getDescripton(), violation.getLocation(), IMarker.PRIORITY_NORMAL, ICodeGenConstants.PLUGIN_ID, -1); } @@ -241,7 +263,7 @@ public static void addMarkers(VdmNodeInfo nodeInfo, return; } - IFile ifile = PluginVdm2JavaUtil.convert(location.getFile()); + IFile ifile = convert(location.getFile()); String reason = nodeInfo.getReason(); @@ -261,6 +283,7 @@ private static File getFolder(File parent, String folder) { File resultingFolder = new File(parent, folder); resultingFolder.mkdirs(); + return resultingFolder; } From 111f7147d686077927e9b7a47706c6a71aad0875 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Fri, 6 Mar 2015 19:27:07 +0100 Subject: [PATCH 238/323] Issue #425. Made the folder structure of the generated Eclipse project conform to the user specified package --- .../codegen/commands/AboutCommand.java | 2 +- .../codegen/commands/Vdm2JavaCommand.java | 38 +++++++++---------- 2 files changed, 20 insertions(+), 20 deletions(-) diff --git a/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/AboutCommand.java b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/AboutCommand.java index fa67ffeaee..9aade690de 100644 --- a/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/AboutCommand.java +++ b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/AboutCommand.java @@ -48,7 +48,7 @@ public Object execute(ExecutionEvent event) throws ExecutionException String title = "VDM++ to Java Code Generator"; String about = GeneralUtils.readFromInputStream(fileStream).toString(); about = String.format(about, PluginVdm2JavaUtil.CODEGEN_RUNTIME_BIN_FILE, - PluginVdm2JavaUtil.CODEGEN_RUNTIME_SOURCES_FILE_NAME, + PluginVdm2JavaUtil.CODEGEN_RUNTIME_SOURCES_FILE, PluginVdm2JavaUtil.CODEGEN_RUNTIME_LIB_FOLDER); MessageDialog.openInformation(shell, title, about); diff --git a/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaCommand.java b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaCommand.java index ee7aeee400..b6bb80be3d 100644 --- a/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaCommand.java +++ b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaCommand.java @@ -178,10 +178,10 @@ protected IStatus run(IProgressMonitor monitor) try { - File outputFolder = PluginVdm2JavaUtil.getOutputFolder(vdmProject); + File javaCodeOutputFolder = PluginVdm2JavaUtil.getJavaCodeOutputFolder(vdmProject, javaSettings); // Clean folder with generated Java code - GeneralUtils.deleteFolderContents(outputFolder); + GeneralUtils.deleteFolderContents(javaCodeOutputFolder); // Generate user specified classes GeneratedData generatedData = vdm2java.generateJavaFromVdm(mergedParseLists); @@ -189,11 +189,9 @@ protected IStatus run(IProgressMonitor monitor) outputUserSpecifiedSkippedClasses(classesToSkip); outputSkippedClasses(generatedData.getSkippedClasses()); - File javaOutputFolder = new File(outputFolder, PluginVdm2JavaUtil.CODEGEN_RUNTIME_SRC_FOLDER_NAME); - try { - vdm2java.generateJavaSourceFiles(javaOutputFolder, generatedData.getClasses()); + vdm2java.generateJavaSourceFiles(javaCodeOutputFolder, generatedData.getClasses()); } catch (Exception e) { CodeGenConsole.GetInstance().printErrorln("Problems saving the code generated Java source files to disk."); @@ -210,37 +208,39 @@ protected IStatus run(IProgressMonitor monitor) return Status.CANCEL_STATUS; } - File libFolder = new File(outputFolder, PluginVdm2JavaUtil.CODEGEN_RUNTIME_LIB_FOLDER_NAME); + File libFolder = PluginVdm2JavaUtil.getCodeGenRuntimeLibFolder(vdmProject); + try { - PluginVdm2JavaUtil.copyCodeGenFile(PluginVdm2JavaUtil.CODEGEN_RUNTIME_BIN_FILE_NAME, libFolder); + PluginVdm2JavaUtil.copyCodeGenFile(PluginVdm2JavaUtil.CODEGEN_RUNTIME_BIN_FILE, libFolder); outputRuntimeBinaries(libFolder); } catch(Exception e) { - CodeGenConsole.GetInstance().printErrorln("Problems copying the Java code generator runtime library to " + outputFolder.getAbsolutePath()); + CodeGenConsole.GetInstance().printErrorln("Problems copying the Java code generator runtime library to " + libFolder.getAbsolutePath()); CodeGenConsole.GetInstance().printErrorln("Reason: " + e.getMessage()); } try { - PluginVdm2JavaUtil.copyCodeGenFile(PluginVdm2JavaUtil.CODEGEN_RUNTIME_SOURCES_FILE_NAME, libFolder); + PluginVdm2JavaUtil.copyCodeGenFile(PluginVdm2JavaUtil.CODEGEN_RUNTIME_SOURCES_FILE, libFolder); outputRuntimeSources(libFolder); } catch(Exception e) { - CodeGenConsole.GetInstance().printErrorln("Problems copying the Java code generator runtime library sources to " + outputFolder.getAbsolutePath()); + CodeGenConsole.GetInstance().printErrorln("Problems copying the Java code generator runtime library sources to " + libFolder.getAbsolutePath()); CodeGenConsole.GetInstance().printErrorln("Reason: " + e.getMessage()); } try { - PluginVdm2JavaUtil.copyCodeGenFile(PluginVdm2JavaUtil.ECLIPSE_RES_FILES_FOLDER_NAME + "/" - + PluginVdm2JavaUtil.ECLIPSE_PROJECT_TEMPLATE_FILE_NAME, PluginVdm2JavaUtil.ECLIPSE_PROJECT_FILE_NAME, outputFolder); - PluginVdm2JavaUtil.copyCodeGenFile(PluginVdm2JavaUtil.ECLIPSE_RES_FILES_FOLDER_NAME + "/" - + PluginVdm2JavaUtil.ECLIPSE_CLASSPATH_TEMPLATE_FILE_NAME, PluginVdm2JavaUtil.ECLIPSE_CLASSPATH_FILE_NAME, outputFolder); + File eclipseProjectFolder = PluginVdm2JavaUtil.getEclipseProjectFolder(vdmProject); + PluginVdm2JavaUtil.copyCodeGenFile(PluginVdm2JavaUtil.ECLIPSE_RES_FILES_FOLDER + "/" + + PluginVdm2JavaUtil.ECLIPSE_PROJECT_TEMPLATE_FILE, PluginVdm2JavaUtil.ECLIPSE_PROJECT_FILE, eclipseProjectFolder); + PluginVdm2JavaUtil.copyCodeGenFile(PluginVdm2JavaUtil.ECLIPSE_RES_FILES_FOLDER + "/" + + PluginVdm2JavaUtil.ECLIPSE_CLASSPATH_TEMPLATE_FILE, PluginVdm2JavaUtil.ECLIPSE_CLASSPATH_FILE, eclipseProjectFolder); - GeneralCodeGenUtils.replaceInFile(new File(outputFolder, PluginVdm2JavaUtil.ECLIPSE_PROJECT_FILE_NAME), "%s", project.getName()); + GeneralCodeGenUtils.replaceInFile(new File(eclipseProjectFolder, PluginVdm2JavaUtil.ECLIPSE_PROJECT_FILE), "%s", project.getName()); CodeGenConsole.GetInstance().println("Generated Eclipse project with Java generated code.\n"); @@ -252,10 +252,10 @@ protected IStatus run(IProgressMonitor monitor) + e.getMessage()); } - outputUserspecifiedModules(javaOutputFolder, generatedData.getClasses()); + outputUserspecifiedModules(javaCodeOutputFolder, generatedData.getClasses()); // Quotes generation - outputQuotes(vdmProject, new File(javaOutputFolder, PluginVdm2JavaUtil.QUOTES_FOLDER), + outputQuotes(vdmProject, new File(javaCodeOutputFolder, PluginVdm2JavaUtil.QUOTES_FOLDER), vdm2java, generatedData.getQuoteValues()); // Renaming of variables shadowing other variables @@ -404,13 +404,13 @@ private void outputRenamings(List allRenamings) private void outputRuntimeBinaries(File outputFolder) { - File runtime = new File(outputFolder, PluginVdm2JavaUtil.CODEGEN_RUNTIME_BIN_FILE_NAME); + File runtime = new File(outputFolder, PluginVdm2JavaUtil.CODEGEN_RUNTIME_BIN_FILE); CodeGenConsole.GetInstance().println("Copied the Java code generator runtime library to " + runtime.getAbsolutePath()); } private void outputRuntimeSources(File outputFolder) { - File runtime = new File(outputFolder, PluginVdm2JavaUtil.CODEGEN_RUNTIME_SOURCES_FILE_NAME); + File runtime = new File(outputFolder, PluginVdm2JavaUtil.CODEGEN_RUNTIME_SOURCES_FILE); CodeGenConsole.GetInstance().println("Copied the Java code generator runtime library sources to " + runtime.getAbsolutePath() + "\n"); } From 69cd9eaefe9ea82d35a9c874cddc9d1e546f148f Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Fri, 6 Mar 2015 20:04:37 +0100 Subject: [PATCH 239/323] Clear the generated eclipse project folder prior to code generation --- .../ide/plugins/codegen/commands/Vdm2JavaCommand.java | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaCommand.java b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaCommand.java index b6bb80be3d..c85fb1fa27 100644 --- a/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaCommand.java +++ b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaCommand.java @@ -178,10 +178,10 @@ protected IStatus run(IProgressMonitor monitor) try { - File javaCodeOutputFolder = PluginVdm2JavaUtil.getJavaCodeOutputFolder(vdmProject, javaSettings); - + File eclipseProjectFolder = PluginVdm2JavaUtil.getEclipseProjectFolder(vdmProject); + // Clean folder with generated Java code - GeneralUtils.deleteFolderContents(javaCodeOutputFolder); + GeneralUtils.deleteFolderContents(eclipseProjectFolder); // Generate user specified classes GeneratedData generatedData = vdm2java.generateJavaFromVdm(mergedParseLists); @@ -189,6 +189,8 @@ protected IStatus run(IProgressMonitor monitor) outputUserSpecifiedSkippedClasses(classesToSkip); outputSkippedClasses(generatedData.getSkippedClasses()); + File javaCodeOutputFolder = PluginVdm2JavaUtil.getJavaCodeOutputFolder(vdmProject, javaSettings); + try { vdm2java.generateJavaSourceFiles(javaCodeOutputFolder, generatedData.getClasses()); @@ -234,7 +236,6 @@ protected IStatus run(IProgressMonitor monitor) try { - File eclipseProjectFolder = PluginVdm2JavaUtil.getEclipseProjectFolder(vdmProject); PluginVdm2JavaUtil.copyCodeGenFile(PluginVdm2JavaUtil.ECLIPSE_RES_FILES_FOLDER + "/" + PluginVdm2JavaUtil.ECLIPSE_PROJECT_TEMPLATE_FILE, PluginVdm2JavaUtil.ECLIPSE_PROJECT_FILE, eclipseProjectFolder); PluginVdm2JavaUtil.copyCodeGenFile(PluginVdm2JavaUtil.ECLIPSE_RES_FILES_FOLDER + "/" From 082f50fc1fb4dc2c3e9ea4a5d786e0fe0311c316 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Fri, 6 Mar 2015 21:19:23 +0100 Subject: [PATCH 240/323] Fix for the naming of the Java file used to store a code generated quote --- .../codegen/utils/GeneralCodeGenUtils.java | 17 +++++++++++++++++ .../overture/codegen/utils/GeneralUtils.java | 13 +++++++++---- .../overture/codegen/vdm2java/JavaCodeGen.java | 12 ++++++++++-- .../codegen/tests/utils/CompileTests.java | 2 +- .../codegen/commands/Vdm2JavaCommand.java | 2 +- 5 files changed, 38 insertions(+), 8 deletions(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/utils/GeneralCodeGenUtils.java b/core/codegen/src/main/java/org/overture/codegen/utils/GeneralCodeGenUtils.java index 23a688369e..6995943c52 100644 --- a/core/codegen/src/main/java/org/overture/codegen/utils/GeneralCodeGenUtils.java +++ b/core/codegen/src/main/java/org/overture/codegen/utils/GeneralCodeGenUtils.java @@ -44,8 +44,11 @@ import org.overture.ast.typechecker.NameScope; import org.overture.ast.types.AVoidType; import org.overture.ast.util.definitions.ClassList; +import org.overture.codegen.cgast.SDeclCG; +import org.overture.codegen.cgast.declarations.AClassDeclCG; import org.overture.codegen.ir.ITempVarGen; import org.overture.codegen.logging.Logger; +import org.overture.codegen.vdm2java.JavaCodeGen; import org.overture.parser.lex.LexException; import org.overture.parser.lex.LexTokenReader; import org.overture.parser.messages.Console; @@ -390,4 +393,18 @@ public static String getFolderFromJavaRootPackage(String pack) return pack.replaceAll("\\.", "/"); } } + + public static boolean isQuote(SDeclCG decl) + { + if(decl instanceof AClassDeclCG) + { + AClassDeclCG clazz = (AClassDeclCG) decl; + + return clazz.getPackage() != null && clazz.getPackage().endsWith("." + JavaCodeGen.QUOTES); + } + else + { + return false; + } + } } diff --git a/core/codegen/src/main/java/org/overture/codegen/utils/GeneralUtils.java b/core/codegen/src/main/java/org/overture/codegen/utils/GeneralUtils.java index afe9a4aa69..b027ad6665 100644 --- a/core/codegen/src/main/java/org/overture/codegen/utils/GeneralUtils.java +++ b/core/codegen/src/main/java/org/overture/codegen/utils/GeneralUtils.java @@ -138,13 +138,13 @@ public static List getFilesFromPaths(String[] args) return files; } - public static void deleteFolderContents(File folder) + public static void deleteFolderContents(File folder, boolean removeFolders) { - deleteFolderContents(folder, new ArrayList()); + deleteFolderContents(folder, new ArrayList(), removeFolders); } public static void deleteFolderContents(File folder, - List folderNamesToAvoid) + List folderNamesToAvoid, boolean removeFolders) { if (folder == null) { @@ -164,12 +164,17 @@ public static void deleteFolderContents(File folder, { if (!folderNamesToAvoid.contains(f.getName())) { - deleteFolderContents(f, folderNamesToAvoid); + deleteFolderContents(f, folderNamesToAvoid, removeFolders); } } else { f.delete(); } + + if(removeFolders) + { + f.delete(); + } } } diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java index c4c838cc43..cb12396f6e 100644 --- a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java +++ b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java @@ -506,8 +506,16 @@ public void generateJavaSourceFile(File outputFolder, if (generatedModule != null && generatedModule.canBeGenerated() && !generatedModule.hasMergeErrors()) { - JavaCodeGenUtil.saveJavaClass(outputFolder, generatedModule.getName() - + IJavaCodeGenConstants.JAVA_FILE_EXTENSION, generatedModule.getContent()); + String javaFileName = generatedModule.getName(); + + if(GeneralCodeGenUtils.isQuote(generatedModule.getIrDecl())) + { + javaFileName += JAVA_QUOTE_NAME_SUFFIX; + } + + javaFileName += IJavaCodeGenConstants.JAVA_FILE_EXTENSION; + + JavaCodeGenUtil.saveJavaClass(outputFolder, javaFileName, generatedModule.getContent()); } } diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/CompileTests.java b/core/codegen/src/test/java/org/overture/codegen/tests/utils/CompileTests.java index 4acd974661..14deb62f0e 100644 --- a/core/codegen/src/test/java/org/overture/codegen/tests/utils/CompileTests.java +++ b/core/codegen/src/test/java/org/overture/codegen/tests/utils/CompileTests.java @@ -466,7 +466,7 @@ public void runTests(List testInputFiles, List resultFiles, { File currentInputFile = testInputFiles.get(i); - GeneralUtils.deleteFolderContents(parent, FOLDER_NAMES_TO_AVOID); + GeneralUtils.deleteFolderContents(parent, FOLDER_NAMES_TO_AVOID, false); // Calculating the Java result: File file = resultFiles.get(i); diff --git a/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaCommand.java b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaCommand.java index c85fb1fa27..0e85e77dd6 100644 --- a/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaCommand.java +++ b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaCommand.java @@ -181,7 +181,7 @@ protected IStatus run(IProgressMonitor monitor) File eclipseProjectFolder = PluginVdm2JavaUtil.getEclipseProjectFolder(vdmProject); // Clean folder with generated Java code - GeneralUtils.deleteFolderContents(eclipseProjectFolder); + GeneralUtils.deleteFolderContents(eclipseProjectFolder, true); // Generate user specified classes GeneratedData generatedData = vdm2java.generateJavaFromVdm(mergedParseLists); From f9a7533760973c64dc719dd32bbe8e799878954c Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Fri, 6 Mar 2015 22:41:03 +0100 Subject: [PATCH 241/323] Updated code generation of IO file writing to work with "append" quotes from any package --- .../src/main/java/org/overture/codegen/runtime/IO.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/IO.java b/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/IO.java index ce37a29265..318169dc1b 100644 --- a/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/IO.java +++ b/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/IO.java @@ -101,7 +101,8 @@ public boolean fecho(String filename, String text, Object fdir) { try { File file = getFile(filename); - FileOutputStream fos = new FileOutputStream(file, fdir.getClass().getName().equals("quotes.appendQuote")); + FileOutputStream fos = new FileOutputStream(file, fdir.getClass().getName(). + endsWith("quotes.appendQuote")); fos.write(text.getBytes(Charset.defaultCharset().name())); fos.close(); From b0a5d36f8f7f4a06caee0eeff3500df98d2c3b26 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Fri, 6 Mar 2015 22:44:46 +0100 Subject: [PATCH 242/323] Introduced the notion of warnings into the GenerateData data structure This is used to communicate problems back to the user such as if the user chooses a launch configuration that is not type correct. --- .../codegen/utils/GeneralCodeGenUtils.java | 70 ++++++++----------- .../overture/codegen/utils/GeneratedData.java | 47 ++++++++++--- .../codegen/vdm2java/JavaCodeGen.java | 25 +++++-- 3 files changed, 87 insertions(+), 55 deletions(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/utils/GeneralCodeGenUtils.java b/core/codegen/src/main/java/org/overture/codegen/utils/GeneralCodeGenUtils.java index 6995943c52..217bfef76e 100644 --- a/core/codegen/src/main/java/org/overture/codegen/utils/GeneralCodeGenUtils.java +++ b/core/codegen/src/main/java/org/overture/codegen/utils/GeneralCodeGenUtils.java @@ -135,56 +135,46 @@ public static TypeCheckResult validateExp(String exp) return typeCheckResult; } - public static SClassDefinition consMainClass(List mergedParseLists, - String expression, Dialect dialect, String mainClassName, - ITempVarGen nameGen) + public static SClassDefinition consMainClass( + List mergedParseLists, String expression, + Dialect dialect, String mainClassName, ITempVarGen nameGen) throws VDMErrorsException, AnalysisException { - try - { - ClassList classes = new ClassList(); - classes.addAll(mergedParseLists); - PExp entryExp = typeCheckEntryPoint(classes, expression, dialect); + ClassList classes = new ClassList(); + classes.addAll(mergedParseLists); + PExp entryExp = typeCheckEntryPoint(classes, expression, dialect); - String resultTypeStr = entryExp.getType() instanceof AVoidType ? "()" - : "?"; + String resultTypeStr = entryExp.getType() instanceof AVoidType ? "()" + : "?"; - // Collect all the class names - List namesToAvoid = new LinkedList<>(); + // Collect all the class names + List namesToAvoid = new LinkedList<>(); - for (SClassDefinition c : classes) - { - namesToAvoid.add(c.getName().getName()); - } + for (SClassDefinition c : classes) + { + namesToAvoid.add(c.getName().getName()); + } + + // If the user already uses the name proposed for the main class + // we have to find a new name for the main class + if (namesToAvoid.contains(mainClassName)) + { + String prefix = mainClassName + "_"; + mainClassName = nameGen.nextVarName(prefix); - // If the user already uses the name proposed for the main class - // we have to find a new name for the main class - if (namesToAvoid.contains(mainClassName)) + while (namesToAvoid.contains(mainClassName)) { - String prefix = mainClassName + "_"; mainClassName = nameGen.nextVarName(prefix); - - while (namesToAvoid.contains(mainClassName)) - { - mainClassName = nameGen.nextVarName(prefix); - } } + } - String entryClassTemplate = - "class " + mainClassName + "\n" - + "operations\n" + "public static Run : () ==> " - + resultTypeStr + "\n" + "Run () == " + expression + ";\n" - + "end " + mainClassName; - - SClassDefinition clazz = parseClass(entryClassTemplate, mainClassName, dialect); + String entryClassTemplate = "class " + mainClassName + "\n" + + "operations\n" + "public static Run : () ==> " + + resultTypeStr + "\n" + "Run () == " + expression + ";\n" + + "end " + mainClassName; - return tcClass(classes, clazz); + SClassDefinition clazz = parseClass(entryClassTemplate, mainClassName, dialect); - } catch (VDMErrorsException | AnalysisException e) - { - Logger.getLog().printErrorln("Problems encountered when constructing the main class in 'GeneralCodeGenUtils'"); - e.printStackTrace(); - return null; - } + return tcClass(classes, clazz); } public static PExp typeCheckEntryPoint(ClassList classes, String expression, Dialect dialect) @@ -258,7 +248,7 @@ public static PExp parseExpression(String expression, } public static SClassDefinition parseClass(String classStr, - String defaultModuleName, Dialect dialect) throws ParserException, LexException + String defaultModuleName, Dialect dialect) { LexTokenReader ltr = new LexTokenReader(classStr, dialect, Console.charset); ClassReader reader = new ClassReader(ltr); diff --git a/core/codegen/src/main/java/org/overture/codegen/utils/GeneratedData.java b/core/codegen/src/main/java/org/overture/codegen/utils/GeneratedData.java index 0c04e0273e..d3312b490f 100644 --- a/core/codegen/src/main/java/org/overture/codegen/utils/GeneratedData.java +++ b/core/codegen/src/main/java/org/overture/codegen/utils/GeneratedData.java @@ -33,40 +33,65 @@ public class GeneratedData private InvalidNamesResult invalidNamesResult; private List skippedClasses; private List allRenamings; - - public GeneratedData(List classes, - List quoteValues, InvalidNamesResult invalidNamesResult, List skippedClasses, List allRenamings) - { - super(); - this.classes = classes; - this.quoteValues = quoteValues; - this.invalidNamesResult = invalidNamesResult; - this.skippedClasses = skippedClasses; - this.allRenamings = allRenamings; - } + private List warnings; public List getClasses() { return classes; } + public void setClasses(List classes) + { + this.classes = classes; + } + public List getQuoteValues() { return quoteValues; } + public void setQuoteValues(List quoteValues) + { + this.quoteValues = quoteValues; + } + public InvalidNamesResult getInvalidNamesResult() { return invalidNamesResult; } + public void setInvalidNamesResult(InvalidNamesResult invalidNamesResult) + { + this.invalidNamesResult = invalidNamesResult; + } + public List getSkippedClasses() { return skippedClasses; } + public void setSkippedClasses(List skippedClasses) + { + this.skippedClasses = skippedClasses; + } + public List getAllRenamings() { return allRenamings; } + + public void setAllRenamings(List allRenamings) + { + this.allRenamings = allRenamings; + } + + public List getWarnings() + { + return warnings; + } + + public void setWarnings(List warnings) + { + this.warnings = warnings; + } } diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java index cb12396f6e..23918aaaed 100644 --- a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java +++ b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java @@ -199,11 +199,20 @@ public GeneratedData generateJavaFromVdm( { SClassDefinition mainClass = null; + List warnings = new LinkedList(); if(getJavaSettings().getVdmEntryExp() != null) { - mainClass = GeneralCodeGenUtils.consMainClass(mergedParseLists, getJavaSettings().getVdmEntryExp(), - Settings.dialect, JAVA_MAIN_CLASS_NAME, getInfo().getTempVarNameGen()); - mergedParseLists.add(mainClass); + try + { + mainClass = GeneralCodeGenUtils.consMainClass(mergedParseLists, getJavaSettings().getVdmEntryExp(), + Settings.dialect, JAVA_MAIN_CLASS_NAME, getInfo().getTempVarNameGen()); + mergedParseLists.add(mainClass); + } catch (Exception e) + { + // It can go wrong if the VDM entry point does not type check + warnings.add("The chosen launch configuration could not be type checked: " + e.getMessage()); + warnings.add("Skipping launch configuration.."); + } } computeDefTable(mergedParseLists); @@ -361,7 +370,15 @@ else if(mergeVisitor.hasUnsupportedTargLangNodes()) javaFormat.clearFunctionValueAssistant(); javaFormat.clearClasses(); - return new GeneratedData(generated, generateJavaFromVdmQuotes(), invalidNamesResult, skipping, allRenamings); + GeneratedData data = new GeneratedData(); + data.setClasses(generated); + data.setQuoteValues(generateJavaFromVdmQuotes()); + data.setInvalidNamesResult(invalidNamesResult); + data.setSkippedClasses(skipping); + data.setAllRenamings(allRenamings); + data.setWarnings(warnings); + + return data; } private void computeDefTable(List mergedParseLists) From 0d294859980293c1a848a8a60bbeeefc2152ad15 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Fri, 6 Mar 2015 22:48:02 +0100 Subject: [PATCH 243/323] Improvement: updated the Java code generator to output a warning in case the user's launch configuration is not type correct --- .../codegen/commands/Vdm2JavaCommand.java | 18 ++++++++++++++++++ .../commands/Vdm2JavaLaunchConfigCommand.java | 4 +--- .../codegen/util/PluginVdm2JavaUtil.java | 2 ++ 3 files changed, 21 insertions(+), 3 deletions(-) diff --git a/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaCommand.java b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaCommand.java index 0e85e77dd6..575654497d 100644 --- a/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaCommand.java +++ b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaCommand.java @@ -268,7 +268,12 @@ protected IStatus run(IProgressMonitor monitor) { handleInvalidNames(invalidNames); } + + // Output any warnings such as problems with the user's launch configuration + outputWarnings(generatedData.getWarnings()); + + // Summarize the code generation process int noOfClasses = generatedData.getClasses().size(); String msg = String.format("...finished Java code generation (generated %s %s).", @@ -358,6 +363,19 @@ private void deleteMarkers(IProject project) ex.printStackTrace(); } } + + private void outputWarnings(List warnings) + { + if(warnings != null && !warnings.isEmpty()) + { + for(String warning : warnings) + { + CodeGenConsole.GetInstance().println(PluginVdm2JavaUtil.WARNING + " " + warning); + } + + CodeGenConsole.GetInstance().printErrorln(""); + } + } private void outputUserSpecifiedSkippedClasses( List userspecifiedSkippedClasses) diff --git a/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaLaunchConfigCommand.java b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaLaunchConfigCommand.java index b008588219..7a6a7c21ed 100644 --- a/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaLaunchConfigCommand.java +++ b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaLaunchConfigCommand.java @@ -10,8 +10,6 @@ public class Vdm2JavaLaunchConfigCommand extends Vdm2JavaCommand { - private static final String WARNING = "[WARNING]"; - @Override public JavaSettings getJavaSettings(IProject project, List classesToSkip) @@ -34,7 +32,7 @@ public JavaSettings getJavaSettings(IProject project, } } else { - CodeGenConsole.GetInstance().println(WARNING + CodeGenConsole.GetInstance().println(PluginVdm2JavaUtil.WARNING + " No launch configuration could be found for this project.\n"); CodeGenConsole.GetInstance().println("Cancelling launch configuration based code generation...\n"); } diff --git a/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/util/PluginVdm2JavaUtil.java b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/util/PluginVdm2JavaUtil.java index e15e735220..aa550a22cf 100644 --- a/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/util/PluginVdm2JavaUtil.java +++ b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/util/PluginVdm2JavaUtil.java @@ -87,6 +87,8 @@ public class PluginVdm2JavaUtil public static final String ECLIPSE_RES_FILES_FOLDER = "eclipsefiles"; public static final String ECLIPSE_PROJECT_SRC_FOLDER = "src"; + public static final String WARNING = "[WARNING]"; + private PluginVdm2JavaUtil() { } From 2864b537c668594db9b3d467a54b48c6886671db Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sat, 7 Mar 2015 09:41:37 +0100 Subject: [PATCH 244/323] Issue #425. Implemented support for the experimental 'sprintf' feature in the IO library --- .../src/main/java/org/overture/codegen/runtime/IO.java | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/IO.java b/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/IO.java index 318169dc1b..f536bae2ae 100644 --- a/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/IO.java +++ b/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/IO.java @@ -150,6 +150,16 @@ public static void printf(VDMSeq seq, List args) { System.out.flush(); } + public static String sprintf(String format, List args) { + + return String.format(format, args.toArray()); + } + + public static VDMSeq sprintf(VDMSeq seq, List args) { + + throw new UnsupportedOperationException("sprintf is only supported for formats of type String"); + } + private static Object[] formatList(List args) { for(int i = 0; i < args.size(); i++) From bbd31f01cd7a49ae521c6eff7438ab28f18d0113 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sat, 7 Mar 2015 09:43:59 +0100 Subject: [PATCH 245/323] Added unit testing to the Java codegen-runtime library --- core/codegen-runtime/pom.xml | 43 ++++++++++++++----- .../codegen-runtime/src/test/java/IOTest.java | 24 +++++++++++ 2 files changed, 56 insertions(+), 11 deletions(-) create mode 100644 core/codegen-runtime/src/test/java/IOTest.java diff --git a/core/codegen-runtime/pom.xml b/core/codegen-runtime/pom.xml index e2c998a53f..bffc84b03a 100644 --- a/core/codegen-runtime/pom.xml +++ b/core/codegen-runtime/pom.xml @@ -12,19 +12,40 @@ codegen-runtime VDM Code Generator Runtime + + + junit + junit + 4.11 + + + + - - maven-source-plugin - - - attach-sources - - jar-no-fork - - - - + + org.apache.maven.plugins + maven-surefire-plugin + + true + + **/*Test.java + **/*Test?.java + **/*TestSuite.java + + + + + maven-source-plugin + + + attach-sources + + jar-no-fork + + + + diff --git a/core/codegen-runtime/src/test/java/IOTest.java b/core/codegen-runtime/src/test/java/IOTest.java new file mode 100644 index 0000000000..54bbdc409f --- /dev/null +++ b/core/codegen-runtime/src/test/java/IOTest.java @@ -0,0 +1,24 @@ +import static org.junit.Assert.assertEquals; + +import org.junit.Test; +import org.overture.codegen.runtime.IO; +import org.overture.codegen.runtime.SeqUtil; +import org.overture.codegen.runtime.Tuple; +import org.overture.codegen.runtime.VDMSeq; + + +public class IOTest +{ + @Test + public void testSprintfStr() + { + VDMSeq args = SeqUtil.seq("tuple", Tuple.mk_(1,2)); + String format = "A %s: %s"; + + @SuppressWarnings("unchecked") + String actual = IO.sprintf(format, args); + String expected = "A tuple: mk_(1, 2)"; + + assertEquals("Unexpected string returned from IO.sprintf", expected, actual); + } +} From 1cb955e84422e47aa34b0f61b3cf97ed3595d04f Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sat, 7 Mar 2015 19:51:59 +0100 Subject: [PATCH 246/323] Improved the command-line version of the Java code generator --- .../overture/codegen/utils/GeneralUtils.java | 14 - .../codegen/vdm2java/JavaCodeGenMain.java | 393 +++++++++++++----- 2 files changed, 300 insertions(+), 107 deletions(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/utils/GeneralUtils.java b/core/codegen/src/main/java/org/overture/codegen/utils/GeneralUtils.java index b027ad6665..9c48c263e1 100644 --- a/core/codegen/src/main/java/org/overture/codegen/utils/GeneralUtils.java +++ b/core/codegen/src/main/java/org/overture/codegen/utils/GeneralUtils.java @@ -124,20 +124,6 @@ public static List getFiles(File folder) return fileList; } - public static List getFilesFromPaths(String[] args) - { - List files = new LinkedList(); - - for (int i = 1; i < args.length; i++) - { - String fileName = args[i]; - File file = new File(fileName); - files.add(file); - } - - return files; - } - public static void deleteFolderContents(File folder, boolean removeFolders) { deleteFolderContents(folder, new ArrayList(), removeFolders); diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGenMain.java b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGenMain.java index dbd0a9a036..256a952cd9 100644 --- a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGenMain.java +++ b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGenMain.java @@ -22,10 +22,14 @@ package org.overture.codegen.vdm2java; import java.io.File; +import java.util.Arrays; +import java.util.Iterator; +import java.util.LinkedList; import java.util.List; import java.util.Set; import org.overture.ast.analysis.AnalysisException; +import org.overture.ast.definitions.SClassDefinition; import org.overture.ast.lex.Dialect; import org.overture.codegen.analysis.vdm.Renaming; import org.overture.codegen.analysis.violations.InvalidNamesResult; @@ -33,6 +37,7 @@ import org.overture.codegen.ir.IRSettings; import org.overture.codegen.ir.IrNodeInfo; import org.overture.codegen.logging.Logger; +import org.overture.codegen.utils.GeneralCodeGenUtils; import org.overture.codegen.utils.GeneralUtils; import org.overture.codegen.utils.Generated; import org.overture.codegen.utils.GeneratedData; @@ -42,153 +47,355 @@ public class JavaCodeGenMain { + public static final String OO_ARG = "-oo"; + public static final String EXP_ARG = "-exp"; + public static final String FOLDER_ARG = "-folder"; + public static final String PRINT_ARG = "-print"; + public static final String PACKAGE_ARG = "-package"; + public static final String OUTPUT_ARG = "-output"; + public static final String VDM_ENTRY_EXP = "-entry"; + public static void main(String[] args) { Settings.release = Release.VDM_10; - Dialect dialect = Dialect.VDM_RT; + Dialect dialect = Dialect.VDM_PP; - if (args.length <= 1) + boolean ooChosen = false; + boolean printClasses = false; + + if (args == null || args.length <= 1) { - Logger.getLog().println("Wrong input!"); + usage("Too few arguments provided"); } - + IRSettings irSettings = new IRSettings(); - irSettings.setCharSeqAsString(false); + irSettings.setCharSeqAsString(true); irSettings.setGeneratePreConds(false); irSettings.setGeneratePreCondChecks(false); irSettings.setGeneratePostConds(false); irSettings.setGeneratePostCondChecks(false); - + JavaSettings javaSettings = new JavaSettings(); javaSettings.setDisableCloning(false); - String setting = args[0]; - if (setting.toLowerCase().equals("oo")) - { - try - { - List files = GeneralUtils.getFilesFromPaths(args); + List listArgs = Arrays.asList(args); + String exp = null; + File outputDir = null; + + List files = new LinkedList(); - List libFiles = GeneralUtils.getFiles(new File("src\\test\\resources\\lib")); - files.addAll(libFiles); + for (Iterator i = listArgs.iterator(); i.hasNext();) + { + String arg = i.next(); - GeneratedData data = JavaCodeGenUtil.generateJavaFromFiles(files, irSettings, javaSettings, dialect); - List generatedClasses = data.getClasses(); + if (arg.equals(OO_ARG)) + { + ooChosen = true; + } else if (arg.equals(EXP_ARG)) + { + ooChosen = false; - for (GeneratedModule generatedClass : generatedClasses) + if (i.hasNext()) { - Logger.getLog().println("**********"); - - if (generatedClass.hasMergeErrors()) - { - Logger.getLog().println(String.format("Class %s could not be merged. Following merge errors were found:", generatedClass.getName())); + exp = i.next(); + } else + { + usage(EXP_ARG + " requires a VDM expression"); + } + } else if (arg.equals(PRINT_ARG)) + { + printClasses = true; + } else if (arg.equals(FOLDER_ARG)) + { + if (i.hasNext()) + { + File path = new File(i.next()); - JavaCodeGenUtil.printMergeErrors(generatedClass.getMergeErrors()); - } else if (!generatedClass.canBeGenerated()) + if (path.isDirectory()) { - Logger.getLog().println("Could not generate class: " - + generatedClass.getName() + "\n"); - - if(generatedClass.hasUnsupportedIrNodes()) - { - Logger.getLog().println("Following VDM constructs are not supported by the code generator:"); - JavaCodeGenUtil.printUnsupportedIrNodes(generatedClass.getUnsupportedInIr()); - } - - if(generatedClass.hasUnsupportedTargLangNodes()) - { - Logger.getLog().println("Following constructs are not supported by the code generator:"); - JavaCodeGenUtil.printUnsupportedNodes(generatedClass.getUnsupportedInTargLang()); - } - + files.addAll(GeneralUtils.getFiles(path)); } else { - Logger.getLog().println(generatedClass.getContent()); - - Set warnings = generatedClass.getTransformationWarnings(); - - if(!warnings.isEmpty()) - { - Logger.getLog().println("Following transformation warnings were found:"); - JavaCodeGenUtil.printUnsupportedNodes(generatedClass.getTransformationWarnings()); - } + usage("Could not find path: " + path); } - - Logger.getLog().println("\n"); + } else + { + usage(FOLDER_ARG + " requires a directory"); } - - List quotes = data.getQuoteValues(); - - Logger.getLog().println("Generated following quotes:"); - - if (quotes != null && !quotes.isEmpty()) + } else if(arg.equals(PACKAGE_ARG)) + { + if(i.hasNext()) { - for(GeneratedModule q : quotes) + String javaPackage = i.next(); + + if(GeneralCodeGenUtils.isValidJavaPackage(javaPackage)) + { + javaSettings.setJavaRootPackage(javaPackage); + } + else { - Logger.getLog().println(q.getName()); + Logger.getLog().printErrorln("Not a valid java package. Using the default java package instead..\n"); } } - - InvalidNamesResult invalidName = data.getInvalidNamesResult(); - - if (!invalidName.isEmpty()) + } + else if(arg.equals(OUTPUT_ARG)) + { + if (i.hasNext()) { - Logger.getLog().println(JavaCodeGenUtil.constructNameViolationsString(invalidName)); + outputDir = new File(i.next()); + outputDir.mkdirs(); + + if (!outputDir.isDirectory()) + { + usage(outputDir + " is not a directory"); + } + + } else + { + usage(OUTPUT_ARG + " requires a directory"); } - - List allRenamings = data.getAllRenamings(); - - if (!allRenamings.isEmpty()) + } + else if(arg.equals(VDM_ENTRY_EXP)) + { + if(i.hasNext()) { - Logger.getLog().println("\nFollowing renamings of shadowing variables were made: "); + javaSettings.setVdmEntryExp(i.next()); + } + } + else + { + // It's a file or a directory + File file = new File(arg); - Logger.getLog().println(JavaCodeGenUtil.constructVarRenamingString(allRenamings)); + if (file.isFile()) + { + files.add(file); + } else + { + usage("Not a file: " + file); } + } + } + + Logger.getLog().println("Starting code generation...\n"); + + + if (ooChosen) + { + if(files.isEmpty()) + { + usage("Input files are missing"); + } + + if(outputDir == null) + { + Logger.getLog().println("No output directory specified - printing code generated classes instead..\n"); + printClasses = true; + } + + handleOo(files, irSettings, javaSettings, dialect, printClasses, outputDir); + } else + { + handleExp(exp, irSettings, javaSettings, dialect); + } + + Logger.getLog().println("\nFinished code generation! Bye..."); + } + + private static void handleExp(String exp, IRSettings irSettings, + JavaSettings javaSettings, Dialect dialect) + { + try + { + Generated generated = JavaCodeGenUtil.generateJavaFromExp(exp, irSettings, javaSettings, dialect); - } catch (AnalysisException e) + if (generated.hasMergeErrors()) { - Logger.getLog().println(e.getMessage()); + Logger.getLog().println(String.format("VDM expression '%s' could not be merged. Following merge errors were found:", exp)); + JavaCodeGenUtil.printMergeErrors(generated.getMergeErrors()); + } else if (!generated.canBeGenerated()) + { + Logger.getLog().println("Could not generate VDM expression: " + + exp); - } catch (UnsupportedModelingException e) + if (generated.hasUnsupportedIrNodes()) + { + JavaCodeGenUtil.printUnsupportedIrNodes(generated.getUnsupportedInIr()); + } + + if (generated.hasUnsupportedTargLangNodes()) + { + JavaCodeGenUtil.printUnsupportedNodes(generated.getUnsupportedInTargLang()); + } + + } else { - Logger.getLog().println("Could not generate model: " - + e.getMessage()); - Logger.getLog().println(JavaCodeGenUtil.constructUnsupportedModelingString(e)); + Logger.getLog().println("Code generated expression: " + + generated.getContent().trim()); } - } else if (setting.toLowerCase().equals("exp")) + } catch (AnalysisException e) { - try + Logger.getLog().println("Could not code generate model: " + + e.getMessage()); + + } + } + + public static void handleOo(List files, IRSettings irSettings, + JavaSettings javaSettings, Dialect dialect, boolean printCode, File outputDir) + { + try + { + JavaCodeGen vdmCodGen = new JavaCodeGen(); + vdmCodGen.setSettings(irSettings); + vdmCodGen.setJavaSettings(javaSettings); + + List ast = JavaCodeGenUtil.consMergedParseList(files, dialect); + + GeneratedData data = vdmCodGen.generateJavaFromVdm(ast); + + List generatedClasses = data.getClasses(); + + Logger.getLog().println(""); + + if (outputDir != null) + { + String javaPackage = javaSettings.getJavaRootPackage(); + if(GeneralCodeGenUtils.isValidJavaPackage(javaPackage)) + { + String packageFolderPath = GeneralCodeGenUtils.getFolderFromJavaRootPackage(javaPackage); + outputDir = new File(outputDir, packageFolderPath); + } + } + + for (GeneratedModule generatedClass : generatedClasses) { - Generated generated = JavaCodeGenUtil.generateJavaFromExp(args[1], irSettings, javaSettings, dialect); + if (generatedClass.hasMergeErrors()) + { + Logger.getLog().println(String.format("Class %s could not be merged. Following merge errors were found:", generatedClass.getName())); - if (generated.hasMergeErrors()) + JavaCodeGenUtil.printMergeErrors(generatedClass.getMergeErrors()); + } else if (!generatedClass.canBeGenerated()) { - Logger.getLog().println(String.format("VDM expression '%s' could not be merged. Following merge errors were found:", args[1])); - JavaCodeGenUtil.printMergeErrors(generated.getMergeErrors()); - } else if (!generated.canBeGenerated()) + Logger.getLog().println("Could not generate class: " + + generatedClass.getName() + "\n"); + + if (generatedClass.hasUnsupportedIrNodes()) + { + Logger.getLog().println("Following VDM constructs are not supported by the code generator:"); + JavaCodeGenUtil.printUnsupportedIrNodes(generatedClass.getUnsupportedInIr()); + } + + if (generatedClass.hasUnsupportedTargLangNodes()) + { + Logger.getLog().println("Following constructs are not supported by the code generator:"); + JavaCodeGenUtil.printUnsupportedNodes(generatedClass.getUnsupportedInTargLang()); + } + + } else { - Logger.getLog().println("Could not generate VDM expression: " - + args[1]); - - if(generated.hasUnsupportedIrNodes()) + if (outputDir != null) { - JavaCodeGenUtil.printUnsupportedIrNodes(generated.getUnsupportedInIr()); + vdmCodGen.generateJavaSourceFile(outputDir, generatedClass); } - if(generated.hasUnsupportedTargLangNodes()) + if (printCode) + { + Logger.getLog().println("**********"); + Logger.getLog().println(generatedClass.getContent()); + Logger.getLog().println("\n"); + } else { - JavaCodeGenUtil.printUnsupportedNodes(generated.getUnsupportedInTargLang()); + Logger.getLog().println("Generated class : " + + generatedClass.getName()); } + + Set warnings = generatedClass.getTransformationWarnings(); + + if (!warnings.isEmpty()) + { + Logger.getLog().println("Following transformation warnings were found:"); + JavaCodeGenUtil.printUnsupportedNodes(generatedClass.getTransformationWarnings()); + } + } + } + + List quotes = data.getQuoteValues(); + + Logger.getLog().println("\nGenerated following quotes:"); + + if (quotes != null && !quotes.isEmpty()) + { + if(outputDir != null) + { + outputDir = new File(outputDir, JavaCodeGen.QUOTES); - } else + for (GeneratedModule q : quotes) + { + vdmCodGen.generateJavaSourceFile(outputDir, q); + } + } + + for (GeneratedModule q : quotes) { - Logger.getLog().println(generated.getContent().trim()); + Logger.getLog().print(q.getName() + " "); } - } catch (AnalysisException e) + Logger.getLog().println(""); + } + + InvalidNamesResult invalidName = data.getInvalidNamesResult(); + + if (!invalidName.isEmpty()) { - Logger.getLog().println(e.getMessage()); + Logger.getLog().println(JavaCodeGenUtil.constructNameViolationsString(invalidName)); } + + List allRenamings = data.getAllRenamings(); + + if (!allRenamings.isEmpty()) + { + Logger.getLog().println("\nFollowing renamings of shadowing variables were made: "); + + Logger.getLog().println(JavaCodeGenUtil.constructVarRenamingString(allRenamings)); + } + + if(data.getWarnings() != null && !data.getWarnings().isEmpty()) + { + Logger.getLog().println(""); + for(String w : data.getWarnings()) + { + Logger.getLog().println("[WARNING] " + w); + } + } + + } catch (AnalysisException e) + { + Logger.getLog().println("Could not code generate model: " + + e.getMessage()); + + } catch (UnsupportedModelingException e) + { + Logger.getLog().println("Could not generate model: " + + e.getMessage()); + Logger.getLog().println(JavaCodeGenUtil.constructUnsupportedModelingString(e)); } } + + public static void usage(String msg) + { + Logger.getLog().printErrorln("VDM++ to Java Code Generator: " + msg + + "\n"); + Logger.getLog().printErrorln("Usage: CodeGen <-oo | -exp> [] []"); + Logger.getLog().printErrorln(OO_ARG + ": code generate a VDMPP specification consisting of multiple .vdmpp files"); + Logger.getLog().printErrorln(EXP_ARG + " : code generate a VDMPP expression"); + Logger.getLog().printErrorln(FOLDER_ARG + " : a folder containing input .vdmpp files"); + Logger.getLog().printErrorln(PRINT_ARG + ": print the generated code to the console"); + Logger.getLog().printErrorln(PACKAGE_ARG + " : the output java package of the generated code (e.g. my.code)"); + Logger.getLog().printErrorln(OUTPUT_ARG + " : the output folder of the generated code"); + Logger.getLog().printErrorln(VDM_ENTRY_EXP + " : generate a Java main method based on the specified entry point"); + + // Terminate + System.exit(1); + } } From ce67dc5e3d8c4c0d6e4451977cc2aab8fe3c41f4 Mon Sep 17 00:00:00 2001 From: Kenneth Lausdahl Date: Sun, 8 Mar 2015 01:24:11 +0100 Subject: [PATCH 247/323] added initial code gen maven plaugin --- core/codegen-plugin/pom.xml | 78 ++++++++ .../maven/astcreator/AstCreatorBaseMojo.java | 167 ++++++++++++++++++ .../maven/astcreator/GenerateJavaSources.java | 92 ++++++++++ .../maven/astcreator/VdmppNameFilter.java | 15 ++ 4 files changed, 352 insertions(+) create mode 100644 core/codegen-plugin/pom.xml create mode 100644 core/codegen-plugin/src/main/java/org/overture/tools/maven/astcreator/AstCreatorBaseMojo.java create mode 100644 core/codegen-plugin/src/main/java/org/overture/tools/maven/astcreator/GenerateJavaSources.java create mode 100644 core/codegen-plugin/src/main/java/org/overture/tools/maven/astcreator/VdmppNameFilter.java diff --git a/core/codegen-plugin/pom.xml b/core/codegen-plugin/pom.xml new file mode 100644 index 0000000000..337094e719 --- /dev/null +++ b/core/codegen-plugin/pom.xml @@ -0,0 +1,78 @@ + + 4.0.0 + + + org.overturetool + core + 2.2.3-SNAPSHOT + ../pom.xml + + + maven-plugin + + codegen-plugin + Overture CodeGen Maven Plugin + + + + + + + org.apache.maven.plugins + maven-resources-plugin + + + + + + + org.eclipse.m2e + lifecycle-mapping + 1.0.0 + + + + + + + org.apache.maven.plugins + + + maven-plugin-plugin + + [3.2,) + + descriptor + + + + + + + + + + + + + + + + + org.overturetool.core + codegen + ${project.version} + + + org.apache.maven + maven-plugin-api + 2.0 + + + org.apache.maven.plugins + maven-project-info-reports-plugin + 2.1.1 + maven-plugin + + + diff --git a/core/codegen-plugin/src/main/java/org/overture/tools/maven/astcreator/AstCreatorBaseMojo.java b/core/codegen-plugin/src/main/java/org/overture/tools/maven/astcreator/AstCreatorBaseMojo.java new file mode 100644 index 0000000000..4e738924f0 --- /dev/null +++ b/core/codegen-plugin/src/main/java/org/overture/tools/maven/astcreator/AstCreatorBaseMojo.java @@ -0,0 +1,167 @@ +package org.overture.tools.maven.astcreator; + +import java.io.File; +import java.util.List; + +import org.apache.maven.plugin.AbstractMojo; +import org.apache.maven.plugin.MojoExecutionException; +import org.apache.maven.plugin.MojoFailureException; + +/** + * Says "Hi" to the user. + * + * @phase generate-sources + * @requiresDependencyResolution compile + */ +public abstract class AstCreatorBaseMojo extends AbstractMojo +{ + +// protected final String PLUGIN_GROUPID = "org.overture.maven.tools"; +// protected final String PLUGIN_ARTIFACTID = "ast-creator-plugin"; +// +// /** +// * The prefix of the generated classes. +// * +// * @parameter +// * @optional +// */ +// protected boolean extendedTreeOnly = false; +// +// /** +// * The prefix of the generated classes. +// * +// * @parameter +// * @required +// */ +// protected String vdmResourceFolderName; +// +// /** +// * The prefix of the generated classes. +// * +// * @parameter +// */ +// protected String extendedAst; +// +// /** +// * The extended tree dependency groupid. +// * +// * @parameter +// */ +// protected String extendedAstGroupId; +// +// /** +// * The extended tree dependency artifactid. +// * +// * @parameter +// */ +// protected String extendedAstArtifactId; +// +// /** +// * The prefix of the extended generated classes. +// * +// * @parameter +// */ +// protected String extendedName; + + /** + * The package of the generated classes. + * + * @parameter + * @required + */ + protected String packageName; + +// /** +// * The use src folder instead of generate-sources for the generated classes. +// * +// * @parameter +// */ +// protected Boolean useSrcOutput; +// + /** + * Name of the directory into which the astCreatorPlugin should dump the ast files. + * + * @parameter expression="${project.build.directory}/generated-sources/vdmCodeGen" + */ + protected File outputDirectory; + +// /** +// * Enables generation of vDM source code corresponding to the Java generated tree. +// * +// * @parameter +// */ +// protected Boolean generateVdm = false; +// +// /** +// * The package of the generated classes. +// * +// * @parameter +// */ +// protected List deletePackageOnGenerate; + + // /** + // * My top level of tree. + // * + // * @parameter + // */ + // protected List names; + + /** + * @parameter expression="${project}" + * @required + * @readonly + */ + protected org.apache.maven.project.MavenProject project; + + /** + * default-value="${project.reporting.outputDirectory}" + * + * @parameter + */ + private File projectOutputDirectory; + + protected File getProjectOutputDirectory() + { + if (projectOutputDirectory == null + || projectOutputDirectory.length() == 0) + { + File output = new File(project.getFile().getParentFile(), "target"); + if (!output.exists()) + output.mkdirs(); + + return output; + + } else + return projectOutputDirectory; + } + + protected File getProjectJavaSrcDirectory() + { + File output = new File(project.getFile().getParentFile(), "src/main/java".replace('/', File.separatorChar)); + return output; + } + + protected File getProjectVdmSrcDirectory() + { + File output = new File(project.getFile().getParentFile(), "src/main/vpp".replace('/', File.separatorChar)); + return output; + } + + protected File getResourcesDir() + { + File resources = new File(project.getFile().getParentFile(), "src/main/resources".replace('/', File.separatorChar)); + return resources; + } + + // protected List getGrammas() + // { + // List grammas = new Vector(); + // grammas.add(new File(getResourcesDir(), ast)); + // System.out.println("AST file: " + grammas.get(0).getAbsolutePath()); + // return grammas; + // } + + public abstract void execute() throws MojoExecutionException, + MojoFailureException; + +} diff --git a/core/codegen-plugin/src/main/java/org/overture/tools/maven/astcreator/GenerateJavaSources.java b/core/codegen-plugin/src/main/java/org/overture/tools/maven/astcreator/GenerateJavaSources.java new file mode 100644 index 0000000000..18df7066d3 --- /dev/null +++ b/core/codegen-plugin/src/main/java/org/overture/tools/maven/astcreator/GenerateJavaSources.java @@ -0,0 +1,92 @@ +package org.overture.tools.maven.astcreator; + +import java.io.File; +import java.util.Collection; +import java.util.List; +import java.util.Vector; + +import org.apache.commons.io.FileUtils; +import org.apache.commons.io.filefilter.DirectoryFileFilter; +import org.apache.commons.io.filefilter.RegexFileFilter; +import org.apache.maven.plugin.MojoExecutionException; +import org.apache.maven.plugin.MojoFailureException; +import org.overture.ast.lex.Dialect; +import org.overture.codegen.ir.IRSettings; +import org.overture.codegen.utils.GeneralCodeGenUtils; +import org.overture.codegen.vdm2java.JavaCodeGenMain; +import org.overture.codegen.vdm2java.JavaSettings; +import org.overture.config.Release; +import org.overture.config.Settings; + +/** + * Generate Tree + * + * @goal generate + * @phase generate-sources + * @requiresDependencyResolution compile + */ +public class GenerateJavaSources extends AstCreatorBaseMojo +{ + + @Override + public void execute() throws MojoExecutionException, MojoFailureException + { + getLog().info("Preparing for VDM to Java generation..."); + // Let's make sure that maven knows to look in the output directory + project.addCompileSourceRoot(outputDirectory.getPath()); + + Settings.release = Release.VDM_10; + Dialect dialect = Dialect.VDM_PP; + + IRSettings irSettings = new IRSettings(); + irSettings.setCharSeqAsString(true); + irSettings.setGeneratePreConds(false); + irSettings.setGeneratePreCondChecks(false); + irSettings.setGeneratePostConds(false); + irSettings.setGeneratePostCondChecks(false); + + JavaSettings javaSettings = new JavaSettings(); + javaSettings.setDisableCloning(false); + + if (GeneralCodeGenUtils.isValidJavaPackage(packageName)) + { + javaSettings.setJavaRootPackage(packageName); + } else + { + getLog().error(String.format("The Java package: '%s' is not valid.", packageName)); + // throw new MojoFailureException + } + + Collection files = null; + if (getProjectVdmSrcDirectory() != null) + { + files = FileUtils.listFiles(getProjectVdmSrcDirectory(), new RegexFileFilter(".+\\.vpp|.+\\.vdmpp"), DirectoryFileFilter.DIRECTORY); + } + + if (files == null || files.isEmpty()) + { + getLog().info("Nothing to generate, no specification files."); + return; + } + + outputDirectory.mkdirs(); + + getLog().info("Starting generation..."); + List tmp = new Vector(); + tmp.addAll(files); + JavaCodeGenMain.handleOo(tmp, irSettings, javaSettings, dialect, false, outputDirectory); + getLog().info("Generation completed."); + } + + private Collection getSpecFiles(File root) + { + List files = new Vector(); + + for (File file : root.listFiles(new VdmppNameFilter())) + {// TODO + files.add(file); + } + return files; + } + +} diff --git a/core/codegen-plugin/src/main/java/org/overture/tools/maven/astcreator/VdmppNameFilter.java b/core/codegen-plugin/src/main/java/org/overture/tools/maven/astcreator/VdmppNameFilter.java new file mode 100644 index 0000000000..72424f7d9e --- /dev/null +++ b/core/codegen-plugin/src/main/java/org/overture/tools/maven/astcreator/VdmppNameFilter.java @@ -0,0 +1,15 @@ +package org.overture.tools.maven.astcreator; + +import java.io.File; +import java.io.FilenameFilter; + +public class VdmppNameFilter implements FilenameFilter +{ + + @Override + public boolean accept(File arg0, String arg1) + { + return arg1.endsWith(".vdmpp"); + } + +} From 1e71450b3a418443a1edc3683f38c82d8970a8a3 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sun, 8 Mar 2015 15:42:15 +0100 Subject: [PATCH 248/323] Added some test to exercise normalisation of names to conform to the Java naming conventions --- .../resources/renaming_specs/AssignmentDef | 24 +++++++ .../renaming_specs/AssignmentDef.result | 42 ++++++++++++ .../test/resources/renaming_specs/ClassName | 19 ++++++ .../resources/renaming_specs/ClassName.result | 38 +++++++++++ .../test/resources/renaming_specs/FuncName | 21 ++++++ .../resources/renaming_specs/FuncName.result | 45 +++++++++++++ .../test/resources/renaming_specs/InstanceVar | 24 +++++++ .../renaming_specs/InstanceVar.result | 42 ++++++++++++ .../src/test/resources/renaming_specs/LetExp | 23 +++++++ .../resources/renaming_specs/LetExp.result | 47 ++++++++++++++ .../src/test/resources/renaming_specs/LetStm | 23 +++++++ .../resources/renaming_specs/LetStm.result | 42 ++++++++++++ .../src/test/resources/renaming_specs/OpName | 21 ++++++ .../resources/renaming_specs/OpName.result | 40 ++++++++++++ .../renaming_specs/SameNameInDifferentOps | 29 +++++++++ .../SameNameInDifferentOps.result | 48 ++++++++++++++ .../renaming_specs/SamePatchTwoClass | 35 ++++++++++ .../renaming_specs/SamePatchTwoClass.result | 64 +++++++++++++++++++ .../test/resources/renaming_specs/ValueDef | 24 +++++++ .../resources/renaming_specs/ValueDef.result | 42 ++++++++++++ 20 files changed, 693 insertions(+) create mode 100644 core/codegen/src/test/resources/renaming_specs/AssignmentDef create mode 100644 core/codegen/src/test/resources/renaming_specs/AssignmentDef.result create mode 100644 core/codegen/src/test/resources/renaming_specs/ClassName create mode 100644 core/codegen/src/test/resources/renaming_specs/ClassName.result create mode 100644 core/codegen/src/test/resources/renaming_specs/FuncName create mode 100644 core/codegen/src/test/resources/renaming_specs/FuncName.result create mode 100644 core/codegen/src/test/resources/renaming_specs/InstanceVar create mode 100644 core/codegen/src/test/resources/renaming_specs/InstanceVar.result create mode 100644 core/codegen/src/test/resources/renaming_specs/LetExp create mode 100644 core/codegen/src/test/resources/renaming_specs/LetExp.result create mode 100644 core/codegen/src/test/resources/renaming_specs/LetStm create mode 100644 core/codegen/src/test/resources/renaming_specs/LetStm.result create mode 100644 core/codegen/src/test/resources/renaming_specs/OpName create mode 100644 core/codegen/src/test/resources/renaming_specs/OpName.result create mode 100644 core/codegen/src/test/resources/renaming_specs/SameNameInDifferentOps create mode 100644 core/codegen/src/test/resources/renaming_specs/SameNameInDifferentOps.result create mode 100644 core/codegen/src/test/resources/renaming_specs/SamePatchTwoClass create mode 100644 core/codegen/src/test/resources/renaming_specs/SamePatchTwoClass.result create mode 100644 core/codegen/src/test/resources/renaming_specs/ValueDef create mode 100644 core/codegen/src/test/resources/renaming_specs/ValueDef.result diff --git a/core/codegen/src/test/resources/renaming_specs/AssignmentDef b/core/codegen/src/test/resources/renaming_specs/AssignmentDef new file mode 100644 index 0000000000..a28181e2d4 --- /dev/null +++ b/core/codegen/src/test/resources/renaming_specs/AssignmentDef @@ -0,0 +1,24 @@ +class Entry + +operations + +public static Run : () ==> ? +Run () == +let a = new A'() +in + return a.op(); + +end Entry + +class A' + +operations + +public op : () ==> nat +op () == +( + dcl y' : nat := 11; + return y'; +); + +end A' \ No newline at end of file diff --git a/core/codegen/src/test/resources/renaming_specs/AssignmentDef.result b/core/codegen/src/test/resources/renaming_specs/AssignmentDef.result new file mode 100644 index 0000000000..cd9631de9a --- /dev/null +++ b/core/codegen/src/test/resources/renaming_specs/AssignmentDef.result @@ -0,0 +1,42 @@ +import org.overture.codegen.runtime.*; + +import java.util.*; + + +public class Entry { + public Entry() { + } + + public static Object Run() { + A_X_ a = new A_X_(); + + return a.op(); + } + + public String toString() { + return "Entry{}"; + } +} + +########## +import org.overture.codegen.runtime.*; + +import java.util.*; + + +public class A_X_ { + public A_X_() { + } + + public Number op() { + Number y_X_ = 11L; + + return y_X_; + } + + public String toString() { + return "A_X_{}"; + } +} + +########## diff --git a/core/codegen/src/test/resources/renaming_specs/ClassName b/core/codegen/src/test/resources/renaming_specs/ClassName new file mode 100644 index 0000000000..d620b1159b --- /dev/null +++ b/core/codegen/src/test/resources/renaming_specs/ClassName @@ -0,0 +1,19 @@ +class Entry + +operations + +public static Run : () ==> ? +Run () == +let a = new A'() +in + return a.x; + +end Entry + +class A' + +instance variables + +public x : nat := 5; + +end A' \ No newline at end of file diff --git a/core/codegen/src/test/resources/renaming_specs/ClassName.result b/core/codegen/src/test/resources/renaming_specs/ClassName.result new file mode 100644 index 0000000000..c0384164ac --- /dev/null +++ b/core/codegen/src/test/resources/renaming_specs/ClassName.result @@ -0,0 +1,38 @@ +import org.overture.codegen.runtime.*; + +import java.util.*; + + +public class Entry { + public Entry() { + } + + public static Object Run() { + A_X_ a = new A_X_(); + + return a.x; + } + + public String toString() { + return "Entry{}"; + } +} + +########## +import org.overture.codegen.runtime.*; + +import java.util.*; + + +public class A_X_ { + public Number x = 5L; + + public A_X_() { + } + + public String toString() { + return "A_X_{" + "x := " + Utils.toString(x) + "}"; + } +} + +########## diff --git a/core/codegen/src/test/resources/renaming_specs/FuncName b/core/codegen/src/test/resources/renaming_specs/FuncName new file mode 100644 index 0000000000..9e9c82d955 --- /dev/null +++ b/core/codegen/src/test/resources/renaming_specs/FuncName @@ -0,0 +1,21 @@ +class Entry + +operations + +public static Run : () ==> ? +Run () == +let a = new A'() +in + return a.f'(); + +end Entry + +class A' + +functions + +public f' : () -> nat +f'() == + 2*97; + +end A' \ No newline at end of file diff --git a/core/codegen/src/test/resources/renaming_specs/FuncName.result b/core/codegen/src/test/resources/renaming_specs/FuncName.result new file mode 100644 index 0000000000..99e3fa131d --- /dev/null +++ b/core/codegen/src/test/resources/renaming_specs/FuncName.result @@ -0,0 +1,45 @@ +import org.overture.codegen.runtime.*; + +import java.util.*; + + +public class Entry { + public Entry() { + } + + public static Object Run() { + A_X_ a = new A_X_(); + + return a.f_X_(); + } + + public String toString() { + return "Entry{}"; + } +} + +########## +import org.overture.codegen.runtime.*; + +import java.util.*; + + +public class A_X_ { + public A_X_() { + } + + public static Number f_X_() { + return 2L * 97L; + } + + public String toString() { + return "A_X_{}"; + } +} + +########## +public interface Func_1 { + public abstract T_1 eval(); +} + +########## diff --git a/core/codegen/src/test/resources/renaming_specs/InstanceVar b/core/codegen/src/test/resources/renaming_specs/InstanceVar new file mode 100644 index 0000000000..b8c9497d20 --- /dev/null +++ b/core/codegen/src/test/resources/renaming_specs/InstanceVar @@ -0,0 +1,24 @@ +class Entry + +operations + +public static Run : () ==> ? +Run () == +let a = new A'() +in + return a.x' + a.op(); + +end Entry + +class A' + +instance variables + +public x' : nat := 5; + +operations + +public op : () ==> nat +op () == return x'; + +end A' \ No newline at end of file diff --git a/core/codegen/src/test/resources/renaming_specs/InstanceVar.result b/core/codegen/src/test/resources/renaming_specs/InstanceVar.result new file mode 100644 index 0000000000..2f939786e2 --- /dev/null +++ b/core/codegen/src/test/resources/renaming_specs/InstanceVar.result @@ -0,0 +1,42 @@ +import org.overture.codegen.runtime.*; + +import java.util.*; + + +public class Entry { + public Entry() { + } + + public static Object Run() { + A_X_ a = new A_X_(); + + return a.x_X_.longValue() + a.op().longValue(); + } + + public String toString() { + return "Entry{}"; + } +} + +########## +import org.overture.codegen.runtime.*; + +import java.util.*; + + +public class A_X_ { + public Number x_X_ = 5L; + + public A_X_() { + } + + public Number op() { + return x_X_; + } + + public String toString() { + return "A_X_{" + "x_X_ := " + Utils.toString(x_X_) + "}"; + } +} + +########## diff --git a/core/codegen/src/test/resources/renaming_specs/LetExp b/core/codegen/src/test/resources/renaming_specs/LetExp new file mode 100644 index 0000000000..a33a06a833 --- /dev/null +++ b/core/codegen/src/test/resources/renaming_specs/LetExp @@ -0,0 +1,23 @@ +class Entry + +operations + +public static Run : () ==> ? +Run () == +let a = new A'() +in + return a.f(); + +end Entry + +class A' + +functions + +public f : () -> nat +f () == +let y' = 2 +in + y'; + +end A' \ No newline at end of file diff --git a/core/codegen/src/test/resources/renaming_specs/LetExp.result b/core/codegen/src/test/resources/renaming_specs/LetExp.result new file mode 100644 index 0000000000..4d66aa3bc8 --- /dev/null +++ b/core/codegen/src/test/resources/renaming_specs/LetExp.result @@ -0,0 +1,47 @@ +import org.overture.codegen.runtime.*; + +import java.util.*; + + +public class Entry { + public Entry() { + } + + public static Object Run() { + A_X_ a = new A_X_(); + + return a.f(); + } + + public String toString() { + return "Entry{}"; + } +} + +########## +import org.overture.codegen.runtime.*; + +import java.util.*; + + +public class A_X_ { + public A_X_() { + } + + public static Number f() { + Number y_X_ = 2L; + + return y_X_; + } + + public String toString() { + return "A_X_{}"; + } +} + +########## +public interface Func_1 { + public abstract T_1 eval(); +} + +########## diff --git a/core/codegen/src/test/resources/renaming_specs/LetStm b/core/codegen/src/test/resources/renaming_specs/LetStm new file mode 100644 index 0000000000..1a76573bdf --- /dev/null +++ b/core/codegen/src/test/resources/renaming_specs/LetStm @@ -0,0 +1,23 @@ +class Entry + +operations + +public static Run : () ==> ? +Run () == +let a = new A'() +in + return a.op(); + +end Entry + +class A' + +operations + +public op : () ==> nat +op () == +let y' = 43 +in + return y'; + +end A' \ No newline at end of file diff --git a/core/codegen/src/test/resources/renaming_specs/LetStm.result b/core/codegen/src/test/resources/renaming_specs/LetStm.result new file mode 100644 index 0000000000..4f1f4f4486 --- /dev/null +++ b/core/codegen/src/test/resources/renaming_specs/LetStm.result @@ -0,0 +1,42 @@ +import org.overture.codegen.runtime.*; + +import java.util.*; + + +public class Entry { + public Entry() { + } + + public static Object Run() { + A_X_ a = new A_X_(); + + return a.op(); + } + + public String toString() { + return "Entry{}"; + } +} + +########## +import org.overture.codegen.runtime.*; + +import java.util.*; + + +public class A_X_ { + public A_X_() { + } + + public Number op() { + Number y_X_ = 43L; + + return y_X_; + } + + public String toString() { + return "A_X_{}"; + } +} + +########## diff --git a/core/codegen/src/test/resources/renaming_specs/OpName b/core/codegen/src/test/resources/renaming_specs/OpName new file mode 100644 index 0000000000..72db81a640 --- /dev/null +++ b/core/codegen/src/test/resources/renaming_specs/OpName @@ -0,0 +1,21 @@ +class Entry + +operations + +public static Run : () ==> ? +Run () == +let a = new A'() +in + return a.op'(); + +end Entry + +class A' + +operations + +public op' : () ==> nat +op'() == + return 98; + +end A' \ No newline at end of file diff --git a/core/codegen/src/test/resources/renaming_specs/OpName.result b/core/codegen/src/test/resources/renaming_specs/OpName.result new file mode 100644 index 0000000000..efc239099c --- /dev/null +++ b/core/codegen/src/test/resources/renaming_specs/OpName.result @@ -0,0 +1,40 @@ +import org.overture.codegen.runtime.*; + +import java.util.*; + + +public class Entry { + public Entry() { + } + + public static Object Run() { + A_X_ a = new A_X_(); + + return a.op_X_(); + } + + public String toString() { + return "Entry{}"; + } +} + +########## +import org.overture.codegen.runtime.*; + +import java.util.*; + + +public class A_X_ { + public A_X_() { + } + + public Number op_X_() { + return 98L; + } + + public String toString() { + return "A_X_{}"; + } +} + +########## diff --git a/core/codegen/src/test/resources/renaming_specs/SameNameInDifferentOps b/core/codegen/src/test/resources/renaming_specs/SameNameInDifferentOps new file mode 100644 index 0000000000..27df2bcb65 --- /dev/null +++ b/core/codegen/src/test/resources/renaming_specs/SameNameInDifferentOps @@ -0,0 +1,29 @@ +class Entry + +operations + +public static Run : () ==> ? +Run () == +let a = new A'() +in + return a.op() + a.op1(); + +end Entry + +class A' + +operations + + +public op : () ==> nat +op () == +(dcl y' : nat := 5; + return y';); + +public op1 : () ==> nat +op1 () == +let y' = 42 +in + return y'; + +end A' \ No newline at end of file diff --git a/core/codegen/src/test/resources/renaming_specs/SameNameInDifferentOps.result b/core/codegen/src/test/resources/renaming_specs/SameNameInDifferentOps.result new file mode 100644 index 0000000000..99228ae00e --- /dev/null +++ b/core/codegen/src/test/resources/renaming_specs/SameNameInDifferentOps.result @@ -0,0 +1,48 @@ +import org.overture.codegen.runtime.*; + +import java.util.*; + + +public class Entry { + public Entry() { + } + + public static Object Run() { + A_X_ a = new A_X_(); + + return a.op().longValue() + a.op1().longValue(); + } + + public String toString() { + return "Entry{}"; + } +} + +########## +import org.overture.codegen.runtime.*; + +import java.util.*; + + +public class A_X_ { + public A_X_() { + } + + public Number op() { + Number y_X_ = 5L; + + return y_X_; + } + + public Number op1() { + Number y_X_ = 42L; + + return y_X_; + } + + public String toString() { + return "A_X_{}"; + } +} + +########## diff --git a/core/codegen/src/test/resources/renaming_specs/SamePatchTwoClass b/core/codegen/src/test/resources/renaming_specs/SamePatchTwoClass new file mode 100644 index 0000000000..91ff5b8f08 --- /dev/null +++ b/core/codegen/src/test/resources/renaming_specs/SamePatchTwoClass @@ -0,0 +1,35 @@ +class Entry + +operations + +public static Run : () ==> ? +Run () == +let a = new A'(), + b = new B'() +in + return a.op'() + b.op'(); + +end Entry + +class A' + +operations + +public op' : () ==> nat +op' () == +(dcl y' : nat := 6; + return y';); + +end A' + +class B' + +operations + +public op' : () ==> nat +op' () == +let y' = 42 +in + return y'; + +end B' \ No newline at end of file diff --git a/core/codegen/src/test/resources/renaming_specs/SamePatchTwoClass.result b/core/codegen/src/test/resources/renaming_specs/SamePatchTwoClass.result new file mode 100644 index 0000000000..878b83c3b8 --- /dev/null +++ b/core/codegen/src/test/resources/renaming_specs/SamePatchTwoClass.result @@ -0,0 +1,64 @@ +import org.overture.codegen.runtime.*; + +import java.util.*; + + +public class Entry { + public Entry() { + } + + public static Object Run() { + A_X_ a = new A_X_(); + B_X_ b = new B_X_(); + + return a.op_X_().longValue() + b.op_X_().longValue(); + } + + public String toString() { + return "Entry{}"; + } +} + +########## +import org.overture.codegen.runtime.*; + +import java.util.*; + + +public class A_X_ { + public A_X_() { + } + + public Number op_X_() { + Number y_X_ = 6L; + + return y_X_; + } + + public String toString() { + return "A_X_{}"; + } +} + +########## +import org.overture.codegen.runtime.*; + +import java.util.*; + + +public class B_X_ { + public B_X_() { + } + + public Number op_X_() { + Number y_X_ = 42L; + + return y_X_; + } + + public String toString() { + return "B_X_{}"; + } +} + +########## diff --git a/core/codegen/src/test/resources/renaming_specs/ValueDef b/core/codegen/src/test/resources/renaming_specs/ValueDef new file mode 100644 index 0000000000..d137704d4d --- /dev/null +++ b/core/codegen/src/test/resources/renaming_specs/ValueDef @@ -0,0 +1,24 @@ +class Entry + +operations + +public static Run : () ==> ? +Run () == +let a = new A'() +in + return a.q' + a.op(); + +end Entry + +class A' + +values + +public q' = 42; + +operations + +public op : () ==> nat +op () == return q'; + +end A' \ No newline at end of file diff --git a/core/codegen/src/test/resources/renaming_specs/ValueDef.result b/core/codegen/src/test/resources/renaming_specs/ValueDef.result new file mode 100644 index 0000000000..aa965ee48e --- /dev/null +++ b/core/codegen/src/test/resources/renaming_specs/ValueDef.result @@ -0,0 +1,42 @@ +import org.overture.codegen.runtime.*; + +import java.util.*; + + +public class Entry { + public Entry() { + } + + public static Object Run() { + A_X_ a = new A_X_(); + + return a.q_X_.longValue() + a.op().longValue(); + } + + public String toString() { + return "Entry{}"; + } +} + +########## +import org.overture.codegen.runtime.*; + +import java.util.*; + + +public class A_X_ { + public static final Number q_X_ = 42L; + + public A_X_() { + } + + public Number op() { + return q_X_; + } + + public String toString() { + return "A_X_{" + "q_X_ = " + Utils.toString(q_X_) + "}"; + } +} + +########## From 26761a332f663b16cab077d99c19de9e24c24f59 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sun, 8 Mar 2015 15:44:02 +0100 Subject: [PATCH 249/323] Added the normalisation test to codegen --- .../codegen/tests/NameNormalising.java | 30 +++++++++++++++++++ .../org/overture/codegen/tests/TestFlags.java | 1 + 2 files changed, 31 insertions(+) create mode 100644 core/codegen/src/test/java/org/overture/codegen/tests/NameNormalising.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/NameNormalising.java b/core/codegen/src/test/java/org/overture/codegen/tests/NameNormalising.java new file mode 100644 index 0000000000..725ebd31df --- /dev/null +++ b/core/codegen/src/test/java/org/overture/codegen/tests/NameNormalising.java @@ -0,0 +1,30 @@ +package org.overture.codegen.tests; + +import java.io.File; +import java.io.IOException; +import java.lang.reflect.InvocationTargetException; + +import junit.framework.Test; +import junit.framework.TestSuite; + +import org.overture.ast.lex.LexLocation; +import org.overture.test.framework.BaseTestSuite; +import org.overture.test.framework.Properties; + +public class NameNormalising extends BaseTestSuite +{ + public static final String ROOT = "src" + File.separatorChar + "test" + + File.separatorChar + "resources" + File.separatorChar + "renaming_specs"; + + public static Test suite() throws IllegalArgumentException, + SecurityException, InstantiationException, IllegalAccessException, + InvocationTargetException, NoSuchMethodException, IOException + { + LexLocation.absoluteToStringLocation = false; + Properties.recordTestResults = TestFlags.NAME_NORMALISING_TESTS_ON; + + String name = "Name normalising test case"; + TestSuite test = createTestCompleteFile(name, ROOT, SpecificationTestCase.class, ""); + return test; + } +} diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/TestFlags.java b/core/codegen/src/test/java/org/overture/codegen/tests/TestFlags.java index d08bfec051..e881bbbe65 100644 --- a/core/codegen/src/test/java/org/overture/codegen/tests/TestFlags.java +++ b/core/codegen/src/test/java/org/overture/codegen/tests/TestFlags.java @@ -38,4 +38,5 @@ public class TestFlags public static final boolean PRE_POST_TESTS_ON = false; public static final boolean RT_TESTS_ON = false; public static final boolean PACKAGE_TESTS_ON = false; + public static final boolean NAME_NORMALISING_TESTS_ON = false; } From 7f65091bf3b6e06a314f393ca55f0d81979b8c52 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sun, 8 Mar 2015 15:45:39 +0100 Subject: [PATCH 250/323] Added the name normalising test to the test execution system --- .../codegen/tests/utils/CompileTests.java | 21 +++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/CompileTests.java b/core/codegen/src/test/java/org/overture/codegen/tests/utils/CompileTests.java index 14deb62f0e..d2690d24c2 100644 --- a/core/codegen/src/test/java/org/overture/codegen/tests/utils/CompileTests.java +++ b/core/codegen/src/test/java/org/overture/codegen/tests/utils/CompileTests.java @@ -41,6 +41,7 @@ import org.overture.codegen.tests.ConfiguredStringGenerationTest; import org.overture.codegen.tests.ExpressionTest; import org.overture.codegen.tests.FunctionValueTest; +import org.overture.codegen.tests.NameNormalising; import org.overture.codegen.tests.PackageTest; import org.overture.codegen.tests.PatternTest; import org.overture.codegen.tests.PrePostTest; @@ -84,6 +85,7 @@ public class CompileTests public static final boolean RUN_CONCURRENCY_CLASSIC_TESTS = true; public static final boolean RUN_RT_TESTS = true; public static final boolean RUN_PACKAGE_TESTS = true; + public static final boolean RUN_NAMING_NORMALISING_TESTS = true; public static final boolean RUN_BIND_TESTS = true; public static final boolean PRE_POST_TESTS = true; public static final boolean RUN_EXECUTING_CLASSIC_SPEC_TESTS = true; @@ -170,6 +172,11 @@ private void runTests() throws IOException runPackageTests(); } + if(RUN_NAMING_NORMALISING_TESTS) + { + runNamingNormalisingTests(); + } + if (RUN_BIND_TESTS) { runBindTests(); @@ -201,6 +208,20 @@ private void runTests() throws IOException + String.format("%02d:%02d", minutes, seconds) + "."); } + private void runNamingNormalisingTests() throws IOException + { + System.out.println("Beginning name normalising tests..\n"); + + testInputFiles = TestUtils.getTestInputFiles(new File(NameNormalising.ROOT)); + resultFiles = TestUtils.getFiles(new File(NameNormalising.ROOT), RESULT_FILE_EXTENSION); + + runTests(testInputFiles, resultFiles, new ExecutableSpecTestHandler(Release.VDM_10, Dialect.VDM_RT), false); + + System.out.println("\n********"); + System.out.println("Finished with name normalising tests"); + System.out.println("********\n"); + } + private void runPackageTests() throws IOException { System.out.println("Beginning package tests..\n"); From cd2e6cd003578378bec39f17035a04c3c40059af Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sun, 8 Mar 2015 15:49:06 +0100 Subject: [PATCH 251/323] Added functionality to validate Java identifiers --- .../codegen/utils/GeneralCodeGenUtils.java | 106 +++++++++++++++++- 1 file changed, 105 insertions(+), 1 deletion(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/utils/GeneralCodeGenUtils.java b/core/codegen/src/main/java/org/overture/codegen/utils/GeneralCodeGenUtils.java index 217bfef76e..f4f51e1873 100644 --- a/core/codegen/src/main/java/org/overture/codegen/utils/GeneralCodeGenUtils.java +++ b/core/codegen/src/main/java/org/overture/codegen/utils/GeneralCodeGenUtils.java @@ -48,6 +48,7 @@ import org.overture.codegen.cgast.declarations.AClassDeclCG; import org.overture.codegen.ir.ITempVarGen; import org.overture.codegen.logging.Logger; +import org.overture.codegen.vdm2java.IJavaCodeGenConstants; import org.overture.codegen.vdm2java.JavaCodeGen; import org.overture.parser.lex.LexException; import org.overture.parser.lex.LexTokenReader; @@ -369,7 +370,22 @@ public static boolean isValidJavaPackage(String pack) Pattern pattern = Pattern.compile("^[a-zA-Z_\\$][\\w\\$]*(?:\\.[a-zA-Z_\\$][\\w\\$]*)*$"); - return pattern.matcher(pack).matches(); + if(!pattern.matcher(pack).matches()) + { + return false; + } + + String [] split = pack.split("\\."); + + for(String s : split) + { + if(isJavaKeyword(s)) + { + return false; + } + } + + return true; } public static String getFolderFromJavaRootPackage(String pack) @@ -397,4 +413,92 @@ public static boolean isQuote(SDeclCG decl) return false; } } + + public static boolean isJavaKeyword(String s) + { + if(s == null || s.isEmpty()) + { + return false; + } + + for(String kw : IJavaCodeGenConstants.RESERVED_WORDS) + { + if(s.equals(kw)) + { + return true; + } + } + + return false; + } + + /** + * Checks whether the given String is a valid Java identifier. + * + * @param s the String to check + * @return true if 's' is an identifier, false otherwise + */ + public static boolean isValidJavaIdentifier(String s) + { + if (s == null || s.length() == 0) + { + return false; + } + + if(isJavaKeyword(s)) + { + return false; + } + + char[] c = s.toCharArray(); + if (!Character.isJavaIdentifierStart(c[0])) + { + return false; + } + + for (int i = 1; i < c.length; i++) + { + if (!Character.isJavaIdentifierPart(c[i])) + { + return false; + } + } + + return true; + } + + /** + * Computes the indices of characters that need to be replaced with valid characters in order to make 's' a valid + * Java identifier. Please note that this method assumes that 's' is NOT a keyword. + * + * @param s the identifier to compute correction indices for. + * @return the indices of the characters that need to be corrected in order to make the identifier a valid Java + * identifier + */ + public static List computeJavaIdentifierCorrections(String s) + { + List correctionIndices = new LinkedList(); + + if (s == null || s.length() == 0) + { + return correctionIndices; + } + + char[] c = s.toCharArray(); + + if (!Character.isJavaIdentifierStart(c[0])) + { + correctionIndices.add(0); + } + + for (int i = 1; i < c.length; i++) + { + if (!Character.isJavaIdentifierPart(c[i])) + { + correctionIndices.add(i); + } + } + + return correctionIndices; + } } From b70c0c814ddaed5be4a810866b9fccbdfbce7420 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sun, 8 Mar 2015 15:53:31 +0100 Subject: [PATCH 252/323] Fix to a problem with the 'rename analysis' when the name belongs to an instance variable --- .../codegen/analysis/vdm/RenameAnalysis.java | 21 ++++++++++++++++++- 1 file changed, 20 insertions(+), 1 deletion(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/RenameAnalysis.java b/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/RenameAnalysis.java index 484d5e83bb..c756c1e1a0 100644 --- a/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/RenameAnalysis.java +++ b/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/RenameAnalysis.java @@ -4,8 +4,10 @@ import org.overture.ast.analysis.AnalysisException; import org.overture.ast.analysis.DepthFirstAnalysisAdaptor; +import org.overture.ast.definitions.AInstanceVariableDefinition; import org.overture.ast.intf.lex.ILexNameToken; import org.overture.ast.lex.LexNameToken; +import org.overture.ast.node.INode; class RenameAnalysis extends DepthFirstAnalysisAdaptor { @@ -16,15 +18,32 @@ public RenameAnalysis(List renamings) this.renamings = renamings; } + @Override + public void caseAInstanceVariableDefinition(AInstanceVariableDefinition node) + throws AnalysisException + { + handleNameToken(node, node.getName()); + handleNameToken(node, node.getOldname()); + + node.getExpression().apply(this); + node.getType().apply(this); + } + @Override public void caseILexNameToken(ILexNameToken node) throws AnalysisException + { + handleNameToken(node.parent(), node); + } + + private void handleNameToken(INode parent, ILexNameToken node) { for (Renaming r : renamings) { if (node.getLocation().equals(r.getLoc())) { - node.parent().replaceChild(node, consLexNameToken(node, r.getNewName())); + parent.replaceChild(node, consLexNameToken(node, r.getNewName())); + break; } } } From 7d78937a6cb80808a9b545222ffac8214d1613ec Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sun, 8 Mar 2015 15:57:54 +0100 Subject: [PATCH 253/323] Added an analysis to compute renamings that will normalise VDM identifiers to conform with Java's rules for naming identifiers --- .../vdm/JavaIdentifierNormaliser.java | 114 ++++++++++++++++++ 1 file changed, 114 insertions(+) create mode 100644 core/codegen/src/main/java/org/overture/codegen/analysis/vdm/JavaIdentifierNormaliser.java diff --git a/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/JavaIdentifierNormaliser.java b/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/JavaIdentifierNormaliser.java new file mode 100644 index 0000000000..0fd5d8ff30 --- /dev/null +++ b/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/JavaIdentifierNormaliser.java @@ -0,0 +1,114 @@ +package org.overture.codegen.analysis.vdm; + +import java.util.HashMap; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import org.overture.ast.analysis.AnalysisException; +import org.overture.ast.analysis.DepthFirstAnalysisAdaptor; +import org.overture.ast.intf.lex.ILexNameToken; +import org.overture.codegen.ir.ITempVarGen; +import org.overture.codegen.utils.GeneralCodeGenUtils; + +public class JavaIdentifierNormaliser extends DepthFirstAnalysisAdaptor +{ + private Set allNames; + private Map renamingsSoFar; + private ITempVarGen nameGen; + private List renamings; + + public JavaIdentifierNormaliser(Set allNames, ITempVarGen nameGen) + { + this.allNames = allNames; + this.renamingsSoFar = new HashMap(); + this.nameGen = nameGen; + this.renamings = new LinkedList(); + } + + @Override + public void inILexNameToken(ILexNameToken node) throws AnalysisException + { + if(!GeneralCodeGenUtils.isValidJavaIdentifier(node.getName())) + { + String newName = getReplacementName(node.getName()); + + this.renamings.add(new Renaming(node.getLocation(), node.getName(), newName)); + } + } + + public List getRenamings() + { + return renamings; + } + + public String getReplacementName(String invalidName) + { + String name = renamingsSoFar.get(invalidName); + + if(name != null) + { + // A replacement name has previously been computed for 'invalidName' just use that + return name; + } + + String suggestion = ""; + + if (GeneralCodeGenUtils.isJavaKeyword(invalidName)) + { + // appending '_' to a Java keyword makes it a valid identifier + suggestion = invalidName + "_"; + } else + { + suggestion = patchName(invalidName); + } + + // Now it is important that the suggestion does not collide with a name in the model + + if(allNames.contains(suggestion)) + { + // Okay the name is already used so we need to compute a new one (e.g. _42) + String prefix = suggestion + "_"; + suggestion = nameGen.nextVarName(prefix); + + while (allNames.contains(suggestion)) + { + suggestion = nameGen.nextVarName(prefix); + } + } + // else {the suggestion is valid and does not collide with another name in the model} + + // By now we should have computed a name that does not appear in the model + + // Register the name we are about to use to replace 'invalidName' + renamingsSoFar.put(invalidName, suggestion); + allNames.add(suggestion); + + return suggestion; + } + + private String patchName(String invalidName) + { + // Say we have an invalid name such as s' + final String PATCH = "_X_"; + List correctionIndices = GeneralCodeGenUtils.computeJavaIdentifierCorrections(invalidName); + + String tmp = ""; + char[] chars = invalidName.toCharArray(); + for(int i = 0; i < chars.length; i++) + { + if(correctionIndices.contains(i)) + { + tmp += PATCH; + } + else + { + tmp += chars[i]; + } + } + + // Return the patch named (e.g. s_X_) + return tmp; + } +} From 2aa5d223c9eafd0be0b0d412ef93ceed439150fe Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sun, 8 Mar 2015 16:08:41 +0100 Subject: [PATCH 254/323] Slightly improved naming analysis related classes by changing them to use sets for storing names --- .../codegen/analysis/vdm/NameCollector.java | 17 ++++++----------- .../vdm/VarShadowingRenameCollector.java | 5 +++-- 2 files changed, 9 insertions(+), 13 deletions(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/NameCollector.java b/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/NameCollector.java index 733bf738df..1605095a39 100644 --- a/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/NameCollector.java +++ b/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/NameCollector.java @@ -1,7 +1,7 @@ package org.overture.codegen.analysis.vdm; -import java.util.LinkedList; -import java.util.List; +import java.util.HashSet; +import java.util.Set; import org.overture.ast.analysis.AnalysisException; import org.overture.ast.analysis.DepthFirstAnalysisAdaptor; @@ -9,14 +9,14 @@ public class NameCollector extends DepthFirstAnalysisAdaptor { - private List names; + private Set names; public NameCollector() { - this.names = new LinkedList(); + this.names = new HashSet(); } - public List namesToAvoid() + public Set namesToAvoid() { return names; } @@ -24,11 +24,6 @@ public List namesToAvoid() @Override public void inILexNameToken(ILexNameToken node) throws AnalysisException { - String name = node.getName(); - - if (!names.contains(name)) - { - names.add(name); - } + names.add(node.getName()); } } diff --git a/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/VarShadowingRenameCollector.java b/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/VarShadowingRenameCollector.java index b752e1ea96..cd8a7514ea 100644 --- a/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/VarShadowingRenameCollector.java +++ b/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/VarShadowingRenameCollector.java @@ -1,6 +1,7 @@ package org.overture.codegen.analysis.vdm; import java.util.Collections; +import java.util.HashSet; import java.util.LinkedList; import java.util.List; import java.util.Map; @@ -79,7 +80,7 @@ public class VarShadowingRenameCollector extends DepthFirstAnalysisAdaptor private int enclosingCounter; private List renamings; - private List namesToAvoid; + private Set namesToAvoid; private TempVarNameGen nameGen; public VarShadowingRenameCollector(ITypeCheckerAssistantFactory af, Map idDefs) @@ -92,7 +93,7 @@ public VarShadowingRenameCollector(ITypeCheckerAssistantFactory af, Map(); - this.namesToAvoid = new LinkedList(); + this.namesToAvoid = new HashSet(); this.nameGen = new TempVarNameGen(); } From 953b34b944eb5f5d3ab0c758cf1ca0852706a1b0 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sun, 8 Mar 2015 16:17:08 +0100 Subject: [PATCH 255/323] Added identifier normalisation to the Java code generator --- ...rShadowingRenamer.java => VarRenamer.java} | 2 +- .../codegen/vdm2java/JavaCodeGen.java | 43 ++++++++++++++++++- .../codegen/tests/VarShadowingTestCase.java | 4 +- 3 files changed, 44 insertions(+), 5 deletions(-) rename core/codegen/src/main/java/org/overture/codegen/analysis/vdm/{VarShadowingRenamer.java => VarRenamer.java} (97%) diff --git a/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/VarShadowingRenamer.java b/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/VarRenamer.java similarity index 97% rename from core/codegen/src/main/java/org/overture/codegen/analysis/vdm/VarShadowingRenamer.java rename to core/codegen/src/main/java/org/overture/codegen/analysis/vdm/VarRenamer.java index 115871233e..e2cecbcd36 100644 --- a/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/VarShadowingRenamer.java +++ b/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/VarRenamer.java @@ -9,7 +9,7 @@ import org.overture.ast.statements.AIdentifierStateDesignator; import org.overture.typechecker.assistant.ITypeCheckerAssistantFactory; -public class VarShadowingRenamer +public class VarRenamer { public void rename(SClassDefinition clazz, List renamings) throws AnalysisException diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java index 23918aaaed..3e43cdff96 100644 --- a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java +++ b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java @@ -42,10 +42,12 @@ import org.overture.ast.statements.AIdentifierStateDesignator; import org.overture.ast.statements.ANotYetSpecifiedStm; import org.overture.codegen.analysis.vdm.IdStateDesignatorDefCollector; +import org.overture.codegen.analysis.vdm.JavaIdentifierNormaliser; +import org.overture.codegen.analysis.vdm.NameCollector; import org.overture.codegen.analysis.vdm.Renaming; import org.overture.codegen.analysis.vdm.UnreachableStmRemover; import org.overture.codegen.analysis.vdm.VarShadowingRenameCollector; -import org.overture.codegen.analysis.vdm.VarShadowingRenamer; +import org.overture.codegen.analysis.vdm.VarRenamer; import org.overture.codegen.analysis.violations.GeneratedVarComparison; import org.overture.codegen.analysis.violations.InvalidNamesResult; import org.overture.codegen.analysis.violations.ReservedWordsComparison; @@ -215,6 +217,7 @@ public GeneratedData generateJavaFromVdm( } } + normaliseIdentifiers(mergedParseLists); computeDefTable(mergedParseLists); // To document any renaming of variables shadowing other variables @@ -381,6 +384,42 @@ else if(mergeVisitor.hasUnsupportedTargLangNodes()) return data; } + private void normaliseIdentifiers(List mergedParseLists) + throws AnalysisException + { + List userClasses = new LinkedList(); + + for (SClassDefinition clazz : mergedParseLists) + { + if (!getInfo().getDeclAssistant().classIsLibrary(clazz)) + { + userClasses.add(clazz); + } + } + + NameCollector collector = new NameCollector(); + + for (SClassDefinition clazz : userClasses) + { + clazz.apply(collector); + } + + Set allNames = collector.namesToAvoid(); + + JavaIdentifierNormaliser normaliser = new JavaIdentifierNormaliser(allNames, getInfo().getTempVarNameGen()); + + for (SClassDefinition clazz : userClasses) + { + clazz.apply(normaliser); + } + + VarRenamer renamer = new VarRenamer(); + for (SClassDefinition clazz : userClasses) + { + renamer.rename(clazz, normaliser.getRenamings()); + } + } + private void computeDefTable(List mergedParseLists) throws AnalysisException { @@ -414,7 +453,7 @@ private List performRenaming(List mergedParseLists, List allRenamings = new LinkedList(); VarShadowingRenameCollector renamingsCollector = new VarShadowingRenameCollector(generator.getIRInfo().getTcFactory(), idDefs); - VarShadowingRenamer renamer = new VarShadowingRenamer(); + VarRenamer renamer = new VarRenamer(); for (SClassDefinition classDef : mergedParseLists) { diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/VarShadowingTestCase.java b/core/codegen/src/test/java/org/overture/codegen/tests/VarShadowingTestCase.java index faf156af98..7a6994b7d1 100644 --- a/core/codegen/src/test/java/org/overture/codegen/tests/VarShadowingTestCase.java +++ b/core/codegen/src/test/java/org/overture/codegen/tests/VarShadowingTestCase.java @@ -13,7 +13,7 @@ import org.overture.ast.statements.AIdentifierStateDesignator; import org.overture.codegen.analysis.vdm.IdStateDesignatorDefCollector; import org.overture.codegen.analysis.vdm.Renaming; -import org.overture.codegen.analysis.vdm.VarShadowingRenamer; +import org.overture.codegen.analysis.vdm.VarRenamer; import org.overture.codegen.logging.Logger; import org.overture.codegen.utils.GeneralUtils; import org.overture.config.Release; @@ -74,7 +74,7 @@ public void test() throws Exception Value orgSpecResult = evalSpec(originalSpecTcResult.result); - List renamings = new VarShadowingRenamer().computeRenamings(originalSpecTcResult.result, af, idDefs); + List renamings = new VarRenamer().computeRenamings(originalSpecTcResult.result, af, idDefs); StringBuilder sb = GeneralUtils.readLines(file, "\n"); From 1978ad1495e6fec38d72e71017169f86481545fc Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sun, 8 Mar 2015 16:18:30 +0100 Subject: [PATCH 256/323] New approach to handling use of Java keywords as identifiers requires update to existing test results --- .../specifications/NameViolationsJavakeyword.result | 13 +++---------- 1 file changed, 3 insertions(+), 10 deletions(-) diff --git a/core/codegen/src/test/resources/specifications/NameViolationsJavakeyword.result b/core/codegen/src/test/resources/specifications/NameViolationsJavakeyword.result index c7c48814a8..064ab788f5 100644 --- a/core/codegen/src/test/resources/specifications/NameViolationsJavakeyword.result +++ b/core/codegen/src/test/resources/specifications/NameViolationsJavakeyword.result @@ -7,11 +7,11 @@ public class A { public A() { } - public Number cg_double(final Number Character) { + public Number double_(final Number Character) { if (!(Utils.equals(1L, 2L))) { - return cg_double(3L); + return double_(3L); } else { - return cg_double(3L); + return double_(3L); } } @@ -21,10 +21,3 @@ public class A { } ########## -*Name Violations* - -Reserved name violation: [Violation in module A: 'double'. Location: line 5 at position: 8 in NameViolationsJavakeyword]. Prefix 'cg_' has been added to the name -Reserved name violation: [Violation in module A: 'double'. Location: line 9 at position: 16 in NameViolationsJavakeyword]. Prefix 'cg_' has been added to the name -Reserved name violation: [Violation in module A: 'double'. Location: line 13 at position: 16 in NameViolationsJavakeyword]. Prefix 'cg_' has been added to the name - -########## From eca5b358172054eea114e61340db469dea85f197 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sun, 8 Mar 2015 16:34:40 +0100 Subject: [PATCH 257/323] Optimisation to naming analysis: Do not add renamings that are already there --- .../vdm/JavaIdentifierNormaliser.java | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/JavaIdentifierNormaliser.java b/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/JavaIdentifierNormaliser.java index 0fd5d8ff30..ed4ac7be29 100644 --- a/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/JavaIdentifierNormaliser.java +++ b/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/JavaIdentifierNormaliser.java @@ -8,6 +8,7 @@ import org.overture.ast.analysis.AnalysisException; import org.overture.ast.analysis.DepthFirstAnalysisAdaptor; +import org.overture.ast.intf.lex.ILexLocation; import org.overture.ast.intf.lex.ILexNameToken; import org.overture.codegen.ir.ITempVarGen; import org.overture.codegen.utils.GeneralCodeGenUtils; @@ -34,8 +35,24 @@ public void inILexNameToken(ILexNameToken node) throws AnalysisException { String newName = getReplacementName(node.getName()); - this.renamings.add(new Renaming(node.getLocation(), node.getName(), newName)); + if (!contains(node.getLocation())) + { + this.renamings.add(new Renaming(node.getLocation(), node.getName(), newName)); + } + } + } + + private boolean contains(ILexLocation loc) + { + for (Renaming r : renamings) + { + if (r.getLoc().equals(loc)) + { + return true; + } } + + return false; } public List getRenamings() From e62c22ef4b5297cff9af3648d0097f0482195f99 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sun, 8 Mar 2015 16:36:33 +0100 Subject: [PATCH 258/323] The Java code generator now collects renamings of identifiers related to identifier normalisation. Subsequently these renamings are reported to the user. --- .../org/overture/codegen/vdm2java/JavaCodeGen.java | 14 ++++++++++---- .../overture/codegen/vdm2java/JavaCodeGenMain.java | 2 +- .../plugins/codegen/commands/Vdm2JavaCommand.java | 2 +- 3 files changed, 12 insertions(+), 6 deletions(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java index 3e43cdff96..bcc9491be8 100644 --- a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java +++ b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java @@ -217,12 +217,13 @@ public GeneratedData generateJavaFromVdm( } } - normaliseIdentifiers(mergedParseLists); + List allRenamings = normaliseIdentifiers(mergedParseLists); computeDefTable(mergedParseLists); // To document any renaming of variables shadowing other variables removeUnreachableStms(mergedParseLists); - List allRenamings = performRenaming(mergedParseLists, getInfo().getIdStateDesignatorDefs()); + + allRenamings.addAll(performRenaming(mergedParseLists, getInfo().getIdStateDesignatorDefs())); for (SClassDefinition classDef : mergedParseLists) { @@ -384,7 +385,7 @@ else if(mergeVisitor.hasUnsupportedTargLangNodes()) return data; } - private void normaliseIdentifiers(List mergedParseLists) + private List normaliseIdentifiers(List mergedParseLists) throws AnalysisException { List userClasses = new LinkedList(); @@ -414,10 +415,15 @@ private void normaliseIdentifiers(List mergedParseLists) } VarRenamer renamer = new VarRenamer(); + + List renamings = normaliser.getRenamings(); + for (SClassDefinition clazz : userClasses) { - renamer.rename(clazz, normaliser.getRenamings()); + renamer.rename(clazz, renamings); } + + return renamings; } private void computeDefTable(List mergedParseLists) diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGenMain.java b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGenMain.java index 256a952cd9..f29acc063e 100644 --- a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGenMain.java +++ b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGenMain.java @@ -355,7 +355,7 @@ public static void handleOo(List files, IRSettings irSettings, if (!allRenamings.isEmpty()) { - Logger.getLog().println("\nFollowing renamings of shadowing variables were made: "); + Logger.getLog().println("\nDue to variable shadowing or normalisation of Java identifiers the following renamings of variables have been made: "); Logger.getLog().println(JavaCodeGenUtil.constructVarRenamingString(allRenamings)); } diff --git a/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaCommand.java b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaCommand.java index 575654497d..2cf39d141a 100644 --- a/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaCommand.java +++ b/ide/plugins/codegen/src/main/java/org/overture/ide/plugins/codegen/commands/Vdm2JavaCommand.java @@ -416,7 +416,7 @@ private void outputRenamings(List allRenamings) { if(!allRenamings.isEmpty()) { - CodeGenConsole.GetInstance().println("Hidden variables found! Following variable renamings were done: "); + CodeGenConsole.GetInstance().println("Due to variable shadowing or normalisation of Java identifiers the following renamings of variables have been made:"); CodeGenConsole.GetInstance().println(JavaCodeGenUtil.constructVarRenamingString(allRenamings));; } } From 83b31849abf5eaa94a06e3c5e601ea5890c82e91 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sun, 8 Mar 2015 21:51:26 +0100 Subject: [PATCH 259/323] Small optimisation tweaks to the Java code generator --- .../codegen/vdm2java/JavaCodeGen.java | 40 ++++++++++++------- 1 file changed, 25 insertions(+), 15 deletions(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java index bcc9491be8..cfe2ddb19c 100644 --- a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java +++ b/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java @@ -196,7 +196,7 @@ public List generateJavaFromVdmQuotes() } public GeneratedData generateJavaFromVdm( - List mergedParseLists) throws AnalysisException, + List ast) throws AnalysisException, UnsupportedModelingException { SClassDefinition mainClass = null; @@ -206,9 +206,9 @@ public GeneratedData generateJavaFromVdm( { try { - mainClass = GeneralCodeGenUtils.consMainClass(mergedParseLists, getJavaSettings().getVdmEntryExp(), + mainClass = GeneralCodeGenUtils.consMainClass(ast, getJavaSettings().getVdmEntryExp(), Settings.dialect, JAVA_MAIN_CLASS_NAME, getInfo().getTempVarNameGen()); - mergedParseLists.add(mainClass); + ast.add(mainClass); } catch (Exception e) { // It can go wrong if the VDM entry point does not type check @@ -216,16 +216,18 @@ public GeneratedData generateJavaFromVdm( warnings.add("Skipping launch configuration.."); } } + + List userClasses = getUserClasses(ast); - List allRenamings = normaliseIdentifiers(mergedParseLists); - computeDefTable(mergedParseLists); + List allRenamings = normaliseIdentifiers(userClasses); + computeDefTable(userClasses); // To document any renaming of variables shadowing other variables - removeUnreachableStms(mergedParseLists); + removeUnreachableStms(ast); - allRenamings.addAll(performRenaming(mergedParseLists, getInfo().getIdStateDesignatorDefs())); + allRenamings.addAll(performRenaming(userClasses, getInfo().getIdStateDesignatorDefs())); - for (SClassDefinition classDef : mergedParseLists) + for (SClassDefinition classDef : ast) { if (generator.getIRInfo().getAssistantManager().getDeclAssistant().classIsLibrary(classDef)) { @@ -233,12 +235,12 @@ public GeneratedData generateJavaFromVdm( } } - InvalidNamesResult invalidNamesResult = validateVdmModelNames(mergedParseLists); - validateVdmModelingConstructs(mergedParseLists); + InvalidNamesResult invalidNamesResult = validateVdmModelNames(userClasses); + validateVdmModelingConstructs(userClasses); List statuses = new ArrayList(); - for (SClassDefinition classDef : mergedParseLists) + for (SClassDefinition classDef : ast) { statuses.add(generator.generateFrom(classDef)); } @@ -280,7 +282,10 @@ public GeneratedData generateJavaFromVdm( { try { - generator.applyTransformation(status, transformation); + if (!getInfo().getDeclAssistant().isLibraryName(status.getClassName())) + { + generator.applyTransformation(status, transformation); + } } catch (org.overture.codegen.cgast.analysis.AnalysisException e) { @@ -385,8 +390,8 @@ else if(mergeVisitor.hasUnsupportedTargLangNodes()) return data; } - private List normaliseIdentifiers(List mergedParseLists) - throws AnalysisException + private List getUserClasses( + List mergedParseLists) { List userClasses = new LinkedList(); @@ -397,7 +402,12 @@ private List normaliseIdentifiers(List mergedParseLi userClasses.add(clazz); } } - + return userClasses; + } + + private List normaliseIdentifiers(List userClasses) + throws AnalysisException + { NameCollector collector = new NameCollector(); for (SClassDefinition clazz : userClasses) From a5a15efea7bfa8a0898aa46a50752fd346aa8002 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sun, 8 Mar 2015 23:00:32 +0100 Subject: [PATCH 260/323] Some updates to test results related to code generation of traces This is a consequence of recent work on the pvj/main branch --- .../src/test/resources/traces_verdict_specs/MapNoSuchKey.result | 2 +- .../resources/traces_verdict_specs/SeqIndexOutOfRange.result | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/core/codegen/src/test/resources/traces_verdict_specs/MapNoSuchKey.result b/core/codegen/src/test/resources/traces_verdict_specs/MapNoSuchKey.result index ecd5ff00b7..33076babaa 100644 --- a/core/codegen/src/test/resources/traces_verdict_specs/MapNoSuchKey.result +++ b/core/codegen/src/test/resources/traces_verdict_specs/MapNoSuchKey.result @@ -11,7 +11,7 @@ public class Entry implements java.io.Serializable { public static Character f(final Number idx) { VDMMap xs = MapUtil.map(new Maplet(1L, 'a'), new Maplet(2L, 'b')); - return ((Character) MapUtil.get(xs, idx)); + return ((Character) Utils.get(xs, idx)); } public void Entry_T1_Run(final TestAccumulator testAccumulator) { diff --git a/core/codegen/src/test/resources/traces_verdict_specs/SeqIndexOutOfRange.result b/core/codegen/src/test/resources/traces_verdict_specs/SeqIndexOutOfRange.result index 09b734865d..a8d4d93cb7 100644 --- a/core/codegen/src/test/resources/traces_verdict_specs/SeqIndexOutOfRange.result +++ b/core/codegen/src/test/resources/traces_verdict_specs/SeqIndexOutOfRange.result @@ -11,7 +11,7 @@ public class Entry implements java.io.Serializable { public static Number f(final Number idx) { VDMSeq xs = SeqUtil.seq(1L, 2L); - return ((Number) xs.get(Utils.index(idx))); + return ((Number) Utils.get(xs, idx)); } public void Entry_T1_Run(final TestAccumulator testAccumulator) { From 58f8ab19af6bb68a387e3fa3f344e7288942ae31 Mon Sep 17 00:00:00 2001 From: Kenneth Lausdahl Date: Sun, 8 Mar 2015 23:06:59 +0100 Subject: [PATCH 261/323] changed config to place VDM sources under resources, and let the user specify a folder where the root of the specification is read from --- .../maven/astcreator/AstCreatorBaseMojo.java | 24 +++++++++---------- .../maven/astcreator/GenerateJavaSources.java | 11 +++++++-- 2 files changed, 21 insertions(+), 14 deletions(-) diff --git a/core/codegen-plugin/src/main/java/org/overture/tools/maven/astcreator/AstCreatorBaseMojo.java b/core/codegen-plugin/src/main/java/org/overture/tools/maven/astcreator/AstCreatorBaseMojo.java index 4e738924f0..f94ded83f7 100644 --- a/core/codegen-plugin/src/main/java/org/overture/tools/maven/astcreator/AstCreatorBaseMojo.java +++ b/core/codegen-plugin/src/main/java/org/overture/tools/maven/astcreator/AstCreatorBaseMojo.java @@ -71,13 +71,13 @@ public abstract class AstCreatorBaseMojo extends AbstractMojo */ protected String packageName; -// /** -// * The use src folder instead of generate-sources for the generated classes. -// * -// * @parameter -// */ -// protected Boolean useSrcOutput; -// + /** + * The name of the folder under resources where the specification is stored. + * + * @parameter + */ + protected String specificationDir; + /** * Name of the directory into which the astCreatorPlugin should dump the ast files. * @@ -141,11 +141,11 @@ protected File getProjectJavaSrcDirectory() return output; } - protected File getProjectVdmSrcDirectory() - { - File output = new File(project.getFile().getParentFile(), "src/main/vpp".replace('/', File.separatorChar)); - return output; - } +// protected File getProjectVdmSrcDirectory() +// { +// File output = new File(project.getFile().getParentFile(), "src/main/vdm".replace('/', File.separatorChar)); +// return output; +// } protected File getResourcesDir() { diff --git a/core/codegen-plugin/src/main/java/org/overture/tools/maven/astcreator/GenerateJavaSources.java b/core/codegen-plugin/src/main/java/org/overture/tools/maven/astcreator/GenerateJavaSources.java index 18df7066d3..6725b1afb5 100644 --- a/core/codegen-plugin/src/main/java/org/overture/tools/maven/astcreator/GenerateJavaSources.java +++ b/core/codegen-plugin/src/main/java/org/overture/tools/maven/astcreator/GenerateJavaSources.java @@ -58,9 +58,16 @@ public void execute() throws MojoExecutionException, MojoFailureException } Collection files = null; - if (getProjectVdmSrcDirectory() != null) + File specificationRoot = getResourcesDir(); + + if(specificationDir!=null && !specificationDir.isEmpty()) { - files = FileUtils.listFiles(getProjectVdmSrcDirectory(), new RegexFileFilter(".+\\.vpp|.+\\.vdmpp"), DirectoryFileFilter.DIRECTORY); + specificationRoot = new File(specificationRoot,specificationDir); + } + + if (specificationRoot != null && specificationRoot.exists()) + { + files = FileUtils.listFiles(specificationRoot, new RegexFileFilter(".+\\.vpp|.+\\.vdmpp"), DirectoryFileFilter.DIRECTORY); } if (files == null || files.isEmpty()) From 6d3852e7c49cdedda8d214ff4732d686eab64d90 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Sun, 8 Mar 2015 23:21:43 +0100 Subject: [PATCH 262/323] Solving a last few issues after merging with pvj/main --- .../main/java/org/overture/codegen/traces/TraceStmsBuilder.java | 2 +- .../overture/codegen/tests/utils/ExecutableSpecTestHandler.java | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/TraceStmsBuilder.java b/core/codegen/src/main/java/org/overture/codegen/traces/TraceStmsBuilder.java index 87774971fb..c83560c7fb 100644 --- a/core/codegen/src/main/java/org/overture/codegen/traces/TraceStmsBuilder.java +++ b/core/codegen/src/main/java/org/overture/codegen/traces/TraceStmsBuilder.java @@ -59,8 +59,8 @@ import org.overture.codegen.logging.Logger; import org.overture.codegen.trans.TempVarPrefixes; import org.overture.codegen.trans.assistants.TransAssistantCG; +import org.overture.codegen.trans.conv.ObjectDesignatorToExpCG; import org.overture.codegen.trans.iterator.ILanguageIterator; -import org.overture.codegen.trans.uniontypes.ObjectDesignatorToExpCG; public class TraceStmsBuilder extends AnswerAdaptor { diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExecutableSpecTestHandler.java b/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExecutableSpecTestHandler.java index 73965fcf3b..1558ff077f 100644 --- a/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExecutableSpecTestHandler.java +++ b/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExecutableSpecTestHandler.java @@ -53,7 +53,7 @@ public void writeGeneratedCode(File parent, File resultFile, String rootPackage) return; } - injectArgIntoMainClassFile(parent, rootPackage != null ? (rootPackage + "." + JAVA_ENTRY_CALL) : JAVA_ENTRY_CALL); + injectArgIntoMainClassFile(parent, rootPackage != null ? (rootPackage + "." + getJavaEntry()) : getJavaEntry()); if (rootPackage != null) { From 6429ee7d55a7cf223c99aa27f79117d0c3aa0832 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Mon, 9 Mar 2015 06:41:11 +0100 Subject: [PATCH 263/323] Test execution of code generated traces disabled temporarily --- .../java/org/overture/codegen/tests/utils/ComparisonCG.java | 6 ++---- .../java/org/overture/codegen/tests/utils/TraceHandler.java | 6 ++++-- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/ComparisonCG.java b/core/codegen/src/test/java/org/overture/codegen/tests/utils/ComparisonCG.java index 7a074be756..81feafad31 100644 --- a/core/codegen/src/test/java/org/overture/codegen/tests/utils/ComparisonCG.java +++ b/core/codegen/src/test/java/org/overture/codegen/tests/utils/ComparisonCG.java @@ -34,8 +34,6 @@ import org.overture.codegen.runtime.VDMMap; import org.overture.codegen.runtime.VDMSeq; import org.overture.codegen.runtime.VDMSet; -import org.overture.ct.ctruntime.utils.TraceTest; -import org.overture.interpreter.traces.Verdict; import org.overture.interpreter.values.BooleanValue; import org.overture.interpreter.values.CharacterValue; import org.overture.interpreter.values.FieldMap; @@ -65,9 +63,9 @@ public ComparisonCG(File testInputFile) } } - @SuppressWarnings("rawtypes") public boolean compare(Object cgValue, Object vdmResult) { + /* if(!(vdmResult instanceof Value)) { if(vdmResult instanceof List && cgValue instanceof List) @@ -122,7 +120,7 @@ public boolean compare(Object cgValue, Object vdmResult) { return false; } - } + }*/ Value vdmValue = (Value) vdmResult; diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/TraceHandler.java b/core/codegen/src/test/java/org/overture/codegen/tests/utils/TraceHandler.java index 943837cf1f..bcb0066045 100644 --- a/core/codegen/src/test/java/org/overture/codegen/tests/utils/TraceHandler.java +++ b/core/codegen/src/test/java/org/overture/codegen/tests/utils/TraceHandler.java @@ -10,10 +10,10 @@ import javax.xml.xpath.XPathExpressionException; import org.apache.commons.io.FileUtils; +import org.apache.commons.lang.NotImplementedException; import org.junit.Assert; import org.overture.ast.lex.Dialect; import org.overture.codegen.logging.Logger; -import org.overture.codegen.runtime.traces.TestAccumulator; import org.overture.config.Release; import org.overture.ct.ctruntime.TraceRunnerMain; import org.overture.ct.ctruntime.utils.CtHelper; @@ -98,6 +98,8 @@ public ExecutionResult interpretVdm(File intputFile) throws Exception @Override public ExecutionResult runJava(File folder) { + throw new NotImplementedException("Not implemented yet!"); + /* ExecutionResult javaResult = super.runJava(folder); Object executionResult = javaResult.getExecutionResult(); @@ -111,7 +113,7 @@ public ExecutionResult runJava(File folder) else { return new ExecutionResult(javaResult.getStrRepresentation(), javaResult.getExecutionResult().toString()); - } + }*/ } public File computeVdmTraceResult(File specFile) throws IOException, From 414af9ede25c1b3b4a2e353e83c756970d57740e Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Mon, 9 Mar 2015 08:31:33 +0100 Subject: [PATCH 264/323] Add quick profiling to function values too. [Issue: ] --- core/interpreter/pom.xml | 5 ++++ .../interpreter/util/QuickProfiler.java | 29 +++++++++++++++++++ .../interpreter/values/FunctionValue.java | 15 ++++++++-- .../interpreter/values/OperationValue.java | 7 ++--- 4 files changed, 50 insertions(+), 6 deletions(-) create mode 100644 core/interpreter/src/main/java/org/overture/interpreter/util/QuickProfiler.java diff --git a/core/interpreter/pom.xml b/core/interpreter/pom.xml index efe21ca7f8..8d70913c39 100644 --- a/core/interpreter/pom.xml +++ b/core/interpreter/pom.xml @@ -13,6 +13,11 @@ The VDM Interpreter + + commons-io + commons-io + 2.4 + org.overturetool.core ast diff --git a/core/interpreter/src/main/java/org/overture/interpreter/util/QuickProfiler.java b/core/interpreter/src/main/java/org/overture/interpreter/util/QuickProfiler.java new file mode 100644 index 0000000000..6628ba6e7b --- /dev/null +++ b/core/interpreter/src/main/java/org/overture/interpreter/util/QuickProfiler.java @@ -0,0 +1,29 @@ +package org.overture.interpreter.util; + +import java.io.File; +import java.io.IOException; + +import org.apache.commons.io.FileUtils; + +public abstract class QuickProfiler +{ + + private static String PROFILE_PATH = "profile.csv"; + + public static void printDuration(long start, String name) + { + StringBuilder sb = new StringBuilder(); + sb.append(name); + sb.append(", "); + sb.append(System.currentTimeMillis() - start); + sb.append("\n"); + try + { + FileUtils.writeStringToFile(new File(PROFILE_PATH), sb.toString(), true); + } catch (IOException e) + { + e.printStackTrace(); + } + } + +} diff --git a/core/interpreter/src/main/java/org/overture/interpreter/values/FunctionValue.java b/core/interpreter/src/main/java/org/overture/interpreter/values/FunctionValue.java index 144b68789a..65f376c84c 100644 --- a/core/interpreter/src/main/java/org/overture/interpreter/values/FunctionValue.java +++ b/core/interpreter/src/main/java/org/overture/interpreter/values/FunctionValue.java @@ -70,6 +70,7 @@ import org.overture.interpreter.runtime.VdmRuntimeError; import org.overture.interpreter.solver.IConstraintSolver; import org.overture.interpreter.solver.SolverFactory; +import org.overture.interpreter.util.QuickProfiler; import org.overture.typechecker.assistant.pattern.PatternListTC; public class FunctionValue extends Value @@ -271,8 +272,18 @@ public String toString() public Value eval(ILexLocation from, Value arg, Context ctxt) throws AnalysisException { - ValueList args = new ValueList(arg); - return eval(from, args, ctxt, null); + long start = System.currentTimeMillis(); + + try + { + ValueList args = new ValueList(arg); + return eval(from, args, ctxt, null); + } finally + { + QuickProfiler.printDuration(start, this.classdef.getName().getFullName() + + "." + this.name); + } + } public Value eval(ILexLocation from, ValueList argValues, Context ctxt) diff --git a/core/interpreter/src/main/java/org/overture/interpreter/values/OperationValue.java b/core/interpreter/src/main/java/org/overture/interpreter/values/OperationValue.java index 05cb134b20..748842e4bc 100644 --- a/core/interpreter/src/main/java/org/overture/interpreter/values/OperationValue.java +++ b/core/interpreter/src/main/java/org/overture/interpreter/values/OperationValue.java @@ -87,6 +87,7 @@ import org.overture.interpreter.scheduler.ResourceScheduler; import org.overture.interpreter.solver.IConstraintSolver; import org.overture.interpreter.solver.SolverFactory; +import org.overture.interpreter.util.QuickProfiler; import org.overture.parser.config.Properties; public class OperationValue extends Value @@ -281,10 +282,8 @@ public Value eval(ILexLocation from, ValueList argValues, Context ctxt) } } finally { - System.err.println("timecheck," - + this.expldef.getName().getClassName().getFullName() - +"." + this.expldef.getName().getFullName() + "," - + (System.currentTimeMillis() - start)); + QuickProfiler.printDuration(start, this.expldef.getName().getClassName().getFullName() + +"." + this.expldef.getName().getFullName()); } } From 0442f7a8fdd3b8267d79093c89728e9b2b3a8fec Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Mon, 9 Mar 2015 09:20:39 +0100 Subject: [PATCH 265/323] Cache data and write at end. Improve call names. --- .../interpreter/runtime/ClassInterpreter.java | 2 + .../interpreter/util/QuickProfiler.java | 10 +- .../interpreter/values/FunctionValue.java | 451 +++++++++--------- .../interpreter/values/OperationValue.java | 4 +- 4 files changed, 237 insertions(+), 230 deletions(-) diff --git a/core/interpreter/src/main/java/org/overture/interpreter/runtime/ClassInterpreter.java b/core/interpreter/src/main/java/org/overture/interpreter/runtime/ClassInterpreter.java index 113aea716f..1330bcb75f 100644 --- a/core/interpreter/src/main/java/org/overture/interpreter/runtime/ClassInterpreter.java +++ b/core/interpreter/src/main/java/org/overture/interpreter/runtime/ClassInterpreter.java @@ -63,6 +63,7 @@ import org.overture.interpreter.scheduler.SystemClock; import org.overture.interpreter.traces.CallSequence; import org.overture.interpreter.util.ClassListInterpreter; +import org.overture.interpreter.util.QuickProfiler; import org.overture.interpreter.values.BUSValue; import org.overture.interpreter.values.CPUValue; import org.overture.interpreter.values.NameValuePair; @@ -246,6 +247,7 @@ private Value execute(PExp expr, DBGPReader dbgp) throws Exception RuntimeValidator.stop(); + QuickProfiler.print(); return main.getResult(); // Can throw ContextException } diff --git a/core/interpreter/src/main/java/org/overture/interpreter/util/QuickProfiler.java b/core/interpreter/src/main/java/org/overture/interpreter/util/QuickProfiler.java index 6628ba6e7b..311e854714 100644 --- a/core/interpreter/src/main/java/org/overture/interpreter/util/QuickProfiler.java +++ b/core/interpreter/src/main/java/org/overture/interpreter/util/QuickProfiler.java @@ -9,17 +9,23 @@ public abstract class QuickProfiler { private static String PROFILE_PATH = "profile.csv"; + private static StringBuilder sb = new StringBuilder(); public static void printDuration(long start, String name) { - StringBuilder sb = new StringBuilder(); + sb.append("\""); sb.append(name); + sb.append("\""); sb.append(", "); sb.append(System.currentTimeMillis() - start); sb.append("\n"); + } + + public static void print() + { try { - FileUtils.writeStringToFile(new File(PROFILE_PATH), sb.toString(), true); + FileUtils.writeStringToFile(new File(PROFILE_PATH), sb.toString(), false); } catch (IOException e) { e.printStackTrace(); diff --git a/core/interpreter/src/main/java/org/overture/interpreter/values/FunctionValue.java b/core/interpreter/src/main/java/org/overture/interpreter/values/FunctionValue.java index 65f376c84c..b448f56f92 100644 --- a/core/interpreter/src/main/java/org/overture/interpreter/values/FunctionValue.java +++ b/core/interpreter/src/main/java/org/overture/interpreter/values/FunctionValue.java @@ -272,18 +272,8 @@ public String toString() public Value eval(ILexLocation from, Value arg, Context ctxt) throws AnalysisException { - long start = System.currentTimeMillis(); - - try - { - ValueList args = new ValueList(arg); - return eval(from, args, ctxt, null); - } finally - { - QuickProfiler.printDuration(start, this.classdef.getName().getFullName() - + "." + this.name); - } - + ValueList args = new ValueList(arg); + return eval(from, args, ctxt, null); } public Value eval(ILexLocation from, ValueList argValues, Context ctxt) @@ -313,303 +303,312 @@ public void setClass(SClassDefinition classdef) public Value eval(ILexLocation from, ValueList argValues, Context ctxt, Context sctxt) throws AnalysisException { - if (uninstantiated) - { - abort(3033, "Polymorphic function has not been instantiated: " - + name, ctxt); - } - - List paramPatterns = paramPatternList.get(0); - RootContext evalContext = newContext(from, toTitle(), ctxt, sctxt); - - if (typeValues != null) - { - // Add any @T type values, for recursive polymorphic functions - evalContext.putList(typeValues); - } + long start = System.currentTimeMillis(); - if (argValues.size() != paramPatterns.size()) + try { - VdmRuntimeError.abort(type.getLocation(), 4052, "Wrong number of arguments passed to " - + name, ctxt); - } + if (uninstantiated) + { + abort(3033, "Polymorphic function has not been instantiated: " + + name, ctxt); + } - Iterator valIter = argValues.iterator(); - Iterator typeIter = type.getParameters().iterator(); - NameValuePairMap args = new NameValuePairMap(); + List paramPatterns = paramPatternList.get(0); + RootContext evalContext = newContext(from, toTitle(), ctxt, sctxt); - for (PPattern p : paramPatterns) - { - Value pv = valIter.next(); + if (typeValues != null) + { + // Add any @T type values, for recursive polymorphic functions + evalContext.putList(typeValues); + } - if (checkInvariants) // Don't even convert invariant arg values + if (argValues.size() != paramPatterns.size()) { - pv = pv.convertTo(typeIter.next(), ctxt); + VdmRuntimeError.abort(type.getLocation(), 4052, "Wrong number of arguments passed to " + + name, ctxt); } - try + Iterator valIter = argValues.iterator(); + Iterator typeIter = type.getParameters().iterator(); + NameValuePairMap args = new NameValuePairMap(); + + for (PPattern p : paramPatterns) { - for (NameValuePair nvp : ctxt.assistantFactory.createPPatternAssistant().getNamedValues(p, pv, ctxt)) + Value pv = valIter.next(); + + if (checkInvariants) // Don't even convert invariant arg values { - Value v = args.get(nvp.name); + pv = pv.convertTo(typeIter.next(), ctxt); + } - if (v == null) - { - args.put(nvp); - } else - // Names match, so values must also + try + { + for (NameValuePair nvp : ctxt.assistantFactory.createPPatternAssistant().getNamedValues(p, pv, ctxt)) { - if (!v.equals(nvp.value)) + Value v = args.get(nvp.name); + + if (v == null) { - abort(4053, "Parameter patterns do not match arguments", ctxt); + args.put(nvp); + } else + // Names match, so values must also + { + if (!v.equals(nvp.value)) + { + abort(4053, "Parameter patterns do not match arguments", ctxt); + } } } + } catch (PatternMatchException e) + { + abort(e.number, e, ctxt); } - } catch (PatternMatchException e) - { - abort(e.number, e, ctxt); } - } - if (self != null) - { - evalContext.put(new LexNameToken(location.getModule(), "self", location), self); - } + if (self != null) + { + evalContext.put(new LexNameToken(location.getModule(), "self", location), self); + } - evalContext.putAll(args); + evalContext.putAll(args); - if (paramPatternList.size() == 1) - { - if (precondition != null && Settings.prechecks) + if (paramPatternList.size() == 1) { - // Evaluate pre/post in evalContext as it includes the type - // variables, if any. We disable the swapping and time (RT) - // as precondition checks should be "free". - - try - { - evalContext.threadState.setAtomic(true); - evalContext.setPrepost(4055, "Precondition failure: "); - precondition.eval(from, argValues, evalContext); - } finally + if (precondition != null && Settings.prechecks) { - evalContext.setPrepost(0, null); - evalContext.threadState.setAtomic(false); + // Evaluate pre/post in evalContext as it includes the type + // variables, if any. We disable the swapping and time (RT) + // as precondition checks should be "free". + + try + { + evalContext.threadState.setAtomic(true); + evalContext.setPrepost(4055, "Precondition failure: "); + precondition.eval(from, argValues, evalContext); + } finally + { + evalContext.setPrepost(0, null); + evalContext.threadState.setAtomic(false); + } } - } - Long tid = Thread.currentThread().getId(); + Long tid = Thread.currentThread().getId(); - if (isMeasure) - { - if (measuringThreads.contains(tid)) // We are measuring on this thread + if (isMeasure) { - if (!callingThreads.add(tid)) // And we've been here already + if (measuringThreads.contains(tid)) // We are measuring on this thread { - abort(4148, "Measure function is called recursively: " - + name, evalContext); + if (!callingThreads.add(tid)) // And we've been here already + { + abort(4148, "Measure function is called recursively: " + + name, evalContext); + } } } - } - if (measureName != null) - { - if (measure == null) + if (measureName != null) { - measure = evalContext.lookup(measureName).functionValue(ctxt); - - if (typeValues != null) // Function is polymorphic, so measure copies type args + if (measure == null) { - measure = (FunctionValue) measure.clone(); - measure.uninstantiated = false; - measure.typeValues = typeValues; - } + measure = evalContext.lookup(measureName).functionValue(ctxt); - measure.measuringThreads = Collections.synchronizedSet(new HashSet()); - measure.callingThreads = Collections.synchronizedSet(new HashSet()); - measure.isMeasure = true; - } + if (typeValues != null) // Function is polymorphic, so measure copies type args + { + measure = (FunctionValue) measure.clone(); + measure.uninstantiated = false; + measure.typeValues = typeValues; + } - // If this is a curried function, then the measure is called with all of the - // previously applied argument values, in addition to the argValues. + measure.measuringThreads = Collections.synchronizedSet(new HashSet()); + measure.callingThreads = Collections.synchronizedSet(new HashSet()); + measure.isMeasure = true; + } - ValueList measureArgs = null; + // If this is a curried function, then the measure is called with all of the + // previously applied argument values, in addition to the argValues. - if (curriedArgs == null) - { - measureArgs = argValues; - } else - { - measureArgs = new ValueList(); - measureArgs.addAll(curriedArgs); // Previous args - measureArgs.addAll(argValues); // Final args - } + ValueList measureArgs = null; - // We disable the swapping and time (RT) as measure checks should be "free". - Value mv; + if (curriedArgs == null) + { + measureArgs = argValues; + } else + { + measureArgs = new ValueList(); + measureArgs.addAll(curriedArgs); // Previous args + measureArgs.addAll(argValues); // Final args + } - try - { - measure.measuringThreads.add(tid); - evalContext.threadState.setAtomic(true); - mv = measure.eval(measure.location, measureArgs, evalContext); - } finally - { - evalContext.threadState.setAtomic(false); - measure.measuringThreads.remove(tid); - } + // We disable the swapping and time (RT) as measure checks should be "free". + Value mv; - Stack stack = measureValues.get(tid); + try + { + measure.measuringThreads.add(tid); + evalContext.threadState.setAtomic(true); + mv = measure.eval(measure.location, measureArgs, evalContext); + } finally + { + evalContext.threadState.setAtomic(false); + measure.measuringThreads.remove(tid); + } - if (stack == null) - { - stack = new Stack(); - measureValues.put(tid, stack); - } + Stack stack = measureValues.get(tid); - if (!stack.isEmpty()) - { - Value old = stack.peek(); // Previous value + if (stack == null) + { + stack = new Stack(); + measureValues.put(tid, stack); + } - if (old != null && mv.compareTo(old) >= 0) // Not decreasing order + if (!stack.isEmpty()) { - abort(4146, "Measure failure: " + name - + Utils.listToString("(", argValues, ", ", ")") - + ", measure " + measure.name + ", current " - + mv + ", previous " + old, evalContext); + Value old = stack.peek(); // Previous value + + if (old != null && mv.compareTo(old) >= 0) // Not decreasing order + { + abort(4146, "Measure failure: " + + name + + Utils.listToString("(", argValues, ", ", ")") + + ", measure " + measure.name + + ", current " + mv + ", previous " + old, evalContext); + } } + + stack.push(mv); } - stack.push(mv); - } + Value rv = null; - Value rv = null; + if (body == null) + { - if (body == null) - { + IConstraintSolver solver = SolverFactory.getSolver(Settings.dialect); - IConstraintSolver solver = SolverFactory.getSolver(Settings.dialect); + if (solver != null) + { + rv = invokeSolver(ctxt, evalContext, args, solver); - if (solver != null) - { - rv = invokeSolver(ctxt, evalContext, args, solver); + } else + { + abort(4051, "Cannot apply implicit function: " + name, ctxt); + } } else { - abort(4051, "Cannot apply implicit function: " + name, ctxt); + try + { + rv = body.apply(VdmRuntime.getExpressionEvaluator(), evalContext).convertTo(type.getResult(), evalContext); + } catch (AnalysisException e) + { + if (e instanceof ValueException) + { + throw (ValueException) e; + } + e.printStackTrace(); + } } - } else - { - try + if (ctxt.prepost > 0) // Note, caller's context is checked { - rv = body.apply(VdmRuntime.getExpressionEvaluator(), evalContext).convertTo(type.getResult(), evalContext); - } catch (AnalysisException e) - { - if (e instanceof ValueException) + if (!rv.boolValue(ctxt)) { - throw (ValueException) e; + // Note that this calls getLocation to find out where the body + // wants to report its location for this error - this may be an + // errs clause in some circumstances. + + throw new ContextException(ctxt.prepost, ctxt.prepostMsg + + name, body.getLocation(), evalContext); } - e.printStackTrace(); } - } - if (ctxt.prepost > 0) // Note, caller's context is checked - { - if (!rv.boolValue(ctxt)) + if (postcondition != null && Settings.postchecks) { - // Note that this calls getLocation to find out where the body - // wants to report its location for this error - this may be an - // errs clause in some circumstances. + ValueList postArgs = new ValueList(argValues); + postArgs.add(rv); - throw new ContextException(ctxt.prepost, ctxt.prepostMsg - + name, body.getLocation(), evalContext); - } - } + // Evaluate pre/post in evalContext as it includes the type + // variables, if any. We disable the swapping and time (RT) + // as postcondition checks should be "free". - if (postcondition != null && Settings.postchecks) - { - ValueList postArgs = new ValueList(argValues); - postArgs.add(rv); - - // Evaluate pre/post in evalContext as it includes the type - // variables, if any. We disable the swapping and time (RT) - // as postcondition checks should be "free". + try + { + evalContext.threadState.setAtomic(true); + evalContext.setPrepost(4056, "Postcondition failure: "); + postcondition.eval(from, postArgs, evalContext); + } finally + { + evalContext.setPrepost(0, null); + evalContext.threadState.setAtomic(false); + } + } - try + if (measure != null) { - evalContext.threadState.setAtomic(true); - evalContext.setPrepost(4056, "Postcondition failure: "); - postcondition.eval(from, postArgs, evalContext); - } finally + measureValues.get(tid).pop(); + } + + if (isMeasure) { - evalContext.setPrepost(0, null); - evalContext.threadState.setAtomic(false); + callingThreads.remove(tid); } - } - if (measure != null) + return rv; + } else + // This is a curried function { - measureValues.get(tid).pop(); - } + if (type.getResult() instanceof AFunctionType) + { + // If a curried function has a pre/postcondition, then the + // result of a partial application has a pre/post condition + // with its free variables taken from the environment (so + // that parameters passed are fixed in subsequent applies). - if (isMeasure) - { - callingThreads.remove(tid); - } + FunctionValue newpre = null; - return rv; - } else - // This is a curried function - { - if (type.getResult() instanceof AFunctionType) - { - // If a curried function has a pre/postcondition, then the - // result of a partial application has a pre/post condition - // with its free variables taken from the environment (so - // that parameters passed are fixed in subsequent applies). + if (precondition != null) + { + newpre = precondition.curry(evalContext); + } - FunctionValue newpre = null; + FunctionValue newpost = null; - if (precondition != null) - { - newpre = precondition.curry(evalContext); - } - - FunctionValue newpost = null; + if (postcondition != null) + { + newpost = postcondition.curry(evalContext); + } - if (postcondition != null) - { - newpost = postcondition.curry(evalContext); - } + if (freeVariables != null) + { + evalContext.putAll(freeVariables); + } - if (freeVariables != null) - { - evalContext.putAll(freeVariables); - } + // Curried arguments are collected so that we can invoke any measure functions + // once we reach the final apply that does not return a function. - // Curried arguments are collected so that we can invoke any measure functions - // once we reach the final apply that does not return a function. + ValueList argList = new ValueList(); - ValueList argList = new ValueList(); + if (curriedArgs != null) + { + argList.addAll(curriedArgs); + } - if (curriedArgs != null) - { - argList.addAll(curriedArgs); - } + argList.addAll(argValues); - argList.addAll(argValues); + FunctionValue rv = new FunctionValue(location, "curried", (AFunctionType) type.getResult(), paramPatternList.subList(1, paramPatternList.size()), body, newpre, newpost, evalContext, false, argList, measureName, measureValues, result); - FunctionValue rv = new FunctionValue(location, "curried", (AFunctionType) type.getResult(), paramPatternList.subList(1, paramPatternList.size()), body, newpre, newpost, evalContext, false, argList, measureName, measureValues, result); + rv.setSelf(self); + rv.typeValues = typeValues; - rv.setSelf(self); - rv.typeValues = typeValues; + return rv; + } - return rv; + VdmRuntimeError.abort(type.getLocation(), 4057, "Curried function return type is not a function", ctxt); + return null; } - - VdmRuntimeError.abort(type.getLocation(), 4057, "Curried function return type is not a function", ctxt); - return null; + } finally + { + QuickProfiler.printDuration(start,this.location.getModule()+"."+this.toTitle()); } } diff --git a/core/interpreter/src/main/java/org/overture/interpreter/values/OperationValue.java b/core/interpreter/src/main/java/org/overture/interpreter/values/OperationValue.java index 748842e4bc..b56d73cfd2 100644 --- a/core/interpreter/src/main/java/org/overture/interpreter/values/OperationValue.java +++ b/core/interpreter/src/main/java/org/overture/interpreter/values/OperationValue.java @@ -282,8 +282,8 @@ public Value eval(ILexLocation from, ValueList argValues, Context ctxt) } } finally { - QuickProfiler.printDuration(start, this.expldef.getName().getClassName().getFullName() - +"." + this.expldef.getName().getFullName()); + QuickProfiler.printDuration(start, this.name.getModule() + "." + + this.toTitle()); } } From 331077bbbd4732a1ef3b6f0089520714efe27adb Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Mon, 9 Mar 2015 13:06:19 +0100 Subject: [PATCH 266/323] Restructure codegen folders. [Issue: ] --- core/{ => codegen}/cgisa/pom.xml | 0 .../overturetool/cgisa/ExtIrGenerator.java | 0 .../org/overturetool/cgisa/IsaChecks.java | 0 .../org/overturetool/cgisa/IsaCodeGen.java | 0 .../cgisa/IsaTemplateManager.java | 0 .../overturetool/cgisa/IsaTranslations.java | 0 .../cgisa/checkers/IsCharTypeVisitor.java | 0 .../cgisa/checkers/IsMethodTypeVisitor.java | 0 .../checkers/IsSeqOfCharTypeVisitor.java | 0 .../cgisa/ir/ExtIrClassDeclStatus.java | 0 .../cgisa/transformations/ExtendClass.java | 0 .../cgisa/transformations/GroupMutRecs.java | 0 .../transformations/SortDependencies.java | 0 .../IsaTemplates/Declarations/Class.vm | 0 .../IsaTemplates/Declarations/ExtClass.vm | 0 .../IsaTemplates/Declarations/Field.vm | 0 .../IsaTemplates/Declarations/Function.vm | 0 .../IsaTemplates/Declarations/MutRec.vm | 0 .../IsaTemplates/Expressions/Apply.vm | 0 .../Expressions/Binary/Numeric/Plus.vm | 0 .../IsaTemplates/Expressions/CharLiteral.vm | 0 .../IsaTemplates/Expressions/IntLiteral.vm | 0 .../IsaTemplates/Expressions/Seq/Enum.vm | 0 .../IsaTemplates/Expressions/Variable.vm | 0 .../IsaTemplates/LocalDecls/FormalParam.vm | 0 .../IsaTemplates/Pattern/Identifier.vm | 0 .../IsaTemplates/Types/Basic/Char.vm | 0 .../IsaTemplates/Types/Basic/Integer.vm | 0 .../resources/IsaTemplates/Types/Basic/Nat.vm | 0 .../IsaTemplates/Types/Basic/Nat1.vm | 0 .../cgisa/src/main/resources/isacg.ast | 0 .../src/main/resources/isacg.ast.tostring | 0 .../java/org/overturetool/cgisa/AdHoc.java | 0 .../overturetool/cgisa/CgIsaParamTest.java | 0 .../overturetool/cgisa/CgIsaTestResult.java | 0 .../micro/Functions/FuncApply1Param.vdmpp | 0 .../Functions/FuncApply1Param.vdmpp.result | 0 .../micro/Functions/FuncApply3Params.vdmpp | 0 .../Functions/FuncApply3Params.vdmpp.result | 0 .../micro/Functions/FuncApplyNoParam.vdmpp | 0 .../Functions/FuncApplyNoParam.vdmpp.result | 0 .../micro/Functions/FuncDecl1Param.vdmpp | 0 .../Functions/FuncDecl1Param.vdmpp.result | 0 .../micro/Functions/FuncDecl2Params.vdmpp | 0 .../Functions/FuncDecl2Params.vdmpp.result | 0 .../micro/Functions/FuncDeclNoParam.vdmpp | 0 .../Functions/FuncDeclNoParam.vdmpp.result | 0 .../micro/Functions/FuncDepSimple.vdmpp | 0 .../Functions/FuncDepSimple.vdmpp.result | 0 .../test/resources/micro/Values/IntExp.vdmpp | 0 .../micro/Values/IntExp.vdmpp.result | 0 .../resources/micro/Values/IntExpVarExp.vdmpp | 0 .../micro/Values/IntExpVarExp.vdmpp.result | 0 .../resources/micro/Values/SeqEnumApply.vdmpp | 0 .../micro/Values/SeqEnumApply.vdmpp.result | 0 .../resources/micro/Values/StringApply.vdmpp | 0 .../micro/Values/StringApply.vdmpp.result | 0 .../cgisa/src/test/resources/test.vdmpp | 0 .../codegen-maven-plugin}/pom.xml | 0 .../maven/astcreator/AstCreatorBaseMojo.java | 0 .../maven/astcreator/GenerateJavaSources.java | 0 .../maven/astcreator/VdmppNameFilter.java | 0 core/{ => codegen}/codegen-runtime/README.md | 0 core/{ => codegen}/codegen-runtime/pom.xml | 0 .../overture/codegen/runtime/EvaluatePP.java | 0 .../java/org/overture/codegen/runtime/IO.java | 0 .../org/overture/codegen/runtime/MATH.java | 0 .../org/overture/codegen/runtime/MapUtil.java | 0 .../org/overture/codegen/runtime/Maplet.java | 0 .../org/overture/codegen/runtime/Record.java | 0 .../overture/codegen/runtime/Sentinel.java | 0 .../org/overture/codegen/runtime/SeqUtil.java | 0 .../org/overture/codegen/runtime/SetUtil.java | 0 .../runtime/StaticOperationsCounters.java | 0 .../codegen/runtime/StaticSentinel.java | 0 .../org/overture/codegen/runtime/Token.java | 0 .../org/overture/codegen/runtime/Tuple.java | 0 .../org/overture/codegen/runtime/Utils.java | 0 .../org/overture/codegen/runtime/VDMMap.java | 0 .../org/overture/codegen/runtime/VDMSeq.java | 0 .../org/overture/codegen/runtime/VDMSet.java | 0 .../overture/codegen/runtime/VDMThread.java | 0 .../org/overture/codegen/runtime/VDMUtil.java | 0 .../overture/codegen/runtime/ValueType.java | 0 .../codegen-runtime/src/test/java/IOTest.java | 0 core/codegen/{ => javagen}/pom.xml | 0 .../analysis/vdm/AbstractAnalysis.java | 0 .../codegen/analysis/vdm/DefinitionInfo.java | 0 .../vdm/IdDesignatorOccurencesCollector.java | 0 .../analysis/vdm/IdOccurencesCollector.java | 0 .../vdm/IdStateDesignatorDefCollector.java | 0 .../vdm/JavaIdentifierNormaliser.java | 0 .../codegen/analysis/vdm/NameCollector.java | 0 .../codegen/analysis/vdm/QuoteAnalysis.java | 0 .../codegen/analysis/vdm/RenameAnalysis.java | 0 .../codegen/analysis/vdm/Renaming.java | 0 .../analysis/vdm/UnreachableStmRemover.java | 0 .../codegen/analysis/vdm/UtilAnalysis.java | 0 .../analysis/vdm/VarOccurencesCollector.java | 0 .../codegen/analysis/vdm/VarRenamer.java | 0 .../vdm/VarShadowingRenameCollector.java | 0 .../codegen/analysis/vdm/VdmAnalysis.java | 0 .../violations/GeneratedVarComparison.java | 0 .../violations/InvalidNamesResult.java | 0 .../violations/ModelingViolationAnalysis.java | 0 .../violations/NameViolationAnalysis.java | 0 .../analysis/violations/NamingComparison.java | 0 .../violations/ReservedWordsComparison.java | 0 .../violations/TypenameComparison.java | 0 .../UnsupportedModelingException.java | 0 .../analysis/violations/VdmAstAnalysis.java | 0 .../analysis/violations/Violation.java | 0 .../violations/ViolationAnalysis.java | 0 .../codegen/assistant/AssistantBase.java | 0 .../codegen/assistant/AssistantManager.java | 0 .../codegen/assistant/BindAssistantCG.java | 0 .../assistant/CollectionTypeStrategy.java | 0 .../codegen/assistant/DeclAssistantCG.java | 0 .../codegen/assistant/DeclStrategy.java | 0 .../codegen/assistant/ExpAssistantCG.java | 0 .../assistant/LocationAssistantCG.java | 0 .../codegen/assistant/StmAssistantCG.java | 0 .../codegen/assistant/TypeAssistantCG.java | 0 .../org/overture/codegen/ir/CodeGenBase.java | 0 .../org/overture/codegen/ir/IRAnalysis.java | 0 .../codegen/ir/IRClassDeclStatus.java | 0 .../org/overture/codegen/ir/IRConstants.java | 0 .../org/overture/codegen/ir/IRExpStatus.java | 0 .../overture/codegen/ir/IRGeneratedTag.java | 0 .../org/overture/codegen/ir/IRGenerator.java | 0 .../java/org/overture/codegen/ir/IRInfo.java | 0 .../codegen/ir/IRNamedTypeInvariantTag.java | 0 .../overture/codegen/ir/IROperatorInfo.java | 0 .../overture/codegen/ir/IROperatorLookup.java | 0 .../org/overture/codegen/ir/IRSettings.java | 0 .../org/overture/codegen/ir/IRStatus.java | 0 .../org/overture/codegen/ir/ITempVarGen.java | 0 .../org/overture/codegen/ir/IrNodeInfo.java | 0 .../org/overture/codegen/ir/SourceNode.java | 0 .../overture/codegen/ir/TempVarNameGen.java | 0 .../org/overture/codegen/ir/VdmNodeInfo.java | 0 .../codegen/logging/DefaultLogger.java | 0 .../org/overture/codegen/logging/ILogger.java | 0 .../org/overture/codegen/logging/Logger.java | 0 .../codegen/merging/MergeContext.java | 0 .../codegen/merging/MergeVisitor.java | 0 .../codegen/merging/TemplateCallable.java | 0 .../codegen/merging/TemplateManager.java | 0 .../codegen/merging/TemplateStructure.java | 0 .../EnsureLocalObjDesignatorAnalysis.java | 0 .../traces/ICallStmToStringMethodBuilder.java | 0 .../traces/IdentifierPatternCollector.java | 0 .../traces/JavaCallStmToStringBuilder.java | 0 .../codegen/traces/StoreAssistant.java | 0 .../codegen/traces/TermVisitorCG.java | 0 .../traces/TraceCoreDeclVisitorCG.java | 0 .../codegen/traces/TraceDeclVisitorCG.java | 0 .../codegen/traces/TraceLetBeStStrategy.java | 0 .../overture/codegen/traces/TraceNames.java | 0 .../codegen/traces/TraceNodeData.java | 0 .../codegen/traces/TraceStmsBuilder.java | 0 .../traces/TraceSupportedAnalysis.java | 0 .../codegen/traces/TracesTransformation.java | 0 .../codegen/traces/VarExpCasting.java | 0 .../trans/AbstractIterationStrategy.java | 0 .../trans/AssignStmTransformation.java | 0 .../trans/CallObjStmTransformation.java | 0 .../codegen/trans/DeclarationTag.java | 0 .../codegen/trans/IIterationStrategy.java | 0 .../codegen/trans/IPostCheckCreator.java | 0 .../codegen/trans/IsExpTransformation.java | 0 .../trans/PostCheckTransformation.java | 0 .../codegen/trans/PreCheckTransformation.java | 0 .../codegen/trans/PrePostTransformation.java | 0 .../trans/SeqConversionTransformation.java | 0 .../codegen/trans/TempVarPrefixes.java | 0 .../codegen/trans/TransformationVisitor.java | 0 .../BaseTransformationAssistant.java | 0 .../trans/assistants/TransAssistantCG.java | 0 .../codegen/trans/comp/CompStrategy.java | 0 .../trans/comp/ComplexCompStrategy.java | 0 .../codegen/trans/comp/MapCompStrategy.java | 0 .../codegen/trans/comp/SeqCompStrategy.java | 0 .../codegen/trans/comp/SetCompStrategy.java | 0 .../conc/InstanceVarPPEvalTransformation.java | 0 .../conc/MainClassConcTransformation.java | 0 .../trans/conc/MutexDeclTransformation.java | 0 .../trans/conc/SentinelTransformation.java | 0 .../trans/conv/ObjectDesignatorToExpCG.java | 0 .../trans/conv/StateDesignatorToExpCG.java | 0 .../funcvalues/FunctionValueAssistant.java | 0 .../FunctionValueTransformation.java | 0 .../iterator/AbstractLanguageIterator.java | 0 .../trans/iterator/ILanguageIterator.java | 0 .../trans/iterator/JavaLanguageIterator.java | 0 .../codegen/trans/let/LetBeStStrategy.java | 0 .../trans/letexps/FuncTransformation.java | 0 .../trans/letexps/IfExpTransformation.java | 0 .../codegen/trans/patterns/DeclBlockPair.java | 0 .../trans/patterns/MismatchHandling.java | 0 .../trans/patterns/PatternBlockData.java | 0 .../codegen/trans/patterns/PatternInfo.java | 0 .../trans/patterns/PatternMatchConfig.java | 0 .../trans/patterns/PatternTransformation.java | 0 .../trans/quantifier/Exists1CounterData.java | 0 .../quantifier/Exists1QuantifierStrategy.java | 0 .../trans/quantifier/OrdinaryQuantifier.java | 0 .../OrdinaryQuantifierStrategy.java | 0 .../quantifier/QuantifierBaseStrategy.java | 0 .../uniontypes/UnionTypeTransformation.java | 0 .../codegen/utils/AnalysisExceptionCG.java | 0 .../codegen/utils/GeneralCodeGenUtils.java | 0 .../overture/codegen/utils/GeneralUtils.java | 0 .../org/overture/codegen/utils/Generated.java | 0 .../overture/codegen/utils/GeneratedData.java | 0 .../codegen/utils/GeneratedModule.java | 0 .../codegen/utils/LexNameTokenWrapper.java | 0 .../vdm2java/IJavaCodeGenConstants.java | 0 .../codegen/vdm2java/JavaClassCreator.java | 0 .../vdm2java/JavaClassCreatorBase.java | 0 .../vdm2java/JavaClassToStringTrans.java | 0 .../codegen/vdm2java/JavaCodeGen.java | 0 .../codegen/vdm2java/JavaCodeGenMain.java | 0 .../codegen/vdm2java/JavaCodeGenUtil.java | 0 .../overture/codegen/vdm2java/JavaFormat.java | 0 .../codegen/vdm2java/JavaFormatAssistant.java | 0 .../codegen/vdm2java/JavaMainTag.java | 0 .../vdm2java/JavaPostCheckCreator.java | 0 .../codegen/vdm2java/JavaPrecedence.java | 0 .../vdm2java/JavaQuoteValueCreator.java | 0 .../codegen/vdm2java/JavaRecordCreator.java | 0 .../codegen/vdm2java/JavaSettings.java | 0 .../codegen/vdm2java/JavaTransSeries.java | 0 .../codegen/vdm2java/JavaValueSemantics.java | 0 .../vdm2java/JavaValueSemanticsTag.java | 0 .../vdm2java/TemplateCallableManager.java | 0 .../codegen/visitor/AbstractVisitorCG.java | 0 .../codegen/visitor/BindVisitorCG.java | 0 .../overture/codegen/visitor/CGVisitor.java | 0 .../CGVisitorRecursiveTypeHandler.java | 0 .../codegen/visitor/ClassVisitorCG.java | 0 .../codegen/visitor/DeclVisitorCG.java | 0 .../codegen/visitor/ExpVisitorCG.java | 0 .../codegen/visitor/ModifierVisitorCG.java | 0 .../visitor/MultipleBindVisitorCG.java | 0 .../visitor/ObjectDesignatorVisitorCG.java | 0 .../codegen/visitor/PatternVisitorCG.java | 0 .../visitor/StateDesignatorVisitorCG.java | 0 .../codegen/visitor/StmVisitorCG.java | 0 .../codegen/visitor/TypeVisitorCG.java | 0 .../codegen/visitor/VisitorManager.java | 0 .../JavaTemplates/Declarations/CatchClause.vm | 0 .../JavaTemplates/Declarations/Class.vm | 114 +++++++++--------- .../JavaTemplates/Declarations/Field.vm | 0 .../JavaTemplates/Declarations/Interface.vm | 0 .../JavaTemplates/Declarations/LocalVar.vm | 0 .../JavaTemplates/Declarations/Method.vm | 0 .../JavaTemplates/Declarations/Record.vm | 0 .../JavaTemplates/Declarations/Thread.vm | 0 .../JavaTemplates/Declarations/Type.vm | 0 .../Expressions/AnonymousClass.vm | 0 .../JavaTemplates/Expressions/Apply.vm | 0 .../Expressions/Binary/AddrEquals.vm | 0 .../Expressions/Binary/AddrNotEquals.vm | 0 .../Expressions/Binary/Bool/And.vm | 0 .../Expressions/Binary/Bool/Or.vm | 0 .../Expressions/Binary/Bool/Xor.vm | 0 .../Expressions/Binary/DomResBy.vm | 0 .../Expressions/Binary/DomResTo.vm | 0 .../Expressions/Binary/Equals.vm | 0 .../JavaTemplates/Expressions/Binary/InSet.vm | 0 .../Expressions/Binary/MapOverride.vm | 0 .../Expressions/Binary/MapUnion.vm | 0 .../Expressions/Binary/NotEquals.vm | 0 .../Expressions/Binary/Numeric/Divide.vm | 0 .../Expressions/Binary/Numeric/Greater.vm | 0 .../Binary/Numeric/GreaterEqual.vm | 0 .../Expressions/Binary/Numeric/IntDiv.vm | 0 .../Expressions/Binary/Numeric/Less.vm | 0 .../Expressions/Binary/Numeric/LessEqual.vm | 0 .../Expressions/Binary/Numeric/Minus.vm | 0 .../Expressions/Binary/Numeric/Mod.vm | 0 .../Expressions/Binary/Numeric/Mul.vm | 0 .../Expressions/Binary/Numeric/Plus.vm | 0 .../Expressions/Binary/Numeric/Power.vm | 0 .../Expressions/Binary/Numeric/Rem.vm | 0 .../Expressions/Binary/RngResBy.vm | 0 .../Expressions/Binary/RngResTo.vm | 0 .../Expressions/Binary/SeqConcat.vm | 0 .../Expressions/Binary/SeqModification.vm | 0 .../Expressions/Binary/SetDifference.vm | 0 .../Expressions/Binary/SetIntersect.vm | 0 .../Expressions/Binary/SetProperSubset.vm | 0 .../Expressions/Binary/SetSubset.vm | 0 .../Expressions/Binary/SetUnion.vm | 0 .../JavaTemplates/Expressions/BoolLiteral.vm | 0 .../JavaTemplates/Expressions/CharLiteral.vm | 0 .../Expressions/ExplicitVariable.vm | 0 .../JavaTemplates/Expressions/External.vm | 0 .../JavaTemplates/Expressions/Field.vm | 0 .../JavaTemplates/Expressions/FieldNumber.vm | 0 .../JavaTemplates/Expressions/HistoryExp.vm | 0 .../JavaTemplates/Expressions/InstanceOf.vm | 0 .../JavaTemplates/Expressions/IntLiteral.vm | 0 .../JavaTemplates/Expressions/Is/Bool.vm | 0 .../JavaTemplates/Expressions/Is/Char.vm | 0 .../JavaTemplates/Expressions/Is/General.vm | 0 .../JavaTemplates/Expressions/Is/Int.vm | 0 .../JavaTemplates/Expressions/Is/Nat.vm | 0 .../JavaTemplates/Expressions/Is/Nat1.vm | 0 .../JavaTemplates/Expressions/Is/Rat.vm | 0 .../JavaTemplates/Expressions/Is/Real.vm | 0 .../JavaTemplates/Expressions/Is/Token.vm | 0 .../JavaTemplates/Expressions/Is/Tuple.vm | 0 .../JavaTemplates/Expressions/Map/Enum.vm | 0 .../JavaTemplates/Expressions/MapSeqGet.vm | 0 .../JavaTemplates/Expressions/Maplet.vm | 0 .../Expressions/MethodInstantiation.vm | 0 .../JavaTemplates/Expressions/MkBasic.vm | 0 .../JavaTemplates/Expressions/New.vm | 0 .../Expressions/NotImplemented.vm | 0 .../JavaTemplates/Expressions/Null.vm | 0 .../JavaTemplates/Expressions/QuoteLiteral.vm | 0 .../JavaTemplates/Expressions/RealLiteral.vm | 0 .../RuntimeError/LetBeStNoBinding.vm | 0 .../Expressions/RuntimeError/MissingMember.vm | 0 .../Expressions/RuntimeError/PatternMatch.vm | 0 .../Expressions/RuntimeError/PreCond.vm | 0 .../JavaTemplates/Expressions/Self.vm | 0 .../JavaTemplates/Expressions/Seq/Enum.vm | 0 .../JavaTemplates/Expressions/Set/Enum.vm | 0 .../JavaTemplates/Expressions/Set/Range.vm | 0 .../Expressions/StringLiteral.vm | 0 .../JavaTemplates/Expressions/SubSeq.vm | 0 .../Expressions/SuperVariable.vm | 0 .../JavaTemplates/Expressions/TernaryIf.vm | 0 .../JavaTemplates/Expressions/ThreadId.vm | 0 .../JavaTemplates/Expressions/Tuple.vm | 0 .../Expressions/TupleCompatibility.vm | 0 .../JavaTemplates/Expressions/TupleSize.vm | 0 .../JavaTemplates/Expressions/TypeArg.vm | 0 .../JavaTemplates/Expressions/Unary/Abs.vm | 0 .../JavaTemplates/Expressions/Unary/Cast.vm | 0 .../Expressions/Unary/DistConcat.vm | 0 .../Expressions/Unary/DistInter.vm | 0 .../Expressions/Unary/DistMerge.vm | 0 .../Expressions/Unary/DistUnion.vm | 0 .../JavaTemplates/Expressions/Unary/Elems.vm | 0 .../JavaTemplates/Expressions/Unary/Floor.vm | 0 .../JavaTemplates/Expressions/Unary/Head.vm | 0 .../Expressions/Unary/Indices.vm | 0 .../Expressions/Unary/Isolation.vm | 0 .../Expressions/Unary/Len_Card.vm | 0 .../JavaTemplates/Expressions/Unary/MapDom.vm | 0 .../Expressions/Unary/MapInverse.vm | 0 .../Expressions/Unary/MapRange.vm | 0 .../JavaTemplates/Expressions/Unary/Minus.vm | 0 .../JavaTemplates/Expressions/Unary/Not.vm | 0 .../JavaTemplates/Expressions/Unary/Plus.vm | 0 .../Expressions/Unary/PowerSet.vm | 0 .../Expressions/Unary/Reverse.vm | 0 .../Expressions/Unary/SeqToString.vm | 0 .../Expressions/Unary/StringToSeq.vm | 0 .../JavaTemplates/Expressions/Unary/Tail.vm | 0 .../JavaTemplates/Expressions/Undefined.vm | 0 .../JavaTemplates/Expressions/Variable.vm | 0 .../JavaTemplates/LocalDecls/FormalParam.vm | 0 .../JavaTemplates/Pattern/Identifier.vm | 0 .../JavaTemplates/Statements/Assignment.vm | 0 .../JavaTemplates/Statements/Block.vm | 0 .../JavaTemplates/Statements/Break.vm | 0 .../JavaTemplates/Statements/Call.vm | 0 .../JavaTemplates/Statements/CallObject.vm | 0 .../JavaTemplates/Statements/CallObjectExp.vm | 0 .../JavaTemplates/Statements/Continue.vm | 0 .../JavaTemplates/Statements/Decrement.vm | 0 .../JavaTemplates/Statements/Error.vm | 0 .../JavaTemplates/Statements/ForAll.vm | 0 .../JavaTemplates/Statements/ForIndex.vm | 0 .../JavaTemplates/Statements/ForLoop.vm | 0 .../resources/JavaTemplates/Statements/If.vm | 0 .../JavaTemplates/Statements/Increment.vm | 0 .../Statements/LocalAssignment.vm | 0 .../Statements/LocalPatternAssignment.vm | 0 .../JavaTemplates/Statements/MapSeqUpdate.vm | 0 .../Statements/NotImplemented.vm | 0 .../JavaTemplates/Statements/RaiseError.vm | 0 .../JavaTemplates/Statements/Return.vm | 0 .../JavaTemplates/Statements/Skip.vm | 0 .../JavaTemplates/Statements/Start.vm | 0 .../JavaTemplates/Statements/Startlist.vm | 0 .../JavaTemplates/Statements/SuperCall.vm | 0 .../JavaTemplates/Statements/Throw.vm | 0 .../resources/JavaTemplates/Statements/Try.vm | 0 .../JavaTemplates/Statements/While.vm | 0 .../JavaTemplates/Types/Basic/Bool.vm | 0 .../JavaTemplates/Types/Basic/Char.vm | 0 .../JavaTemplates/Types/Basic/Integer.vm | 0 .../JavaTemplates/Types/Basic/Nat.vm | 0 .../JavaTemplates/Types/Basic/Nat1.vm | 0 .../JavaTemplates/Types/Basic/Rat.vm | 0 .../JavaTemplates/Types/Basic/Real.vm | 0 .../JavaTemplates/Types/Basic/Token.vm | 0 .../JavaTemplates/Types/BasicWrappers/Bool.vm | 0 .../JavaTemplates/Types/BasicWrappers/Char.vm | 0 .../Types/BasicWrappers/Integer.vm | 0 .../JavaTemplates/Types/BasicWrappers/Nat.vm | 0 .../JavaTemplates/Types/BasicWrappers/Nat1.vm | 0 .../JavaTemplates/Types/BasicWrappers/Rat.vm | 0 .../JavaTemplates/Types/BasicWrappers/Real.vm | 0 .../resources/JavaTemplates/Types/Class.vm | 0 .../resources/JavaTemplates/Types/External.vm | 0 .../JavaTemplates/Types/Interface.vm | 0 .../resources/JavaTemplates/Types/Map/Map.vm | 0 .../resources/JavaTemplates/Types/Method.vm | 0 .../resources/JavaTemplates/Types/Null.vm | 0 .../resources/JavaTemplates/Types/Object.vm | 0 .../resources/JavaTemplates/Types/Quote.vm | 0 .../resources/JavaTemplates/Types/Record.vm | 0 .../resources/JavaTemplates/Types/Seq/Seq.vm | 0 .../resources/JavaTemplates/Types/Set/Set.vm | 0 .../resources/JavaTemplates/Types/String.vm | 0 .../resources/JavaTemplates/Types/Template.vm | 0 .../resources/JavaTemplates/Types/Tuple.vm | 0 .../resources/JavaTemplates/Types/Union.vm | 0 .../resources/JavaTemplates/Types/Unknown.vm | 0 .../resources/JavaTemplates/Types/Void.vm | 0 .../{ => javagen}/src/main/resources/cg.astv2 | 0 .../src/main/resources/cg.astv2.tostring | 0 .../org/overture/codegen/tests/BindTest.java | 0 .../tests/ClassesToSkipParsingTest.java | 0 .../codegen/tests/ClassicSpecTest.java | 0 .../codegen/tests/ClassicSpecTestCase.java | 0 .../codegen/tests/CodeGenBaseTestCase.java | 0 .../codegen/tests/ComplexExpressionTest.java | 0 .../tests/ConcurrencyClassicSpecTestCase.java | 0 .../tests/ConcurrencyClassicSpecTests.java | 0 .../codegen/tests/ConcurrencyTestCase.java | 0 .../codegen/tests/ConcurrencyTests.java | 0 .../codegen/tests/ConfiguredCloningTest.java | 0 .../tests/ConfiguredCloningTestCase.java | 0 .../tests/ConfiguredStringGenerationTest.java | 0 .../ConfiguredStringGenerationTestCase.java | 0 .../codegen/tests/ExpressionTest.java | 0 .../codegen/tests/ExpressionTestCase.java | 0 .../codegen/tests/FunctionValueTest.java | 0 .../org/overture/codegen/tests/IRTest.java | 0 .../codegen/tests/NameNormalising.java | 0 .../overture/codegen/tests/PackageTest.java | 0 .../codegen/tests/PackageTestCase.java | 0 .../overture/codegen/tests/PatternTest.java | 0 .../overture/codegen/tests/PrePostTest.java | 0 .../codegen/tests/PrePostTestCase.java | 0 .../org/overture/codegen/tests/RtTest.java | 0 .../overture/codegen/tests/RtTestCase.java | 0 .../codegen/tests/SpecificationTest.java | 0 .../codegen/tests/SpecificationTestCase.java | 0 .../org/overture/codegen/tests/TestFlags.java | 0 .../codegen/tests/TracesExpansionTest.java | 0 .../tests/TracesExpansionTestCase.java | 0 .../codegen/tests/TracesVerdictTest.java | 0 .../codegen/tests/TracesVerdictTestCase.java | 0 .../overture/codegen/tests/UnionTypeTest.java | 0 .../org/overture/codegen/tests/UtilsTest.java | 0 .../codegen/tests/VarShadowingTest.java | 0 .../codegen/tests/VarShadowingTestCase.java | 0 .../codegen/tests/utils/ComparisonCG.java | 0 .../codegen/tests/utils/CompileTests.java | 0 .../tests/utils/EntryBasedTestHandler.java | 0 .../utils/ExecutableSpecTestHandler.java | 0 .../tests/utils/ExecutableTestHandler.java | 0 .../codegen/tests/utils/ExecutionResult.java | 0 .../tests/utils/ExpressionTestHandler.java | 0 .../codegen/tests/utils/FileComparator.java | 0 .../tests/utils/JavaCommandLineCompiler.java | 0 .../codegen/tests/utils/JavaExecution.java | 0 .../codegen/tests/utils/JavaToolsUtils.java | 0 .../utils/NonExecutableSpecTestHandler.java | 0 .../codegen/tests/utils/TestHandler.java | 0 .../codegen/tests/utils/TestUtils.java | 0 .../codegen/tests/utils/TraceHandler.java | 0 .../Exists1QuantifierWithTuplePattern | 0 .../Exists1QuantifierWithTuplePattern.result | 0 .../ExistsQuantifierWithTuplePattern | 0 .../ExistsQuantifierWithTuplePattern.result | 0 .../ForAllQuantifierWithTuplePattern | 0 .../ForAllQuantifierWithTuplePattern.result | 0 .../LetBeStExpMultipleBindWithTuplePattern | 0 ...BeStExpMultipleBindWithTuplePattern.result | 0 .../bind_specs/LetBeStExpWithTuplePattern | 0 .../LetBeStExpWithTuplePattern.result | 0 .../bind_specs/LetBeStStmWithRecPattern | 0 .../LetBeStStmWithRecPattern.result | 0 .../bind_specs/MapCompWithTuplePattern | 0 .../bind_specs/MapCompWithTuplePattern.result | 0 .../bind_specs/SeqCompWithTuplePattern | 0 .../bind_specs/SeqCompWithTuplePattern.result | 0 .../SetCompMultipleSetBindWithTuplePatterns | 0 ...ompMultipleSetBindWithTuplePatterns.result | 0 .../bind_specs/SetCompWithIntPattern | 0 .../bind_specs/SetCompWithIntPattern.result | 0 .../bind_specs/SetCompWithTuplePattern | 0 .../bind_specs/SetCompWithTuplePattern.result | 0 .../test/resources/classic_specs/AlarmTraces | 0 .../classic_specs/AlarmTraces.result | 0 .../resources/classic_specs/CashDispenserPP | 0 .../classic_specs/CashDispenserPP.result | 0 .../test/resources/cloning_specs/AlarmTraces | 0 .../cloning_specs/AlarmTraces.result | 0 .../resources/cloning_specs/CashDispenserPP | 0 .../cloning_specs/CashDispenserPP.result | 0 .../test/resources/cloning_specs/TupleUsage | 0 .../resources/cloning_specs/TupleUsage.result | 0 .../complex_expressions/AbsNumberDereference | 0 .../AbsNumberDereference.result | 0 .../AndExpAndChainInForAll | 0 .../AndExpAndChainInForAll.result | 0 .../resources/complex_expressions/AndExpChain | 0 .../complex_expressions/AndExpChain.result | 0 .../complex_expressions/AndExpEvalOrder | 0 .../AndExpEvalOrder.result | 0 .../complex_expressions/AndExpForAllExps | 0 .../AndExpForAllExps.result | 0 .../ApplyObjectDesignatorClone | 0 .../ApplyObjectDesignatorClone.result | 0 .../ApplyObjectDesignatorField | 0 .../ApplyObjectDesignatorField.result | 0 .../ApplyObjectDesignatorMapLookup | 0 .../ApplyObjectDesignatorMapLookup.result | 0 .../ApplyObjectDesignatorMapType | 0 .../ApplyObjectDesignatorMapType.result | 0 .../ApplyObjectDesignatorNoClone | 0 .../ApplyObjectDesignatorNoClone.result | 0 .../ApplyObjectDesignatorWithRecFieldObj1 | 0 ...plyObjectDesignatorWithRecFieldObj1.result | 0 .../ApplyObjectDesignatorWithRecFieldObj2 | 0 ...plyObjectDesignatorWithRecFieldObj2.result | 0 .../resources/complex_expressions/AtomicStm | 0 .../complex_expressions/AtomicStm.result | 0 .../complex_expressions/BlockStmScoping | 0 .../BlockStmScoping.result | 0 .../complex_expressions/CallStmInherited | 0 .../CallStmInherited.result | 0 .../complex_expressions/DeadCodeNestedBlocks | 0 .../DeadCodeNestedBlocks.result | 0 .../complex_expressions/DeflattenBlockStm | 0 .../DeflattenBlockStm.result | 0 .../complex_expressions/DeflattenLetBeStStm | 0 .../DeflattenLetBeStStm.result | 0 .../complex_expressions/DeflattenLetDefExp | 0 .../DeflattenLetDefExp.result | 0 .../complex_expressions/ElseIfWithSetComp | 0 .../ElseIfWithSetComp.result | 0 .../complex_expressions/EmptyRecords | 0 .../complex_expressions/EmptyRecords.result | 0 .../resources/complex_expressions/EqualsDef | 0 .../complex_expressions/EqualsDef.result | 0 .../complex_expressions/EqualsOptionalType | 0 .../EqualsOptionalType.result | 0 .../Exist1ExpTransformedCond | 0 .../Exist1ExpTransformedCond.result | 0 .../ExistExpTransformedCond | 0 .../ExistExpTransformedCond.result | 0 .../complex_expressions/Exists1ExpBindRemoved | 0 .../Exists1ExpBindRemoved.result | 0 .../complex_expressions/Exists1ExpBlockStm | 0 .../Exists1ExpBlockStm.result | 0 .../complex_expressions/Exists1ExpInIfExp | 0 .../Exists1ExpInIfExp.result | 0 .../complex_expressions/Exists1ExpInLet | 0 .../Exists1ExpInLet.result | 0 .../complex_expressions/Exists1ExpReturned | 0 .../Exists1ExpReturned.result | 0 .../complex_expressions/ExistsExpBlockStm | 0 .../ExistsExpBlockStm.result | 0 .../complex_expressions/ExistsExpInIfExp | 0 .../ExistsExpInIfExp.result | 0 .../complex_expressions/ExistsExpInLet | 0 .../complex_expressions/ExistsExpInLet.result | 0 .../complex_expressions/ExistsExpReturned | 0 .../ExistsExpReturned.result | 0 .../ExistsExpSeveralMultipleSetBindsCond1 | 0 ...istsExpSeveralMultipleSetBindsCond1.result | 0 .../ExistsRemoveAllMultipleSetBinds | 0 .../ExistsRemoveAllMultipleSetBinds.result | 0 .../ExistsRemoveOneOfTwoMultipleSetBinds | 0 ...xistsRemoveOneOfTwoMultipleSetBinds.result | 0 .../complex_expressions/ExplicitNameCallStm | 0 .../ExplicitNameCallStm.result | 0 .../complex_expressions/ExplicitNameVarExp | 0 .../ExplicitNameVarExp.result | 0 .../FieldDesignatorOfRecObj | 0 .../FieldDesignatorOfRecObj.result | 0 .../FieldDesignatorOfRecObjChainOfThree | 0 ...FieldDesignatorOfRecObjChainOfThree.result | 0 .../FieldDesignatorOfRecObjChainOfTwo | 0 .../FieldDesignatorOfRecObjChainOfTwo.result | 0 .../complex_expressions/ForAllExpBlockStm | 0 .../ForAllExpBlockStm.result | 0 .../complex_expressions/ForAllExpInIfExp | 0 .../ForAllExpInIfExp.result | 0 .../complex_expressions/ForAllExpInLet | 0 .../complex_expressions/ForAllExpInLet.result | 0 .../complex_expressions/ForAllExpReturned | 0 .../ForAllExpReturned.result | 0 .../ForAllExpSeveralMultipleSetBindsCond1 | 0 ...rAllExpSeveralMultipleSetBindsCond1.result | 0 .../ForAllExpTransformedCond | 0 .../ForAllExpTransformedCond.result | 0 .../ForAllRemoveAllMultipleSetBinds | 0 .../ForAllRemoveAllMultipleSetBinds.result | 0 .../ForAllRemoveOneOfTwoMultipleSetBinds | 0 ...orAllRemoveOneOfTwoMultipleSetBinds.result | 0 .../complex_expressions/HdExpNumberDeref | 0 .../HdExpNumberDeref.result | 0 .../complex_expressions/IfExpAndExpBranch | 0 .../IfExpAndExpBranch.result | 0 .../complex_expressions/InheritedFieldAccess | 0 .../InheritedFieldAccess.result | 0 .../complex_expressions/InheritedFuncInvoke | 0 .../InheritedFuncInvoke.result | 0 .../test/resources/complex_expressions/IsExp | 0 .../complex_expressions/IsExp.result | 0 .../IsExpNamedTypeInvariantRecursiveTypes | 0 ...ExpNamedTypeInvariantRecursiveTypes.result | 0 .../IsExpNamedTypeInvariantUnionOfQuotes | 0 ...sExpNamedTypeInvariantUnionOfQuotes.result | 0 .../complex_expressions/IsExpNatUnionBool | 0 .../IsExpNatUnionBool.result | 0 .../complex_expressions/IsExpQuoteType | 0 .../complex_expressions/IsExpQuoteType.result | 0 .../complex_expressions/LetBeExpWithLetExp | 0 .../LetBeExpWithLetExp.result | 0 .../complex_expressions/LetBeStExpInBlock | 0 .../LetBeStExpInBlock.result | 0 .../LetBeStExpInFuncWithCond | 0 .../LetBeStExpInFuncWithCond.result | 0 .../complex_expressions/LetBeStExpInLetDef | 0 .../LetBeStExpInLetDef.result | 0 .../LetBeStExpInReturnWithCond | 0 .../LetBeStExpInReturnWithCond.result | 0 .../complex_expressions/LetBeStExpRemoveSet | 0 .../LetBeStExpRemoveSet.result | 0 .../complex_expressions/LetBeStExpSetSum | 0 .../LetBeStExpSetSum.result | 0 .../LetBeStExpSimpleNoCond | 0 .../LetBeStExpSimpleNoCond.result | 0 .../LetBeStExpTransformedCond | 0 .../LetBeStExpTransformedCond.result | 0 .../complex_expressions/LetBeStNoCondSetSum | 0 .../LetBeStNoCondSetSum.result | 0 .../complex_expressions/LetBeStRemoveSet | 0 .../LetBeStRemoveSet.result | 0 .../complex_expressions/LetBeStThreeBindsCond | 0 .../LetBeStThreeBindsCond.result | 0 .../LetBeStThreeBindsNoCond | 0 .../LetBeStThreeBindsNoCond.result | 0 .../LetBeStTransformedCond | 0 .../LetBeStTransformedCond.result | 0 .../complex_expressions/LetBeStWithCond | 0 .../LetBeStWithCond.result | 0 .../complex_expressions/MapCompBlockStm | 0 .../MapCompBlockStm.result | 0 .../complex_expressions/MapCompInLet | 0 .../complex_expressions/MapCompInLet.result | 0 .../complex_expressions/MapCompInOpCallInLoop | 0 .../MapCompInOpCallInLoop.result | 0 .../MapCompRemoveAllMultipleSetBinds | 0 .../MapCompRemoveAllMultipleSetBinds.result | 0 .../MapCompRemoveOneOfTwoMultipleSetBinds | 0 ...pCompRemoveOneOfTwoMultipleSetBinds.result | 0 .../MapCompReturnThreePatternsCond | 0 .../MapCompReturnThreePatternsCond.result | 0 .../complex_expressions/MapCompReturned | 0 .../MapCompReturned.result | 0 .../MapCompSeveralMultipleSetBindsCond1 | 0 ...MapCompSeveralMultipleSetBindsCond1.result | 0 .../MapCompSeveralMultipleSetBindsCond2 | 0 ...MapCompSeveralMultipleSetBindsCond2.result | 0 .../MapCompSeveralMultipleSetBindsCond3 | 0 ...MapCompSeveralMultipleSetBindsCond3.result | 0 .../MapCompSeveralMultipleSetBindsNoCond | 0 ...apCompSeveralMultipleSetBindsNoCond.result | 0 .../MapCompTransformedMaplet | 0 .../MapCompTransformedMaplet.result | 0 .../MapSeqStateDesignatorChangeRecField | 0 ...MapSeqStateDesignatorChangeRecField.result | 0 .../MapSeqStateDesignatorMapInMap | 0 .../MapSeqStateDesignatorMapInMap.result | 0 .../MapSeqStateDesignatorMapSeqToSeq | 0 .../MapSeqStateDesignatorMapSeqToSeq.result | 0 .../MapSeqStateDesignatorMapUpdate | 0 .../MapSeqStateDesignatorMapUpdate.result | 0 .../MapSeqStateDesignatorNesting | 0 .../MapSeqStateDesignatorNesting.result | 0 .../MapSeqStateDesignatorSeqInSeqInSeq | 0 .../MapSeqStateDesignatorSeqInSeqInSeq.result | 0 .../MapSeqStateDesignatorSeqUpdate | 0 .../MapSeqStateDesignatorSeqUpdate.result | 0 .../complex_expressions/MethodInstantiation | 0 .../MethodInstantiation.result | 0 .../complex_expressions/NotEqualsOptionalType | 0 .../NotEqualsOptionalType.result | 0 .../OptionalTypedNumberEqual | 0 .../OptionalTypedNumberEqual.result | 0 .../OptionallyTypedRecordFieldComparison | 0 ...ptionallyTypedRecordFieldComparison.result | 0 .../OptionallyTypedSetComparison | 0 .../OptionallyTypedSetComparison.result | 0 .../OptionallyTypedTupleComp | 0 .../OptionallyTypedTupleComp.result | 0 .../resources/complex_expressions/OrExpChain | 0 .../complex_expressions/OrExpChain.result | 0 .../complex_expressions/OrExpEvalOrder | 0 .../complex_expressions/OrExpEvalOrder.result | 0 .../complex_expressions/OrExpExistsExps | 0 .../OrExpExistsExps.result | 0 .../complex_expressions/OrExpOrChainInForAll | 0 .../OrExpOrChainInForAll.result | 0 .../complex_expressions/QuoteLitComparison | 0 .../QuoteLitComparison.result | 0 .../RecModExpArgToApplyExp | 0 .../RecModExpArgToApplyExp.result | 0 .../complex_expressions/RecModExpForAllExp | 0 .../RecModExpForAllExp.result | 0 .../complex_expressions/RecModExpInRecModExp | 0 .../RecModExpInRecModExp.result | 0 .../complex_expressions/RecModExpSimple1 | 0 .../RecModExpSimple1.result | 0 .../complex_expressions/RecModExpVarExp | 0 .../RecModExpVarExp.result | 0 .../resources/complex_expressions/RecordComp | 0 .../complex_expressions/RecordComp.result | 0 .../RecordUsageAcrossClass | 0 .../RecordUsageAcrossClass.result | 0 .../resources/complex_expressions/RecordValue | 0 .../complex_expressions/RecordValue.result | 0 .../RecursiveNamedTypeMapApply | 0 .../RecursiveNamedTypeMapApply.result | 0 .../complex_expressions/SeqCompBlockStm | 0 .../SeqCompBlockStm.result | 0 .../complex_expressions/SeqCompInLet | 0 .../complex_expressions/SeqCompInLet.result | 0 .../complex_expressions/SeqCompInOpCallInLoop | 0 .../SeqCompInOpCallInLoop.result | 0 .../complex_expressions/SeqCompRemoveEmptySet | 0 .../SeqCompRemoveEmptySet.result | 0 .../complex_expressions/SeqCompReturned | 0 .../SeqCompReturned.result | 0 .../SeqCompTransformedElement | 0 .../SeqCompTransformedElement.result | 0 .../complex_expressions/SeqConversion | 0 .../complex_expressions/SeqConversion.result | 0 .../complex_expressions/SetCompBlockStm | 0 .../SetCompBlockStm.result | 0 .../complex_expressions/SetCompInLet | 0 .../complex_expressions/SetCompInLet.result | 0 .../complex_expressions/SetCompInOpCallInLoop | 0 .../SetCompInOpCallInLoop.result | 0 .../SetCompRemoveAllMultipleSetBinds | 0 .../SetCompRemoveAllMultipleSetBinds.result | 0 .../SetCompRemoveOneOfTwoMultipleSetBinds | 0 ...tCompRemoveOneOfTwoMultipleSetBinds.result | 0 .../SetCompReturnThreePatternsCond | 0 .../SetCompReturnThreePatternsCond.result | 0 .../SetCompSeveralMultipleSetBindsCond1 | 0 ...SetCompSeveralMultipleSetBindsCond1.result | 0 .../SetCompSeveralMultipleSetBindsCond2 | 0 ...SetCompSeveralMultipleSetBindsCond2.result | 0 .../SetCompSeveralMultipleSetBindsCond3 | 0 ...SetCompSeveralMultipleSetBindsCond3.result | 0 .../SetCompSeveralMultipleSetBindsNoCond | 0 ...etCompSeveralMultipleSetBindsNoCond.result | 0 .../SetCompTransformedElement | 0 .../SetCompTransformedElement.result | 0 .../complex_expressions/SuperConstructors | 0 .../SuperConstructors.result | 0 .../SuperOpCallOfOverwrittenOp | 0 .../SuperOpCallOfOverwrittenOp.result | 0 .../resources/complex_expressions/TokenType | 0 .../complex_expressions/TokenType.result | 0 .../UnaryMinusExpArgToFunc | 0 .../UnaryMinusExpArgToFunc.result | 0 .../complex_expressions/UnaryPlusExpArgToFunc | 0 .../UnaryPlusExpArgToFunc.result | 0 .../complex_expressions/WhileStmForAllExpCond | 0 .../WhileStmForAllExpCond.result | 0 .../complex_expressions/WhileStmSetSum | 0 .../complex_expressions/WhileStmSetSum.result | 0 .../DoubleOperationMutexSharedCounter | 0 .../DoubleOperationMutexSharedCounter.result | 0 .../DoublePermissionPredSharedCounter | 0 .../DoublePermissionPredSharedCounter.result | 0 .../FourOperationMutexSharedcounter | 0 .../FourOperationMutexSharedcounter.result | 0 .../HistoryCounterActSharedResource | 0 .../HistoryCounterActSharedResource.result | 0 .../HistoryCounterActiveSharedCounter | 0 .../HistoryCounterActiveSharedCounter.result | 0 .../HistoryCounterFinSharedResource | 0 .../HistoryCounterFinSharedResource.result | 0 .../HistoryCounterReqSharedResource | 0 .../HistoryCounterReqSharedResource.result | 0 .../HistoryCounterWaitingSharedCounter | 0 .../HistoryCounterWaitingSharedCounter.result | 0 .../HistoryCounterandMutexSharedResource | 0 ...istoryCounterandMutexSharedResource.result | 0 .../concurrency/MutexAllSharedCounter | 0 .../concurrency/MutexAllSharedCounter.result | 0 .../resources/concurrency/OverloadedOperation | 0 .../concurrency/OverloadedOperation.result | 0 .../resources/concurrency/ReaderWriterExample | 0 .../concurrency/ReaderWriterExample.result | 0 .../concurrency/SingleLevelInheritance | 0 .../concurrency/SingleLevelInheritance.result | 0 .../SingleOperationMutexSharedCounter | 0 .../SingleOperationMutexSharedCounter.result | 0 .../StartlistdefinitionMutexSynchronized | 0 ...tartlistdefinitionMutexSynchronized.result | 0 .../concurrency/ThreadIdSingleThread | 26 ++-- .../concurrency/ThreadIdSingleThread.result | 0 .../test/resources/concurrency/ThreadStart | 0 .../resources/concurrency/ThreadStart.result | 0 .../POP3_LogBased_Test1 | 0 .../POP3_LogBased_Test1.result | 0 .../src/test/resources/expressions/AbsInTuple | 0 .../resources/expressions/AbsInTuple.result | 0 .../test/resources/expressions/AbsOperator | 0 .../resources/expressions/AbsOperator.result | 0 .../resources/expressions/AndOfEquivalence | 0 .../expressions/AndOfEquivalence.result | 0 .../test/resources/expressions/AndOperator | 0 .../resources/expressions/AndOperator.result | 0 .../resources/expressions/ApplyExpSeqEnum | 0 .../expressions/ApplyExpSeqEnum.result | 0 .../test/resources/expressions/ApplyExpString | 0 .../expressions/ApplyExpString.result | 0 .../resources/expressions/BoolLiteralFalse | 0 .../expressions/BoolLiteralFalse.result | 0 .../resources/expressions/BoolLiteralTrue | 0 .../expressions/BoolLiteralTrue.result | 0 .../test/resources/expressions/CharLitNewLine | 0 .../expressions/CharLitNewLine.result | 0 .../resources/expressions/CharLitSingleQuote | 0 .../expressions/CharLitSingleQuote.result | 0 .../test/resources/expressions/DivOperator | 0 .../resources/expressions/DivOperator.result | 0 .../resources/expressions/ElemsSeqOfSeqOfNat1 | 0 .../expressions/ElemsSeqOfSeqOfNat1.result | 0 .../test/resources/expressions/ElemsSeqofNat1 | 0 .../expressions/ElemsSeqofNat1.result | 0 .../test/resources/expressions/EqualsNumeric | 0 .../expressions/EqualsNumeric.result | 0 .../resources/expressions/EquivalenceOperator | 0 .../expressions/EquivalenceOperator.result | 0 .../test/resources/expressions/FieldNumberExp | 0 .../expressions/FieldNumberExp.result | 0 .../resources/expressions/FloorExpression | 0 .../expressions/FloorExpression.result | 0 .../resources/expressions/ImplicationOperator | 0 .../expressions/ImplicationOperator.result | 0 .../resources/expressions/InverseOfProduct | 0 .../expressions/InverseOfProduct.result | 0 .../test/resources/expressions/InverseOfSum | 0 .../resources/expressions/InverseOfSum.result | 0 .../test/resources/expressions/IsExpBoolFalse | 0 .../expressions/IsExpBoolFalse.result | 0 .../test/resources/expressions/IsExpBoolTrue | 0 .../expressions/IsExpBoolTrue.result | 0 .../test/resources/expressions/IsExpCharFalse | 0 .../expressions/IsExpCharFalse.result | 0 .../test/resources/expressions/IsExpCharTrue | 0 .../expressions/IsExpCharTrue.result | 0 .../test/resources/expressions/IsExpIntFalse | 0 .../expressions/IsExpIntFalse.result | 0 .../test/resources/expressions/IsExpIntTrue | 0 .../resources/expressions/IsExpIntTrue.result | 0 .../test/resources/expressions/IsExpNat1False | 0 .../expressions/IsExpNat1False.result | 0 .../test/resources/expressions/IsExpNat1True | 0 .../expressions/IsExpNat1True.result | 0 .../test/resources/expressions/IsExpNatFalse | 0 .../expressions/IsExpNatFalse.result | 0 .../test/resources/expressions/IsExpNatTrue | 0 .../resources/expressions/IsExpNatTrue.result | 0 .../test/resources/expressions/IsExpRatFalse | 0 .../expressions/IsExpRatFalse.result | 0 .../test/resources/expressions/IsExpRatTrue | 0 .../resources/expressions/IsExpRatTrue.result | 0 .../resources/expressions/IsExpTokenFalse | 0 .../expressions/IsExpTokenFalse.result | 0 .../test/resources/expressions/IsExpTokenTrue | 0 .../expressions/IsExpTokenTrue.result | 0 .../expressions/Maps/MapApplyMapEnumExp | 0 .../Maps/MapApplyMapEnumExp.result | 0 .../resources/expressions/Maps/MapDomEmptyMap | 0 .../expressions/Maps/MapDomEmptyMap.result | 0 .../expressions/Maps/MapDomNatToNatMap | 0 .../expressions/Maps/MapDomNatToNatMap.result | 0 .../Maps/MapDomResByEmtptySetAndMap | 0 .../Maps/MapDomResByEmtptySetAndMap.result | 0 .../expressions/Maps/MapDomResByNatToNatMap | 0 .../Maps/MapDomResByNatToNatMap.result | 0 .../Maps/MapDomResToEmtptySetAndMap | 0 .../Maps/MapDomResToEmtptySetAndMap.result | 0 .../expressions/Maps/MapDomResToNatToNatMap | 0 .../Maps/MapDomResToNatToNatMap.result | 0 .../expressions/Maps/MapEnumExpEmpty | 0 .../expressions/Maps/MapEnumExpEmpty.result | 0 .../expressions/Maps/MapEnumExpMixed | 0 .../expressions/Maps/MapEnumExpMixed.result | 0 .../resources/expressions/Maps/MapEnumExpNats | 0 .../expressions/Maps/MapEnumExpNats.result | 0 .../expressions/Maps/MapInverseNatToNatMap | 0 .../Maps/MapInverseNatToNatMap.result | 0 .../expressions/Maps/MapMergeEmptyMaps | 0 .../expressions/Maps/MapMergeEmptyMaps.result | 0 .../expressions/Maps/MapMergeNatToNatMaps | 0 .../Maps/MapMergeNatToNatMaps.result | 0 .../expressions/Maps/MapOverrideEmptyMaps | 0 .../Maps/MapOverrideEmptyMaps.result | 0 .../expressions/Maps/MapOverrideNatToNatMaps | 0 .../Maps/MapOverrideNatToNatMaps.result | 0 .../expressions/Maps/MapRangeEmptyMap | 0 .../expressions/Maps/MapRangeEmptyMap.result | 0 .../expressions/Maps/MapRangeNatToNatMap | 0 .../Maps/MapRangeNatToNatMap.result | 0 .../Maps/MapRangeResByEmtptySetAndMap | 0 .../Maps/MapRangeResByEmtptySetAndMap.result | 0 .../expressions/Maps/MapRangeResByNatToNatMap | 0 .../Maps/MapRangeResByNatToNatMap.result | 0 .../Maps/MapRangeResToEmtptySetAndMap | 0 .../Maps/MapRangeResToEmtptySetAndMap.result | 0 .../expressions/Maps/MapRangeResToNatToNatMap | 0 .../Maps/MapRangeResToNatToNatMap.result | 0 .../expressions/Maps/MapUnionEmptyMaps | 0 .../expressions/Maps/MapUnionEmptyMaps.result | 0 .../expressions/Maps/MapUnionNatToNatMaps | 0 .../Maps/MapUnionNatToNatMaps.result | 0 .../test/resources/expressions/Maps/SetEqual | 0 .../expressions/Maps/SetEqual.result | 0 .../resources/expressions/Maps/SetEqualEmpty | 0 .../expressions/Maps/SetEqualEmpty.result | 0 .../resources/expressions/Maps/SetNotEqual | 0 .../expressions/Maps/SetNotEqual.result | 0 .../expressions/Maps/SetNotEqualEmpty | 0 .../expressions/Maps/SetNotEqualEmpty.result | 0 .../expressions/MkBasicExpEqualsFalse | 0 .../expressions/MkBasicExpEqualsFalse.result | 0 .../expressions/MkBasicExpEqualsTrue | 0 .../expressions/MkBasicExpEqualsTrue.result | 0 .../expressions/MkBasicExpNotEqualsFalse | 0 .../MkBasicExpNotEqualsFalse.result | 0 .../expressions/MkBasicExpNotEqualsTrue | 0 .../MkBasicExpNotEqualsTrue.result | 0 .../test/resources/expressions/ModOperator | 0 .../resources/expressions/ModOperator.result | 0 .../resources/expressions/NotEqualsNumeric | 0 .../expressions/NotEqualsNumeric.result | 0 .../resources/expressions/NotOfImplication | 0 .../expressions/NotOfImplication.result | 0 .../src/test/resources/expressions/NotOfOr | 0 .../test/resources/expressions/NotOfOr.result | 0 .../test/resources/expressions/NotOperator | 0 .../resources/expressions/NotOperator.result | 0 .../src/test/resources/expressions/Null | 0 .../test/resources/expressions/Null.result | 0 .../src/test/resources/expressions/NumericExp | 0 .../resources/expressions/NumericExp.result | 0 .../expressions/NumericExpOperatorPrecedence | 0 .../NumericExpOperatorPrecedence.result | 0 .../src/test/resources/expressions/OrOperator | 0 .../resources/expressions/OrOperator.result | 0 .../src/test/resources/expressions/Power | 0 .../test/resources/expressions/Power.result | 0 .../expressions/RealDivideIntegerOperands | 0 .../RealDivideIntegerOperands.result | 0 .../expressions/RealDivideRealOperand | 0 .../expressions/RealDivideRealOperand.result | 0 .../test/resources/expressions/RemOperator | 0 .../resources/expressions/RemOperator.result | 0 .../expressions/RemOperatorIsolation | 0 .../expressions/RemOperatorIsolation.result | 0 .../expressions/Sequences/SeqConcatExpStrings | 0 .../Sequences/SeqConcatExpStrings.result | 0 .../expressions/Sequences/SeqConcatenationExp | 0 .../Sequences/SeqConcatenationExp.result | 0 .../Sequences/SeqDistConcExpEmptySeq | 0 .../Sequences/SeqDistConcExpEmptySeq.result | 0 .../Sequences/SeqDistConcExpEmptySeqs | 0 .../Sequences/SeqDistConcExpEmptySeqs.result | 0 .../Sequences/SeqDistConcExpNoArgs | 0 .../Sequences/SeqDistConcExpNoArgs.result | 0 .../Sequences/SeqDistConcExpOneSeqs | 0 .../Sequences/SeqDistConcExpOneSeqs.result | 0 .../Sequences/SeqDistConcExpThreeSeqs | 0 .../Sequences/SeqDistConcExpThreeSeqs.result | 0 .../expressions/Sequences/SeqDistConcStrings | 0 .../Sequences/SeqDistConcStrings.result | 0 .../expressions/Sequences/SeqDistConcTuples | 0 .../Sequences/SeqDistConcTuples.result | 0 .../expressions/Sequences/SeqElemsExp | 0 .../expressions/Sequences/SeqElemsExp.result | 0 .../expressions/Sequences/SeqEqualsExp | 0 .../expressions/Sequences/SeqEqualsExp.result | 0 .../resources/expressions/Sequences/SeqHdExp | 0 .../expressions/Sequences/SeqHdExp.result | 0 .../expressions/Sequences/SeqHdValueType | 0 .../Sequences/SeqHdValueType.result | 0 .../expressions/Sequences/SeqIndexExp | 0 .../expressions/Sequences/SeqIndexExp.result | 0 .../Sequences/SeqIndexValueTypeExp | 0 .../Sequences/SeqIndexValueTypeExp.result | 0 .../expressions/Sequences/SeqIndsExp | 0 .../expressions/Sequences/SeqIndsExp.result | 0 .../resources/expressions/Sequences/SeqLenExp | 0 .../expressions/Sequences/SeqLenExp.result | 0 .../resources/expressions/Sequences/SeqModExp | 0 .../expressions/Sequences/SeqModExp.result | 0 .../expressions/Sequences/SeqModExpEmptySeq | 0 .../Sequences/SeqModExpEmptySeq.result | 0 .../expressions/Sequences/SeqNotEqualsExp | 0 .../Sequences/SeqNotEqualsExp.result | 0 .../expressions/Sequences/SeqReverseExp | 0 .../Sequences/SeqReverseExp.result | 0 .../resources/expressions/Sequences/SeqTlExp | 0 .../expressions/Sequences/SeqTlExp.result | 0 .../expressions/Sequences/StringEqual | 0 .../expressions/Sequences/StringEqual.result | 0 .../expressions/Sequences/StringNotEqual | 0 .../Sequences/StringNotEqual.result | 0 .../expressions/SetProperSubsetNatSets | 0 .../expressions/SetProperSubsetNatSets.result | 0 .../resources/expressions/SetRangeEmptySet | 0 .../expressions/SetRangeEmptySet.result | 0 .../resources/expressions/SetRangeEqualBounds | 0 .../expressions/SetRangeEqualBounds.result | 0 .../resources/expressions/SetRangeOneToTen | 0 .../expressions/SetRangeOneToTen.result | 0 .../resources/expressions/SetRangeRealBounds | 0 .../expressions/SetRangeRealBounds.result | 0 .../expressions/Sets/SetCardExpEmpty | 0 .../expressions/Sets/SetCardExpEmpty.result | 0 .../resources/expressions/Sets/SetCardNatSet | 0 .../expressions/Sets/SetCardNatSet.result | 0 .../expressions/Sets/SetDifferenceNatSets | 0 .../Sets/SetDifferenceNatSets.result | 0 .../expressions/Sets/SetDistInterNatSets | 0 .../Sets/SetDistInterNatSets.result | 0 .../expressions/Sets/SetDistUnionNatSets | 0 .../Sets/SetDistUnionNatSets.result | 0 .../expressions/Sets/SetEnumExpEmpty | 0 .../expressions/Sets/SetEnumExpEmpty.result | 0 .../expressions/Sets/SetEnumExpNatSet | 0 .../expressions/Sets/SetEnumExpNatSet.result | 0 .../test/resources/expressions/Sets/SetEqual | 0 .../expressions/Sets/SetEqual.result | 0 .../resources/expressions/Sets/SetEqualEmpty | 0 .../expressions/Sets/SetEqualEmpty.result | 0 .../test/resources/expressions/Sets/SetInSet | 0 .../expressions/Sets/SetInSet.result | 0 .../expressions/Sets/SetIntersectNatSets | 0 .../Sets/SetIntersectNatSets.result | 0 .../resources/expressions/Sets/SetNotEqual | 0 .../expressions/Sets/SetNotEqual.result | 0 .../expressions/Sets/SetNotEqualEmpty | 0 .../expressions/Sets/SetNotEqualEmpty.result | 0 .../resources/expressions/Sets/SetNotInSet | 0 .../expressions/Sets/SetNotInSet.result | 0 .../expressions/Sets/SetPowerSetEmptySet | 0 .../Sets/SetPowerSetEmptySet.result | 0 .../expressions/Sets/SetPowerSetNatSet | 0 .../expressions/Sets/SetPowerSetNatSet.result | 0 .../expressions/Sets/SetSubsetNatSet | 0 .../expressions/Sets/SetSubsetNatSet.result | 0 .../expressions/Sets/SetUnionNatSets | 0 .../expressions/Sets/SetUnionNatSets.result | 0 .../test/resources/expressions/StringEscape | 0 .../resources/expressions/StringEscape.result | 0 .../src/test/resources/expressions/SubSeq1 | 0 .../test/resources/expressions/SubSeq1.result | 0 .../src/test/resources/expressions/SubSeq2 | 0 .../test/resources/expressions/SubSeq2.result | 0 .../src/test/resources/expressions/SubSeq3 | 0 .../test/resources/expressions/SubSeq3.result | 0 .../src/test/resources/expressions/SubSeq4 | 0 .../test/resources/expressions/SubSeq4.result | 0 .../src/test/resources/expressions/SubSeq5 | 0 .../test/resources/expressions/SubSeq5.result | 0 .../src/test/resources/expressions/SubSeq6 | 0 .../test/resources/expressions/SubSeq6.result | 0 .../expressions/SubtractNumericBinary | 0 .../expressions/SubtractNumericBinary.result | 0 .../test/resources/expressions/TupleEquals | 0 .../resources/expressions/TupleEquals.result | 0 .../test/resources/expressions/TupleNotEquals | 0 .../expressions/TupleNotEquals.result | 0 .../resources/expressions/UnaryMinusBinaryExp | 0 .../expressions/UnaryMinusBinaryExp.result | 0 .../resources/expressions/UnaryMinusOfBinExp | 0 .../expressions/UnaryMinusOfBinExp.result | 0 .../expressions/UnaryPlusOfBinaryExp | 0 .../expressions/UnaryPlusOfBinaryExp.result | 0 .../function_value_specs/CurriedAdd1 | 0 .../function_value_specs/CurriedAdd1.result | 0 .../function_value_specs/CurriedAdd2 | 0 .../function_value_specs/CurriedAdd2.result | 0 .../CurriedDifferentParameterTypes | 0 .../CurriedDifferentParameterTypes.result | 0 .../FunctionComposeCurried1 | 0 .../FunctionComposeCurried1.result | 0 .../FunctionComposeCurried2 | 0 .../FunctionComposeCurried2.result | 0 .../FunctionComposeUncurried | 0 .../FunctionComposeUncurried.result | 0 .../FunctionReturningFunction | 0 .../FunctionReturningFunction.result | 0 .../function_value_specs/LambdaCurryAdd | 0 .../LambdaCurryAdd.result | 0 .../function_value_specs/LambdaInLet | 0 .../function_value_specs/LambdaInLet.result | 0 .../LambdaReturningSetComp | 0 .../LambdaReturningSetComp.result | 0 .../function_value_specs/LambdaWithLet | 0 .../function_value_specs/LambdaWithLet.result | 0 .../function_value_specs/MapBoolToNatCurried | 0 .../MapBoolToNatCurried.result | 0 .../function_value_specs/MapNatCurried | 0 .../function_value_specs/MapNatCurried.result | 0 .../function_value_specs/MapNatToBoolCurried | 44 +++---- .../MapNatToBoolCurried.result | 0 .../function_value_specs/MapNatToChar | 0 .../function_value_specs/MapNatToChar.result | 0 .../function_value_specs/MapUncurried | 0 .../function_value_specs/MapUncurried.result | 0 .../src/test/resources/lib/CSV.vdmpp | 0 .../src/test/resources/lib/IO.vdmpp | 0 .../src/test/resources/lib/MATH.vdmpp | 0 .../src/test/resources/lib/VDMUnit.vdmpp | 0 .../src/test/resources/lib/VDMUtil.vdmpp | 0 .../package_specs/OneClassUsesQuotes | 0 .../package_specs/OneClassUsesQuotes.result | 0 .../RecordUsageAcrossClassSimple | 0 .../RecordUsageAcrossClassSimple.result | 0 .../test/resources/package_specs/TwoClasses | 0 .../resources/package_specs/TwoClasses.result | 0 .../resources/package_specs/UsesRuntimeLib | 0 .../package_specs/UsesRuntimeLib.result | 0 .../BlockWithInterdependentPatterns | 0 .../BlockWithInterdependentPatterns.result | 0 .../src/test/resources/pattern_specs/Bool | 0 .../test/resources/pattern_specs/Bool.result | 0 .../CasesExpNamedInvariantTypedExp | 0 .../CasesExpNamedInvariantTypedExp.result | 0 .../pattern_specs/CasesExpNestingLetExp | 0 .../CasesExpNestingLetExp.result | 0 .../pattern_specs/CasesExpOneCaseNoOthers | 0 .../CasesExpOneCaseNoOthers.result | 0 .../test/resources/pattern_specs/CasesExpRec | 0 .../pattern_specs/CasesExpRec.result | 0 ...xpRecordPatternNamedInvariantUnionTypedExp | 0 ...dPatternNamedInvariantUnionTypedExp.result | 0 .../resources/pattern_specs/CasesExpTuple | 0 .../pattern_specs/CasesExpTuple.result | 0 .../CasesExpUnionTypedConWithSimpleTypes | 0 ...asesExpUnionTypedConWithSimpleTypes.result | 0 .../CasesExpUnionTypedCondWithTuples | 0 .../CasesExpUnionTypedCondWithTuples.result | 0 .../test/resources/pattern_specs/CasesStmBool | 0 .../pattern_specs/CasesStmBool.result | 0 .../test/resources/pattern_specs/CasesStmChar | 0 .../pattern_specs/CasesStmChar.result | 0 .../pattern_specs/CasesStmIdentifier | 0 .../pattern_specs/CasesStmIdentifier.result | 0 .../resources/pattern_specs/CasesStmIgnore | 0 .../pattern_specs/CasesStmIgnore.result | 0 .../test/resources/pattern_specs/CasesStmInt | 0 .../pattern_specs/CasesStmInt.result | 0 .../CasesStmMultiplePatternsPerAlt | 0 .../CasesStmMultiplePatternsPerAlt.result | 0 .../CasesStmNamedInvariantTypedExp | 0 .../CasesStmNamedInvariantTypedExp.result | 0 .../test/resources/pattern_specs/CasesStmNil | 0 .../pattern_specs/CasesStmNil.result | 0 .../resources/pattern_specs/CasesStmOpCallExp | 0 .../pattern_specs/CasesStmOpCallExp.result | 0 .../resources/pattern_specs/CasesStmQuote | 0 .../pattern_specs/CasesStmQuote.result | 0 .../test/resources/pattern_specs/CasesStmReal | 0 .../pattern_specs/CasesStmReal.result | 0 .../test/resources/pattern_specs/CasesStmRec | 0 .../pattern_specs/CasesStmRec.result | 0 ...tmRecordPatternNamedInvariantUnionTypedExp | 0 ...dPatternNamedInvariantUnionTypedExp.result | 0 .../resources/pattern_specs/CasesStmString | 0 .../pattern_specs/CasesStmString.result | 0 .../resources/pattern_specs/CasesStmTuple | 0 .../pattern_specs/CasesStmTuple.result | 0 .../src/test/resources/pattern_specs/Char | 0 .../test/resources/pattern_specs/Char.result | 0 .../pattern_specs/ForAllStmIdentifierPattern | 0 .../ForAllStmIdentifierPattern.result | 0 .../pattern_specs/ForAllStmIgnorePattern | 0 .../ForAllStmIgnorePattern.result | 0 .../pattern_specs/ForAllStmIntPattern | 0 .../pattern_specs/ForAllStmIntPattern.result | 0 .../ForAllStmTuplePatternWithIdentifiers | 0 ...orAllStmTuplePatternWithIdentifiers.result | 0 .../ForAllStmTuplePatternWithIgnorePattern | 0 ...AllStmTuplePatternWithIgnorePattern.result | 0 .../ForPatternBindIdentifierPattern | 0 .../ForPatternBindIdentifierPattern.result | 0 .../pattern_specs/ForPatternBindIgnorePattern | 0 .../ForPatternBindIgnorePattern.result | 0 .../pattern_specs/ForPatternBindIntPattern | 0 .../ForPatternBindIntPattern.result | 0 .../ForPatternBindTuplePatternWithIdentifiers | 0 ...ternBindTuplePatternWithIdentifiers.result | 0 ...orPatternBindTuplePatternWithIgnorePattern | 0 ...rnBindTuplePatternWithIgnorePattern.result | 0 .../resources/pattern_specs/IgnorePattern | 0 .../pattern_specs/IgnorePattern.result | 0 .../IgnorePatternLastInTuplePattern | 0 .../IgnorePatternLastInTuplePattern.result | 0 .../src/test/resources/pattern_specs/Int | 0 .../test/resources/pattern_specs/Int.result | 0 .../resources/pattern_specs/LetBeStRecPattern | 0 .../pattern_specs/LetBeStRecPattern.result | 0 .../pattern_specs/LetBeStTuplePattern1 | 0 .../pattern_specs/LetBeStTuplePattern1.result | 0 .../pattern_specs/LetBeStTuplePattern2 | 0 .../pattern_specs/LetBeStTuplePattern2.result | 0 .../src/test/resources/pattern_specs/Nil | 0 .../test/resources/pattern_specs/Nil.result | 0 .../src/test/resources/pattern_specs/Quote | 0 .../test/resources/pattern_specs/Quote.result | 0 .../src/test/resources/pattern_specs/Real | 0 .../test/resources/pattern_specs/Real.result | 0 .../pattern_specs/RecordLastFieldInt | 0 .../pattern_specs/RecordLastFieldInt.result | 0 .../resources/pattern_specs/RecordNoFields | 0 .../pattern_specs/RecordNoFields.result | 0 .../RecordPatternIdentifierPatterns | 0 .../RecordPatternIdentifierPatterns.result | 0 .../RecordPatternWithSimplePatterns | 0 .../RecordPatternWithSimplePatterns.result | 0 .../pattern_specs/RecordWithIgnorePattern | 0 .../RecordWithIgnorePattern.result | 0 .../resources/pattern_specs/RecordWithTuple | 0 .../pattern_specs/RecordWithTuple.result | 0 .../src/test/resources/pattern_specs/String | 0 .../resources/pattern_specs/String.result | 0 .../pattern_specs/TupleLastFieldIntPattern | 0 .../TupleLastFieldIntPattern.result | 0 .../pattern_specs/TupleNestingTuples | 0 .../pattern_specs/TupleNestingTuples.result | 0 .../TuplePatternIdentifierPatterns | 0 .../TuplePatternIdentifierPatterns.result | 0 .../pattern_specs/TuplePatternNestedInBlocks1 | 0 .../TuplePatternNestedInBlocks1.result | 0 .../pattern_specs/TuplePatternNestedInBlocks2 | 0 .../TuplePatternNestedInBlocks2.result | 0 .../pattern_specs/TupleWithBoolPattern | 0 .../pattern_specs/TupleWithBoolPattern.result | 0 .../pattern_specs/TupleWithIgnorePattern | 0 .../TupleWithIgnorePattern.result | 0 .../resources/pattern_specs/TupleWithRecord | 0 .../pattern_specs/TupleWithRecord.result | 0 .../resources/pre_post_specs/ImplicitFunc | 0 .../pre_post_specs/ImplicitFunc.result | 0 .../test/resources/pre_post_specs/ImplicitOp | 0 .../pre_post_specs/ImplicitOp.result | 0 .../PostFailureFuncTuplePattern | 0 .../PostFailureFuncTuplePattern.result | 0 .../pre_post_specs/PostPassFuncTuplePattern | 0 .../PostPassFuncTuplePattern.result | 0 .../pre_post_specs/PostPassNonStaticOp | 0 .../pre_post_specs/PostPassNonStaticOp.result | 0 .../pre_post_specs/PreFailureFuncSimple1 | 0 .../PreFailureFuncSimple1.result | 0 .../pre_post_specs/PreFailureOpTuplePattern | 0 .../PreFailureOpTuplePattern.result | 0 .../pre_post_specs/PrePassFuncSimple1 | 0 .../pre_post_specs/PrePassFuncSimple1.result | 0 .../pre_post_specs/PrePassNonStaticOp | 0 .../pre_post_specs/PrePassNonStaticOp.result | 0 .../pre_post_specs/PrePassOpTuplePattern | 0 .../PrePassOpTuplePattern.result | 0 .../resources/renaming_specs/AssignmentDef | 0 .../renaming_specs/AssignmentDef.result | 0 .../test/resources/renaming_specs/ClassName | 0 .../resources/renaming_specs/ClassName.result | 0 .../test/resources/renaming_specs/FuncName | 0 .../resources/renaming_specs/FuncName.result | 0 .../test/resources/renaming_specs/InstanceVar | 0 .../renaming_specs/InstanceVar.result | 0 .../src/test/resources/renaming_specs/LetExp | 0 .../resources/renaming_specs/LetExp.result | 0 .../src/test/resources/renaming_specs/LetStm | 0 .../resources/renaming_specs/LetStm.result | 0 .../src/test/resources/renaming_specs/OpName | 0 .../resources/renaming_specs/OpName.result | 0 .../renaming_specs/SameNameInDifferentOps | 0 .../SameNameInDifferentOps.result | 0 .../renaming_specs/SamePatchTwoClass | 0 .../renaming_specs/SamePatchTwoClass.result | 0 .../test/resources/renaming_specs/ValueDef | 0 .../resources/renaming_specs/ValueDef.result | 0 .../src/test/resources/rt/AsyncCounterInc | 0 .../test/resources/rt/AsyncCounterInc.result | 0 .../test/resources/specifications/ApplyExp | 0 .../resources/specifications/ApplyExp.result | 0 .../specifications/ApplyExpReturnedString | 0 .../ApplyExpReturnedString.result | 0 .../specifications/AssignmentDefinitionReturn | 0 .../AssignmentDefinitionReturn.result | 0 .../specifications/BlockStmInitialized | 0 .../specifications/BlockStmInitialized.result | 0 .../specifications/BlockStmUninitialized | 0 .../BlockStmUninitialized.result | 0 .../specifications/CallObjectStmReturn | 0 .../specifications/CallObjectStmReturn.result | 0 .../src/test/resources/specifications/CallStm | 0 .../resources/specifications/CallStm.result | 0 .../test/resources/specifications/CallStms | 0 .../resources/specifications/CallStms.result | 0 .../resources/specifications/CallStmsDeadCode | 0 .../specifications/CallStmsDeadCode.result | 0 .../resources/specifications/ClassComparison | 0 .../specifications/ClassComparison.result | 0 .../ConcMechanismsDoNotGenerate | 0 .../ConcMechanismsDoNotGenerate.result | 0 .../specifications/ConstructorDefault | 0 .../specifications/ConstructorDefault.result | 0 .../specifications/ElemsTypeInference | 0 .../specifications/ElemsTypeInference.result | 0 .../test/resources/specifications/Employee | 0 .../resources/specifications/Employee.result | 0 .../test/resources/specifications/ErrorStm | 0 .../resources/specifications/ErrorStm.result | 0 .../resources/specifications/FloorAssignment | 0 .../specifications/FloorAssignment.result | 0 .../resources/specifications/ForAllSeqLoop | 0 .../specifications/ForAllSeqLoop.result | 0 .../resources/specifications/ForAllSetLoop | 0 .../specifications/ForAllSetLoop.result | 0 .../resources/specifications/ForIndexCorner | 0 .../specifications/ForIndexCorner.result | 0 .../test/resources/specifications/ForIndexStm | 0 .../specifications/ForIndexStm.result | 0 .../specifications/ForIndexStmSimple | 0 .../specifications/ForIndexStmSimple.result | 0 .../test/resources/specifications/Functions | 0 .../resources/specifications/Functions.result | 0 .../src/test/resources/specifications/IfExp | 0 .../resources/specifications/IfExp.result | 0 .../test/resources/specifications/InstanceOf | 0 .../specifications/InstanceOf.result | 0 .../test/resources/specifications/LetDefExp | 0 .../resources/specifications/LetDefExp.result | 0 .../resources/specifications/MapApplyClone | 0 .../specifications/MapApplyClone.result | 0 .../specifications/MapComparisonClone | 0 .../specifications/MapComparisonClone.result | 0 .../test/resources/specifications/MapDomClone | 0 .../specifications/MapDomClone.result | 0 .../resources/specifications/MapDomResByClone | 0 .../specifications/MapDomResByClone.result | 0 .../resources/specifications/MapDomResToClone | 0 .../specifications/MapDomResToClone.result | 0 .../resources/specifications/MapInverseClone | 0 .../specifications/MapInverseClone.result | 0 .../resources/specifications/MapMapUnionClone | 0 .../specifications/MapMapUnionClone.result | 0 .../resources/specifications/MapMergeClone | 0 .../specifications/MapMergeClone.result | 0 .../resources/specifications/MapOverrideClone | 0 .../specifications/MapOverrideClone.result | 0 .../resources/specifications/MapPhoneBook | 0 .../specifications/MapPhoneBook.result | 0 .../resources/specifications/MapRangeClone | 0 .../specifications/MapRangeClone.result | 0 .../specifications/MapRangeResByClone | 0 .../specifications/MapRangeResByClone.result | 0 .../specifications/MapRangeResToClone | 0 .../specifications/MapRangeResToClone.result | 0 .../src/test/resources/specifications/MathLib | 0 .../resources/specifications/MathLib.result | 0 .../specifications/NameViolationClassName | 0 .../NameViolationClassName.result | 0 .../specifications/NameViolationsJavakeyword | 0 .../NameViolationsJavakeyword.result | 0 .../specifications/NamedInvariantType | 0 .../specifications/NamedInvariantType.result | 0 .../resources/specifications/NotYetSpecified | 0 .../specifications/NotYetSpecified.result | 0 .../specifications/ObjectDesignatorField | 0 .../ObjectDesignatorField.result | 0 .../specifications/ObjectDesignatorIdentifier | 0 .../ObjectDesignatorIdentifier.result | 0 .../specifications/ObjectDesignatorNew | 0 .../specifications/ObjectDesignatorNew.result | 0 .../specifications/ObjectDesignatorSelf | 0 .../ObjectDesignatorSelf.result | 0 .../specifications/OperationReturnsValueType | 0 .../OperationReturnsValueType.result | 0 .../resources/specifications/OptionalType | 0 .../specifications/OptionalType.result | 0 .../resources/specifications/RecordComparison | 0 .../specifications/RecordComparison.result | 0 .../resources/specifications/RecordCreation | 0 .../specifications/RecordCreation.result | 0 .../test/resources/specifications/RecordCycle | 0 .../specifications/RecordCycle.result | 0 .../test/resources/specifications/RecordDecls | 0 .../specifications/RecordDecls.result | 0 .../resources/specifications/RecordNesting | 0 .../specifications/RecordNesting.result | 0 .../specifications/RecordPrimitiveFields | 0 .../RecordPrimitiveFields.result | 0 .../test/resources/specifications/RecordUsage | 0 .../specifications/RecordUsage.result | 0 .../specifications/RecordUsageAcrossClass | 0 .../RecordUsageAcrossClass.result | 0 .../test/resources/specifications/ReturnVoid | 0 .../specifications/ReturnVoid.result | 0 .../specifications/SeqDistConcOpResult | 0 .../specifications/SeqDistConcOpResult.result | 0 .../SeqDistConcatOperationCalls | 0 .../SeqDistConcatOperationCalls.result | 0 .../resources/specifications/SeqModCloning | 0 .../specifications/SeqModCloning.result | 0 .../test/resources/specifications/SeqNoteBook | 0 .../specifications/SeqNoteBook.result | 0 .../specifications/SeqReverseBasicTypes | 0 .../SeqReverseBasicTypes.result | 0 .../src/test/resources/specifications/SetBag | 0 .../resources/specifications/SetBag.result | 0 .../resources/specifications/SetDiffClone | 0 .../specifications/SetDiffClone.result | 0 .../specifications/SetDistInterClone | 0 .../specifications/SetDistInterClone.result | 0 .../specifications/SetDistUnionClone | 0 .../specifications/SetDistUnionClone.result | 0 .../specifications/SetIntersectClone | 0 .../specifications/SetIntersectClone.result | 0 .../resources/specifications/SetPowerSetClone | 0 .../specifications/SetPowerSetClone.result | 0 .../specifications/SetProperSubsetClone | 0 .../SetProperSubsetClone.result | 0 .../resources/specifications/SetSubsetClone | 0 .../specifications/SetSubsetClone.result | 0 .../resources/specifications/SetUnionCloning | 0 .../specifications/SetUnionCloning.result | 0 .../test/resources/specifications/StringType | 0 .../specifications/StringType.result | 0 .../src/test/resources/specifications/Strings | 0 .../resources/specifications/Strings.result | 0 .../resources/specifications/TemplateTypes | 0 .../specifications/TemplateTypes.result | 0 .../test/resources/specifications/TupleUsage | 0 .../specifications/TupleUsage.result | 0 .../src/test/resources/specifications/Tuples | 0 .../resources/specifications/Tuples.result | 0 .../resources/specifications/UnionOfQuotes | 0 .../specifications/UnionOfQuotes.result | 0 .../resources/specifications/UnknownTypes | 0 .../specifications/UnknownTypes.result | 0 .../UnsupportedModelingConstructs | 0 .../UnsupportedModelingConstructs.result | 0 .../specifications/ValueRefInAcrossClass | 0 .../ValueRefInAcrossClass.result | 0 .../specifications/VariableExpressions | 0 .../specifications/VariableExpressions.result | 0 .../ApplyExpMissingSeqOfCharInOneClass | 0 .../ApplyExpMissingSeqOfCharInOneClass.result | 0 .../test/resources/string_specs/Comparison | 0 .../resources/string_specs/Comparison.result | 0 .../src/test/resources/string_specs/Concat | 0 .../test/resources/string_specs/Concat.result | 0 .../test/resources/string_specs/DistConcat | 0 .../resources/string_specs/DistConcat.result | 0 .../src/test/resources/string_specs/Elems | 0 .../test/resources/string_specs/Elems.result | 0 .../string_specs/EqualsNotEqualsSeqConversion | 0 .../EqualsNotEqualsSeqConversion.result | 0 .../resources/string_specs/EscapedCharacters | 0 .../string_specs/EscapedCharacters.result | 0 .../src/test/resources/string_specs/Head | 0 .../test/resources/string_specs/Head.result | 0 .../src/test/resources/string_specs/Indexing | 0 .../resources/string_specs/Indexing.result | 0 .../src/test/resources/string_specs/Indices | 0 .../resources/string_specs/Indices.result | 0 .../test/resources/string_specs/Modification | 0 .../string_specs/Modification.result | 0 .../src/test/resources/string_specs/Reverse | 0 .../resources/string_specs/Reverse.result | 0 .../test/resources/string_specs/SeqConversion | 0 .../string_specs/SeqConversion.result | 0 .../string_specs/SeqToStrFieldNumberExp | 0 .../SeqToStrFieldNumberExp.result | 0 .../src/test/resources/string_specs/Size | 0 .../test/resources/string_specs/Size.result | 0 .../test/resources/string_specs/StringPattern | 0 .../string_specs/StringPattern.result | 0 .../test/resources/string_specs/SubSeqString1 | 0 .../string_specs/SubSeqString1.result | 0 .../test/resources/string_specs/SubSeqString2 | 0 .../string_specs/SubSeqString2.result | 0 .../test/resources/string_specs/SubSeqString3 | 0 .../string_specs/SubSeqString3.result | 0 .../test/resources/string_specs/SubSeqString4 | 0 .../string_specs/SubSeqString4.result | 0 .../test/resources/string_specs/SubSeqString5 | 0 .../string_specs/SubSeqString5.result | 0 .../test/resources/string_specs/SubSeqString6 | 0 .../string_specs/SubSeqString6.result | 0 .../src/test/resources/string_specs/Tail | 0 .../test/resources/string_specs/Tail.result | 0 .../test/resources/string_specs/Val2SeqOfChar | 0 .../string_specs/Val2SeqOfChar.result | 0 .../traces_expansion_specs/Alternative1 | 0 .../Alternative1.result | 0 .../AlternativeConcurrent1 | 0 .../AlternativeConcurrent1.result | 0 .../traces_expansion_specs/AlternativeRepeat1 | 0 .../AlternativeRepeat1.result | 0 .../traces_expansion_specs/Concurrent1 | 0 .../traces_expansion_specs/Concurrent1.result | 0 .../traces_expansion_specs/Concurrent2 | 0 .../traces_expansion_specs/Concurrent2.result | 0 .../ConcurrentAlternative1 | 0 .../ConcurrentAlternative1.result | 0 .../traces_expansion_specs/ConcurrentRepeat1 | 0 .../ConcurrentRepeat1.result | 0 .../traces_expansion_specs/ConcurrentRepeat2 | 0 .../ConcurrentRepeat2.result | 0 .../ConcurrentWithLetBeSt | 0 .../ConcurrentWithLetBeSt.result | 0 .../resources/traces_expansion_specs/LetBeSt1 | 0 .../traces_expansion_specs/LetBeSt1.result | 0 .../traces_expansion_specs/LetBeStNested | 0 .../LetBeStNested.result | 0 .../traces_expansion_specs/LetBeStRecPattern | 0 .../LetBeStRecPattern.result | 0 .../traces_expansion_specs/LetBeStTupPattern | 0 .../LetBeStTupPattern.result | 0 .../resources/traces_expansion_specs/LetDef1 | 0 .../traces_expansion_specs/LetDef1.result | 0 .../traces_expansion_specs/LetDefConsecutive | 0 .../LetDefConsecutive.result | 0 .../LetDefConsecutiveRepeat | 0 .../LetDefConsecutiveRepeat.result | 0 .../traces_expansion_specs/LetDefTuplePattern | 0 .../LetDefTuplePattern.result | 0 .../traces_expansion_specs/ObjectBind | 0 .../traces_expansion_specs/ObjectBind.result | 0 .../OpCallsUsedToInitLocalDefs | 0 .../OpCallsUsedToInitLocalDefs.result | 0 .../resources/traces_expansion_specs/Repeat1 | 0 .../traces_expansion_specs/Repeat1.result | 0 .../traces_expansion_specs/RepeatAlternative1 | 0 .../RepeatAlternative1.result | 0 .../traces_expansion_specs/RepeatConcurrent1 | 0 .../RepeatConcurrent1.result | 0 .../traces_expansion_specs/SharedObjectBind | 0 .../SharedObjectBind.result | 0 .../traces_expansion_specs/SingleStatement1 | 0 .../SingleStatement1.result | 0 .../resources/traces_verdict_specs/DivByZero | 0 .../traces_verdict_specs/DivByZero.result | 0 .../resources/traces_verdict_specs/Filter | 0 .../traces_verdict_specs/Filter.result | 0 .../traces_verdict_specs/LetBeStNoBinding | 0 .../LetBeStNoBinding.result | 0 .../traces_verdict_specs/MapNoSuchKey | 0 .../traces_verdict_specs/MapNoSuchKey.result | 0 .../traces_verdict_specs/NilRefError | 0 .../traces_verdict_specs/NilRefError.result | 0 .../traces_verdict_specs/PreCondViolation | 0 .../PreCondViolation.result | 0 .../traces_verdict_specs/SameTestTwice | 0 .../traces_verdict_specs/SameTestTwice.result | 0 .../traces_verdict_specs/SeqIndexOutOfRange | 0 .../SeqIndexOutOfRange.result | 0 .../traces_verdict_specs/UnionTypeFailure | 0 .../UnionTypeFailure.result | 0 .../union_type_specs/ApplyExpInElseIfStm | 0 .../ApplyExpInElseIfStm.result | 0 .../union_type_specs/ApplyExpMethodTypeRoot | 0 .../ApplyExpMethodTypeRoot.result | 0 .../ApplyExpMissingFunInOneClass | 0 .../ApplyExpMissingFunInOneClass.result | 0 .../ApplyExpMissingMapInOneClass | 0 .../ApplyExpMissingMapInOneClass.result | 0 .../ApplyExpMissingSeqInOneClass | 0 .../ApplyExpMissingSeqInOneClass.result | 0 .../ApplyExpMissingSeqOfCharInOneClass | 0 .../ApplyExpMissingSeqOfCharInOneClass.result | 0 .../resources/union_type_specs/ApplyExpNested | 0 .../union_type_specs/ApplyExpNested.result | 0 .../CallObjStmInheritedOpProtected | 0 .../CallObjStmInheritedOpProtected.result | 0 .../CallObjStmInheritedOpPublic | 0 .../CallObjStmInheritedOpPublic.result | 0 .../CallObjStmMissingOpInOneClass | 0 .../CallObjStmMissingOpInOneClass.result | 0 .../union_type_specs/CallObjStmNoArgs | 0 .../union_type_specs/CallObjStmNoArgs.result | 0 .../union_type_specs/CallObjStmNoArgsInLoop | 0 .../CallObjStmNoArgsInLoop.result | 0 .../union_type_specs/CallObjStmWithArguments | 0 .../CallObjStmWithArguments.result | 0 .../union_type_specs/CallStmInheritedOp | 0 .../CallStmInheritedOp.result | 0 .../resources/union_type_specs/CallStmLocalOp | 0 .../union_type_specs/CallStmLocalOp.result | 0 .../src/test/resources/union_type_specs/Card | 0 .../resources/union_type_specs/Card.result | 0 .../union_type_specs/FieldExpArgToOpCall | 0 .../FieldExpArgToOpCall.result | 0 .../union_type_specs/FieldExpInReturnStm | 0 .../FieldExpInReturnStm.result | 0 .../union_type_specs/FieldExpMissingRecField | 0 .../FieldExpMissingRecField.result | 0 .../FieldExpNotRootOfApplyExp | 0 .../FieldExpNotRootOfApplyExp.result | 0 .../union_type_specs/FieldExpOfRecord | 0 .../union_type_specs/FieldExpOfRecord.result | 0 .../FieldExpOfRecordArgToApplyExp | 0 .../FieldExpOfRecordArgToApplyExp.result | 0 .../union_type_specs/FieldExpSeqApply | 0 .../union_type_specs/FieldExpSeqApply.result | 0 .../FieldExpWithApplyExpParent | 0 .../FieldExpWithApplyExpParent.result | 0 .../FieldExpWithApplyExpParentInIfStm | 0 .../FieldExpWithApplyExpParentInIfStm.result | 0 .../FieldExpWithObjectAsApplyExp | 0 .../FieldExpWithObjectAsApplyExp.result | 0 .../FieldNumberExpArgToApplyExp | 0 .../FieldNumberExpArgToApplyExp.result | 0 .../FieldNumberExpDifferentFieldTyps | 0 .../FieldNumberExpDifferentFieldTyps.result | 0 .../FieldNumberExpUnknownType | 0 .../FieldNumberExpUnknownType.result | 0 .../src/test/resources/union_type_specs/IfStm | 0 .../resources/union_type_specs/IfStm.result | 0 .../src/test/resources/union_type_specs/Len | 0 .../resources/union_type_specs/Len.result | 0 .../resources/union_type_specs/LetBeStRecElem | 0 .../union_type_specs/LetBeStRecElem.result | 0 .../test/resources/union_type_specs/MapApply | 0 .../union_type_specs/MapApply.result | 0 .../union_type_specs/MapCompUnionOfMapTypes | 0 .../MapCompUnionOfMapTypes.result | 0 .../resources/union_type_specs/NewExpClass | 0 .../union_type_specs/NewExpClass.result | 0 .../resources/union_type_specs/NewExpRecord | 0 .../union_type_specs/NewExpRecord.result | 0 .../test/resources/union_type_specs/NotExp | 0 .../resources/union_type_specs/NotExp.result | 0 .../resources/union_type_specs/NumericPlus | 0 .../union_type_specs/NumericPlus.result | 0 .../test/resources/union_type_specs/ReturnStm | 0 .../union_type_specs/ReturnStm.result | 0 .../test/resources/union_type_specs/SeqApply | 0 .../union_type_specs/SeqApply.result | 0 .../union_type_specs/SeqCompUnionOfSeqTypes | 0 .../SeqCompUnionOfSeqTypes.result | 0 .../test/resources/union_type_specs/SeqConc | 0 .../resources/union_type_specs/SeqConc.result | 0 .../union_type_specs/SetCompUnionOfSetTypes | 0 .../SetCompUnionOfSetTypes.result | 0 .../resources/union_type_specs/UnionOfQuotes | 0 .../union_type_specs/UnionOfQuotes.result | 0 .../union_type_specs/UnknownTypeInUnionType | 0 .../UnknownTypeInUnionType.result | 0 .../var_shadowing_specs/CasesExpTuplePattern | 0 .../var_shadowing_specs/CasesStmTuplePattern | 0 .../test/resources/var_shadowing_specs/DefExp | 0 .../ExistsTwoMultipleSetBinds | 0 .../ForAllExpTwoMultipleBinds | 0 .../ForAllExpTwoMultipleTypeBindsOneName | 0 .../ForAllExpTwoMultipleTypeBindsTwoNames | 0 .../var_shadowing_specs/ForAllStmTuplePattern | 0 .../var_shadowing_specs/ForIndexLoopVar | 0 .../var_shadowing_specs/ForPatternBindTuple | 0 .../var_shadowing_specs/GenUniqueNameLetStm | 0 .../var_shadowing_specs/IdShadowingVarExp | 0 .../IdStateDesignatorNestedBlocks | 0 .../IdStateDesignatorSingleBlock | 0 .../resources/var_shadowing_specs/LambdaInLet | 0 .../resources/var_shadowing_specs/LambdaParam | 0 .../var_shadowing_specs/LetBeStExpNested | 0 .../var_shadowing_specs/LetBeStStmCond | 0 .../LetBeStStmMultipleSetBind | 0 .../LetBeStStmMultipleTypeBind | 0 .../var_shadowing_specs/LetBeStTrace | 0 .../LetBeStTraceMultipleTypeBind | 0 .../LetStmCrossClassDependency | 0 .../LetStmHidingAtSameScopeLevel | 0 .../var_shadowing_specs/LetStmNested | 0 .../var_shadowing_specs/LetStmTuplePatterns | 0 .../LetStmVarHiddenMultipleTimes | 0 .../var_shadowing_specs/LetVarHidesFuncParam | 0 .../var_shadowing_specs/LetVarHidesOpParam | 0 .../MapCompTwoMultipleSetBinds | 0 .../SetCompTwoMultipleSetBinds | 0 .../var_shadowing_specs/StmBlockSimple | 0 .../var_shadowing_specs/TixeStmTuplePattern | 0 .../var_shadowing_specs/TrapStmTuplePattern | 0 .../TuplePatternIdsShadowing | 0 1713 files changed, 92 insertions(+), 92 deletions(-) rename core/{ => codegen}/cgisa/pom.xml (100%) rename core/{ => codegen}/cgisa/src/main/java/org/overturetool/cgisa/ExtIrGenerator.java (100%) rename core/{ => codegen}/cgisa/src/main/java/org/overturetool/cgisa/IsaChecks.java (100%) rename core/{ => codegen}/cgisa/src/main/java/org/overturetool/cgisa/IsaCodeGen.java (100%) rename core/{ => codegen}/cgisa/src/main/java/org/overturetool/cgisa/IsaTemplateManager.java (100%) rename core/{ => codegen}/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslations.java (100%) rename core/{ => codegen}/cgisa/src/main/java/org/overturetool/cgisa/checkers/IsCharTypeVisitor.java (100%) rename core/{ => codegen}/cgisa/src/main/java/org/overturetool/cgisa/checkers/IsMethodTypeVisitor.java (100%) rename core/{ => codegen}/cgisa/src/main/java/org/overturetool/cgisa/checkers/IsSeqOfCharTypeVisitor.java (100%) rename core/{ => codegen}/cgisa/src/main/java/org/overturetool/cgisa/ir/ExtIrClassDeclStatus.java (100%) rename core/{ => codegen}/cgisa/src/main/java/org/overturetool/cgisa/transformations/ExtendClass.java (100%) rename core/{ => codegen}/cgisa/src/main/java/org/overturetool/cgisa/transformations/GroupMutRecs.java (100%) rename core/{ => codegen}/cgisa/src/main/java/org/overturetool/cgisa/transformations/SortDependencies.java (100%) rename core/{ => codegen}/cgisa/src/main/resources/IsaTemplates/Declarations/Class.vm (100%) rename core/{ => codegen}/cgisa/src/main/resources/IsaTemplates/Declarations/ExtClass.vm (100%) rename core/{ => codegen}/cgisa/src/main/resources/IsaTemplates/Declarations/Field.vm (100%) rename core/{ => codegen}/cgisa/src/main/resources/IsaTemplates/Declarations/Function.vm (100%) rename core/{ => codegen}/cgisa/src/main/resources/IsaTemplates/Declarations/MutRec.vm (100%) rename core/{ => codegen}/cgisa/src/main/resources/IsaTemplates/Expressions/Apply.vm (100%) rename core/{ => codegen}/cgisa/src/main/resources/IsaTemplates/Expressions/Binary/Numeric/Plus.vm (100%) rename core/{ => codegen}/cgisa/src/main/resources/IsaTemplates/Expressions/CharLiteral.vm (100%) rename core/{ => codegen}/cgisa/src/main/resources/IsaTemplates/Expressions/IntLiteral.vm (100%) rename core/{ => codegen}/cgisa/src/main/resources/IsaTemplates/Expressions/Seq/Enum.vm (100%) rename core/{ => codegen}/cgisa/src/main/resources/IsaTemplates/Expressions/Variable.vm (100%) rename core/{ => codegen}/cgisa/src/main/resources/IsaTemplates/LocalDecls/FormalParam.vm (100%) rename core/{ => codegen}/cgisa/src/main/resources/IsaTemplates/Pattern/Identifier.vm (100%) rename core/{ => codegen}/cgisa/src/main/resources/IsaTemplates/Types/Basic/Char.vm (100%) rename core/{ => codegen}/cgisa/src/main/resources/IsaTemplates/Types/Basic/Integer.vm (100%) rename core/{ => codegen}/cgisa/src/main/resources/IsaTemplates/Types/Basic/Nat.vm (100%) rename core/{ => codegen}/cgisa/src/main/resources/IsaTemplates/Types/Basic/Nat1.vm (100%) rename core/{ => codegen}/cgisa/src/main/resources/isacg.ast (100%) rename core/{ => codegen}/cgisa/src/main/resources/isacg.ast.tostring (100%) rename core/{ => codegen}/cgisa/src/test/java/org/overturetool/cgisa/AdHoc.java (100%) rename core/{ => codegen}/cgisa/src/test/java/org/overturetool/cgisa/CgIsaParamTest.java (100%) rename core/{ => codegen}/cgisa/src/test/java/org/overturetool/cgisa/CgIsaTestResult.java (100%) rename core/{ => codegen}/cgisa/src/test/resources/micro/Functions/FuncApply1Param.vdmpp (100%) rename core/{ => codegen}/cgisa/src/test/resources/micro/Functions/FuncApply1Param.vdmpp.result (100%) rename core/{ => codegen}/cgisa/src/test/resources/micro/Functions/FuncApply3Params.vdmpp (100%) rename core/{ => codegen}/cgisa/src/test/resources/micro/Functions/FuncApply3Params.vdmpp.result (100%) rename core/{ => codegen}/cgisa/src/test/resources/micro/Functions/FuncApplyNoParam.vdmpp (100%) rename core/{ => codegen}/cgisa/src/test/resources/micro/Functions/FuncApplyNoParam.vdmpp.result (100%) rename core/{ => codegen}/cgisa/src/test/resources/micro/Functions/FuncDecl1Param.vdmpp (100%) rename core/{ => codegen}/cgisa/src/test/resources/micro/Functions/FuncDecl1Param.vdmpp.result (100%) rename core/{ => codegen}/cgisa/src/test/resources/micro/Functions/FuncDecl2Params.vdmpp (100%) rename core/{ => codegen}/cgisa/src/test/resources/micro/Functions/FuncDecl2Params.vdmpp.result (100%) rename core/{ => codegen}/cgisa/src/test/resources/micro/Functions/FuncDeclNoParam.vdmpp (100%) rename core/{ => codegen}/cgisa/src/test/resources/micro/Functions/FuncDeclNoParam.vdmpp.result (100%) rename core/{ => codegen}/cgisa/src/test/resources/micro/Functions/FuncDepSimple.vdmpp (100%) rename core/{ => codegen}/cgisa/src/test/resources/micro/Functions/FuncDepSimple.vdmpp.result (100%) rename core/{ => codegen}/cgisa/src/test/resources/micro/Values/IntExp.vdmpp (100%) rename core/{ => codegen}/cgisa/src/test/resources/micro/Values/IntExp.vdmpp.result (100%) rename core/{ => codegen}/cgisa/src/test/resources/micro/Values/IntExpVarExp.vdmpp (100%) rename core/{ => codegen}/cgisa/src/test/resources/micro/Values/IntExpVarExp.vdmpp.result (100%) rename core/{ => codegen}/cgisa/src/test/resources/micro/Values/SeqEnumApply.vdmpp (100%) rename core/{ => codegen}/cgisa/src/test/resources/micro/Values/SeqEnumApply.vdmpp.result (100%) rename core/{ => codegen}/cgisa/src/test/resources/micro/Values/StringApply.vdmpp (100%) rename core/{ => codegen}/cgisa/src/test/resources/micro/Values/StringApply.vdmpp.result (100%) rename core/{ => codegen}/cgisa/src/test/resources/test.vdmpp (100%) rename core/{codegen-plugin => codegen/codegen-maven-plugin}/pom.xml (100%) rename core/{codegen-plugin => codegen/codegen-maven-plugin}/src/main/java/org/overture/tools/maven/astcreator/AstCreatorBaseMojo.java (100%) rename core/{codegen-plugin => codegen/codegen-maven-plugin}/src/main/java/org/overture/tools/maven/astcreator/GenerateJavaSources.java (100%) rename core/{codegen-plugin => codegen/codegen-maven-plugin}/src/main/java/org/overture/tools/maven/astcreator/VdmppNameFilter.java (100%) rename core/{ => codegen}/codegen-runtime/README.md (100%) rename core/{ => codegen}/codegen-runtime/pom.xml (100%) rename core/{ => codegen}/codegen-runtime/src/main/java/org/overture/codegen/runtime/EvaluatePP.java (100%) rename core/{ => codegen}/codegen-runtime/src/main/java/org/overture/codegen/runtime/IO.java (100%) rename core/{ => codegen}/codegen-runtime/src/main/java/org/overture/codegen/runtime/MATH.java (100%) rename core/{ => codegen}/codegen-runtime/src/main/java/org/overture/codegen/runtime/MapUtil.java (100%) rename core/{ => codegen}/codegen-runtime/src/main/java/org/overture/codegen/runtime/Maplet.java (100%) rename core/{ => codegen}/codegen-runtime/src/main/java/org/overture/codegen/runtime/Record.java (100%) rename core/{ => codegen}/codegen-runtime/src/main/java/org/overture/codegen/runtime/Sentinel.java (100%) rename core/{ => codegen}/codegen-runtime/src/main/java/org/overture/codegen/runtime/SeqUtil.java (100%) rename core/{ => codegen}/codegen-runtime/src/main/java/org/overture/codegen/runtime/SetUtil.java (100%) rename core/{ => codegen}/codegen-runtime/src/main/java/org/overture/codegen/runtime/StaticOperationsCounters.java (100%) rename core/{ => codegen}/codegen-runtime/src/main/java/org/overture/codegen/runtime/StaticSentinel.java (100%) rename core/{ => codegen}/codegen-runtime/src/main/java/org/overture/codegen/runtime/Token.java (100%) rename core/{ => codegen}/codegen-runtime/src/main/java/org/overture/codegen/runtime/Tuple.java (100%) rename core/{ => codegen}/codegen-runtime/src/main/java/org/overture/codegen/runtime/Utils.java (100%) rename core/{ => codegen}/codegen-runtime/src/main/java/org/overture/codegen/runtime/VDMMap.java (100%) rename core/{ => codegen}/codegen-runtime/src/main/java/org/overture/codegen/runtime/VDMSeq.java (100%) rename core/{ => codegen}/codegen-runtime/src/main/java/org/overture/codegen/runtime/VDMSet.java (100%) rename core/{ => codegen}/codegen-runtime/src/main/java/org/overture/codegen/runtime/VDMThread.java (100%) rename core/{ => codegen}/codegen-runtime/src/main/java/org/overture/codegen/runtime/VDMUtil.java (100%) rename core/{ => codegen}/codegen-runtime/src/main/java/org/overture/codegen/runtime/ValueType.java (100%) rename core/{ => codegen}/codegen-runtime/src/test/java/IOTest.java (100%) rename core/codegen/{ => javagen}/pom.xml (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/analysis/vdm/AbstractAnalysis.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/analysis/vdm/DefinitionInfo.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/analysis/vdm/IdDesignatorOccurencesCollector.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/analysis/vdm/IdOccurencesCollector.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/analysis/vdm/IdStateDesignatorDefCollector.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/analysis/vdm/JavaIdentifierNormaliser.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/analysis/vdm/NameCollector.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/analysis/vdm/QuoteAnalysis.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/analysis/vdm/RenameAnalysis.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/analysis/vdm/Renaming.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/analysis/vdm/UnreachableStmRemover.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/analysis/vdm/UtilAnalysis.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/analysis/vdm/VarOccurencesCollector.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/analysis/vdm/VarRenamer.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/analysis/vdm/VarShadowingRenameCollector.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/analysis/vdm/VdmAnalysis.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/analysis/violations/GeneratedVarComparison.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/analysis/violations/InvalidNamesResult.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/analysis/violations/ModelingViolationAnalysis.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/analysis/violations/NameViolationAnalysis.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/analysis/violations/NamingComparison.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/analysis/violations/ReservedWordsComparison.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/analysis/violations/TypenameComparison.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/analysis/violations/UnsupportedModelingException.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/analysis/violations/VdmAstAnalysis.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/analysis/violations/Violation.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/analysis/violations/ViolationAnalysis.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/assistant/AssistantBase.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/assistant/AssistantManager.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/assistant/BindAssistantCG.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/assistant/CollectionTypeStrategy.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/assistant/DeclAssistantCG.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/assistant/DeclStrategy.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/assistant/ExpAssistantCG.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/assistant/LocationAssistantCG.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/assistant/StmAssistantCG.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/assistant/TypeAssistantCG.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/ir/CodeGenBase.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/ir/IRAnalysis.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/ir/IRClassDeclStatus.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/ir/IRConstants.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/ir/IRExpStatus.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/ir/IRGeneratedTag.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/ir/IRGenerator.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/ir/IRInfo.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/ir/IRNamedTypeInvariantTag.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/ir/IROperatorInfo.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/ir/IROperatorLookup.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/ir/IRSettings.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/ir/IRStatus.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/ir/ITempVarGen.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/ir/IrNodeInfo.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/ir/SourceNode.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/ir/TempVarNameGen.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/ir/VdmNodeInfo.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/logging/DefaultLogger.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/logging/ILogger.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/logging/Logger.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/merging/MergeContext.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/merging/MergeVisitor.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/merging/TemplateCallable.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/merging/TemplateManager.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/merging/TemplateStructure.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/traces/EnsureLocalObjDesignatorAnalysis.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/traces/ICallStmToStringMethodBuilder.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/traces/IdentifierPatternCollector.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/traces/JavaCallStmToStringBuilder.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/traces/StoreAssistant.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/traces/TermVisitorCG.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/traces/TraceCoreDeclVisitorCG.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/traces/TraceDeclVisitorCG.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/traces/TraceLetBeStStrategy.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/traces/TraceNames.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/traces/TraceNodeData.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/traces/TraceStmsBuilder.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/traces/TraceSupportedAnalysis.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/traces/TracesTransformation.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/traces/VarExpCasting.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/trans/AbstractIterationStrategy.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/trans/AssignStmTransformation.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/trans/CallObjStmTransformation.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/trans/DeclarationTag.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/trans/IIterationStrategy.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/trans/IPostCheckCreator.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/trans/IsExpTransformation.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/trans/PostCheckTransformation.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/trans/PreCheckTransformation.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/trans/PrePostTransformation.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/trans/SeqConversionTransformation.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/trans/TempVarPrefixes.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/trans/TransformationVisitor.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/trans/assistants/BaseTransformationAssistant.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/trans/assistants/TransAssistantCG.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/trans/comp/CompStrategy.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/trans/comp/ComplexCompStrategy.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/trans/comp/MapCompStrategy.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/trans/comp/SeqCompStrategy.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/trans/comp/SetCompStrategy.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/trans/conc/InstanceVarPPEvalTransformation.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/trans/conc/MainClassConcTransformation.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/trans/conc/MutexDeclTransformation.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/trans/conc/SentinelTransformation.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/trans/conv/ObjectDesignatorToExpCG.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/trans/conv/StateDesignatorToExpCG.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/trans/funcvalues/FunctionValueAssistant.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/trans/funcvalues/FunctionValueTransformation.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/trans/iterator/AbstractLanguageIterator.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/trans/iterator/ILanguageIterator.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/trans/iterator/JavaLanguageIterator.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/trans/let/LetBeStStrategy.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/trans/letexps/FuncTransformation.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/trans/letexps/IfExpTransformation.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/trans/patterns/DeclBlockPair.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/trans/patterns/MismatchHandling.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/trans/patterns/PatternBlockData.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/trans/patterns/PatternInfo.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/trans/patterns/PatternMatchConfig.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/trans/patterns/PatternTransformation.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/trans/quantifier/Exists1CounterData.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/trans/quantifier/Exists1QuantifierStrategy.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/trans/quantifier/OrdinaryQuantifier.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/trans/quantifier/OrdinaryQuantifierStrategy.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/trans/quantifier/QuantifierBaseStrategy.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/trans/uniontypes/UnionTypeTransformation.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/utils/AnalysisExceptionCG.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/utils/GeneralCodeGenUtils.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/utils/GeneralUtils.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/utils/Generated.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/utils/GeneratedData.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/utils/GeneratedModule.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/utils/LexNameTokenWrapper.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/vdm2java/IJavaCodeGenConstants.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/vdm2java/JavaClassCreator.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/vdm2java/JavaClassCreatorBase.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/vdm2java/JavaClassToStringTrans.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/vdm2java/JavaCodeGenMain.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/vdm2java/JavaCodeGenUtil.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/vdm2java/JavaFormat.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/vdm2java/JavaFormatAssistant.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/vdm2java/JavaMainTag.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/vdm2java/JavaPostCheckCreator.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/vdm2java/JavaPrecedence.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/vdm2java/JavaQuoteValueCreator.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/vdm2java/JavaRecordCreator.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/vdm2java/JavaSettings.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/vdm2java/JavaTransSeries.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/vdm2java/JavaValueSemantics.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/vdm2java/JavaValueSemanticsTag.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/vdm2java/TemplateCallableManager.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/visitor/AbstractVisitorCG.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/visitor/BindVisitorCG.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/visitor/CGVisitor.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/visitor/CGVisitorRecursiveTypeHandler.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/visitor/ClassVisitorCG.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/visitor/DeclVisitorCG.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/visitor/ExpVisitorCG.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/visitor/ModifierVisitorCG.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/visitor/MultipleBindVisitorCG.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/visitor/ObjectDesignatorVisitorCG.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/visitor/PatternVisitorCG.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/visitor/StateDesignatorVisitorCG.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/visitor/StmVisitorCG.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/visitor/TypeVisitorCG.java (100%) rename core/codegen/{ => javagen}/src/main/java/org/overture/codegen/visitor/VisitorManager.java (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Declarations/CatchClause.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Declarations/Class.vm (96%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Declarations/Field.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Declarations/Interface.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Declarations/LocalVar.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Declarations/Method.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Declarations/Record.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Declarations/Thread.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Declarations/Type.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/AnonymousClass.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Apply.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Binary/AddrEquals.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Binary/AddrNotEquals.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Binary/Bool/And.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Binary/Bool/Or.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Binary/Bool/Xor.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Binary/DomResBy.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Binary/DomResTo.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Binary/Equals.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Binary/InSet.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Binary/MapOverride.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Binary/MapUnion.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Binary/NotEquals.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Divide.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Greater.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/GreaterEqual.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/IntDiv.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Less.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/LessEqual.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Minus.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Mod.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Mul.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Plus.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Power.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Rem.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Binary/RngResBy.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Binary/RngResTo.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Binary/SeqConcat.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Binary/SeqModification.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Binary/SetDifference.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Binary/SetIntersect.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Binary/SetProperSubset.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Binary/SetSubset.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Binary/SetUnion.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/BoolLiteral.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/CharLiteral.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/ExplicitVariable.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/External.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Field.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/FieldNumber.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/HistoryExp.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/InstanceOf.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/IntLiteral.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Is/Bool.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Is/Char.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Is/General.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Is/Int.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Is/Nat.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Is/Nat1.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Is/Rat.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Is/Real.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Is/Token.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Is/Tuple.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Map/Enum.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/MapSeqGet.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Maplet.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/MethodInstantiation.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/MkBasic.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/New.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/NotImplemented.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Null.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/QuoteLiteral.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/RealLiteral.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/RuntimeError/LetBeStNoBinding.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/RuntimeError/MissingMember.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/RuntimeError/PatternMatch.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/RuntimeError/PreCond.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Self.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Seq/Enum.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Set/Enum.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Set/Range.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/StringLiteral.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/SubSeq.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/SuperVariable.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/TernaryIf.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/ThreadId.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Tuple.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/TupleCompatibility.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/TupleSize.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/TypeArg.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Unary/Abs.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Unary/Cast.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Unary/DistConcat.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Unary/DistInter.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Unary/DistMerge.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Unary/DistUnion.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Unary/Elems.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Unary/Floor.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Unary/Head.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Unary/Indices.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Unary/Isolation.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Unary/Len_Card.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Unary/MapDom.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Unary/MapInverse.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Unary/MapRange.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Unary/Minus.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Unary/Not.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Unary/Plus.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Unary/PowerSet.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Unary/Reverse.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Unary/SeqToString.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Unary/StringToSeq.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Unary/Tail.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Undefined.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Expressions/Variable.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/LocalDecls/FormalParam.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Pattern/Identifier.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Statements/Assignment.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Statements/Block.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Statements/Break.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Statements/Call.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Statements/CallObject.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Statements/CallObjectExp.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Statements/Continue.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Statements/Decrement.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Statements/Error.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Statements/ForAll.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Statements/ForIndex.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Statements/ForLoop.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Statements/If.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Statements/Increment.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Statements/LocalAssignment.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Statements/LocalPatternAssignment.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Statements/MapSeqUpdate.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Statements/NotImplemented.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Statements/RaiseError.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Statements/Return.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Statements/Skip.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Statements/Start.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Statements/Startlist.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Statements/SuperCall.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Statements/Throw.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Statements/Try.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Statements/While.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Types/Basic/Bool.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Types/Basic/Char.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Types/Basic/Integer.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Types/Basic/Nat.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Types/Basic/Nat1.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Types/Basic/Rat.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Types/Basic/Real.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Types/Basic/Token.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Types/BasicWrappers/Bool.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Types/BasicWrappers/Char.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Types/BasicWrappers/Integer.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Types/BasicWrappers/Nat.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Types/BasicWrappers/Nat1.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Types/BasicWrappers/Rat.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Types/BasicWrappers/Real.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Types/Class.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Types/External.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Types/Interface.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Types/Map/Map.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Types/Method.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Types/Null.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Types/Object.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Types/Quote.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Types/Record.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Types/Seq/Seq.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Types/Set/Set.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Types/String.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Types/Template.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Types/Tuple.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Types/Union.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Types/Unknown.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/JavaTemplates/Types/Void.vm (100%) rename core/codegen/{ => javagen}/src/main/resources/cg.astv2 (100%) rename core/codegen/{ => javagen}/src/main/resources/cg.astv2.tostring (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/BindTest.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/ClassesToSkipParsingTest.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/ClassicSpecTest.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/ClassicSpecTestCase.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/CodeGenBaseTestCase.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/ComplexExpressionTest.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/ConcurrencyClassicSpecTestCase.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/ConcurrencyClassicSpecTests.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/ConcurrencyTestCase.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/ConcurrencyTests.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/ConfiguredCloningTest.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/ConfiguredCloningTestCase.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/ConfiguredStringGenerationTest.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/ConfiguredStringGenerationTestCase.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/ExpressionTest.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/ExpressionTestCase.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/FunctionValueTest.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/IRTest.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/NameNormalising.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/PackageTest.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/PackageTestCase.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/PatternTest.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/PrePostTest.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/PrePostTestCase.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/RtTest.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/RtTestCase.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/SpecificationTest.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/SpecificationTestCase.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/TestFlags.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/TracesExpansionTest.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/TracesExpansionTestCase.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/TracesVerdictTest.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/TracesVerdictTestCase.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/UnionTypeTest.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/UtilsTest.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/VarShadowingTest.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/VarShadowingTestCase.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/utils/ComparisonCG.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/utils/CompileTests.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/utils/EntryBasedTestHandler.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/utils/ExecutableSpecTestHandler.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/utils/ExecutableTestHandler.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/utils/ExecutionResult.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/utils/ExpressionTestHandler.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/utils/FileComparator.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/utils/JavaCommandLineCompiler.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/utils/JavaExecution.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/utils/JavaToolsUtils.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/utils/NonExecutableSpecTestHandler.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/utils/TestHandler.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/utils/TestUtils.java (100%) rename core/codegen/{ => javagen}/src/test/java/org/overture/codegen/tests/utils/TraceHandler.java (100%) rename core/codegen/{ => javagen}/src/test/resources/bind_specs/Exists1QuantifierWithTuplePattern (100%) rename core/codegen/{ => javagen}/src/test/resources/bind_specs/Exists1QuantifierWithTuplePattern.result (100%) rename core/codegen/{ => javagen}/src/test/resources/bind_specs/ExistsQuantifierWithTuplePattern (100%) rename core/codegen/{ => javagen}/src/test/resources/bind_specs/ExistsQuantifierWithTuplePattern.result (100%) rename core/codegen/{ => javagen}/src/test/resources/bind_specs/ForAllQuantifierWithTuplePattern (100%) rename core/codegen/{ => javagen}/src/test/resources/bind_specs/ForAllQuantifierWithTuplePattern.result (100%) rename core/codegen/{ => javagen}/src/test/resources/bind_specs/LetBeStExpMultipleBindWithTuplePattern (100%) rename core/codegen/{ => javagen}/src/test/resources/bind_specs/LetBeStExpMultipleBindWithTuplePattern.result (100%) rename core/codegen/{ => javagen}/src/test/resources/bind_specs/LetBeStExpWithTuplePattern (100%) rename core/codegen/{ => javagen}/src/test/resources/bind_specs/LetBeStExpWithTuplePattern.result (100%) rename core/codegen/{ => javagen}/src/test/resources/bind_specs/LetBeStStmWithRecPattern (100%) rename core/codegen/{ => javagen}/src/test/resources/bind_specs/LetBeStStmWithRecPattern.result (100%) rename core/codegen/{ => javagen}/src/test/resources/bind_specs/MapCompWithTuplePattern (100%) rename core/codegen/{ => javagen}/src/test/resources/bind_specs/MapCompWithTuplePattern.result (100%) rename core/codegen/{ => javagen}/src/test/resources/bind_specs/SeqCompWithTuplePattern (100%) rename core/codegen/{ => javagen}/src/test/resources/bind_specs/SeqCompWithTuplePattern.result (100%) rename core/codegen/{ => javagen}/src/test/resources/bind_specs/SetCompMultipleSetBindWithTuplePatterns (100%) rename core/codegen/{ => javagen}/src/test/resources/bind_specs/SetCompMultipleSetBindWithTuplePatterns.result (100%) rename core/codegen/{ => javagen}/src/test/resources/bind_specs/SetCompWithIntPattern (100%) rename core/codegen/{ => javagen}/src/test/resources/bind_specs/SetCompWithIntPattern.result (100%) rename core/codegen/{ => javagen}/src/test/resources/bind_specs/SetCompWithTuplePattern (100%) rename core/codegen/{ => javagen}/src/test/resources/bind_specs/SetCompWithTuplePattern.result (100%) rename core/codegen/{ => javagen}/src/test/resources/classic_specs/AlarmTraces (100%) rename core/codegen/{ => javagen}/src/test/resources/classic_specs/AlarmTraces.result (100%) rename core/codegen/{ => javagen}/src/test/resources/classic_specs/CashDispenserPP (100%) rename core/codegen/{ => javagen}/src/test/resources/classic_specs/CashDispenserPP.result (100%) rename core/codegen/{ => javagen}/src/test/resources/cloning_specs/AlarmTraces (100%) rename core/codegen/{ => javagen}/src/test/resources/cloning_specs/AlarmTraces.result (100%) rename core/codegen/{ => javagen}/src/test/resources/cloning_specs/CashDispenserPP (100%) rename core/codegen/{ => javagen}/src/test/resources/cloning_specs/CashDispenserPP.result (100%) rename core/codegen/{ => javagen}/src/test/resources/cloning_specs/TupleUsage (100%) rename core/codegen/{ => javagen}/src/test/resources/cloning_specs/TupleUsage.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/AbsNumberDereference (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/AbsNumberDereference.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/AndExpAndChainInForAll (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/AndExpAndChainInForAll.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/AndExpChain (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/AndExpChain.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/AndExpEvalOrder (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/AndExpEvalOrder.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/AndExpForAllExps (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/AndExpForAllExps.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ApplyObjectDesignatorClone (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ApplyObjectDesignatorClone.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ApplyObjectDesignatorField (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ApplyObjectDesignatorField.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ApplyObjectDesignatorMapLookup (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ApplyObjectDesignatorMapLookup.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ApplyObjectDesignatorMapType (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ApplyObjectDesignatorMapType.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ApplyObjectDesignatorNoClone (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ApplyObjectDesignatorNoClone.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ApplyObjectDesignatorWithRecFieldObj1 (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ApplyObjectDesignatorWithRecFieldObj1.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ApplyObjectDesignatorWithRecFieldObj2 (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ApplyObjectDesignatorWithRecFieldObj2.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/AtomicStm (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/AtomicStm.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/BlockStmScoping (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/BlockStmScoping.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/CallStmInherited (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/CallStmInherited.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/DeadCodeNestedBlocks (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/DeadCodeNestedBlocks.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/DeflattenBlockStm (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/DeflattenBlockStm.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/DeflattenLetBeStStm (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/DeflattenLetBeStStm.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/DeflattenLetDefExp (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/DeflattenLetDefExp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ElseIfWithSetComp (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ElseIfWithSetComp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/EmptyRecords (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/EmptyRecords.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/EqualsDef (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/EqualsDef.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/EqualsOptionalType (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/EqualsOptionalType.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/Exist1ExpTransformedCond (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/Exist1ExpTransformedCond.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ExistExpTransformedCond (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ExistExpTransformedCond.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/Exists1ExpBindRemoved (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/Exists1ExpBindRemoved.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/Exists1ExpBlockStm (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/Exists1ExpBlockStm.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/Exists1ExpInIfExp (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/Exists1ExpInIfExp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/Exists1ExpInLet (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/Exists1ExpInLet.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/Exists1ExpReturned (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/Exists1ExpReturned.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ExistsExpBlockStm (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ExistsExpBlockStm.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ExistsExpInIfExp (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ExistsExpInIfExp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ExistsExpInLet (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ExistsExpInLet.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ExistsExpReturned (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ExistsExpReturned.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ExistsExpSeveralMultipleSetBindsCond1 (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ExistsExpSeveralMultipleSetBindsCond1.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ExistsRemoveAllMultipleSetBinds (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ExistsRemoveAllMultipleSetBinds.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ExistsRemoveOneOfTwoMultipleSetBinds (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ExistsRemoveOneOfTwoMultipleSetBinds.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ExplicitNameCallStm (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ExplicitNameCallStm.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ExplicitNameVarExp (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ExplicitNameVarExp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/FieldDesignatorOfRecObj (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/FieldDesignatorOfRecObj.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/FieldDesignatorOfRecObjChainOfThree (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/FieldDesignatorOfRecObjChainOfThree.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/FieldDesignatorOfRecObjChainOfTwo (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/FieldDesignatorOfRecObjChainOfTwo.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ForAllExpBlockStm (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ForAllExpBlockStm.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ForAllExpInIfExp (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ForAllExpInIfExp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ForAllExpInLet (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ForAllExpInLet.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ForAllExpReturned (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ForAllExpReturned.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ForAllExpSeveralMultipleSetBindsCond1 (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ForAllExpSeveralMultipleSetBindsCond1.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ForAllExpTransformedCond (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ForAllExpTransformedCond.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ForAllRemoveAllMultipleSetBinds (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ForAllRemoveAllMultipleSetBinds.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ForAllRemoveOneOfTwoMultipleSetBinds (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/ForAllRemoveOneOfTwoMultipleSetBinds.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/HdExpNumberDeref (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/HdExpNumberDeref.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/IfExpAndExpBranch (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/IfExpAndExpBranch.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/InheritedFieldAccess (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/InheritedFieldAccess.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/InheritedFuncInvoke (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/InheritedFuncInvoke.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/IsExp (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/IsExp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/IsExpNamedTypeInvariantRecursiveTypes (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/IsExpNamedTypeInvariantRecursiveTypes.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/IsExpNamedTypeInvariantUnionOfQuotes (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/IsExpNamedTypeInvariantUnionOfQuotes.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/IsExpNatUnionBool (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/IsExpNatUnionBool.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/IsExpQuoteType (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/IsExpQuoteType.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/LetBeExpWithLetExp (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/LetBeExpWithLetExp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/LetBeStExpInBlock (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/LetBeStExpInBlock.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/LetBeStExpInFuncWithCond (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/LetBeStExpInFuncWithCond.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/LetBeStExpInLetDef (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/LetBeStExpInLetDef.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/LetBeStExpInReturnWithCond (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/LetBeStExpInReturnWithCond.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/LetBeStExpRemoveSet (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/LetBeStExpRemoveSet.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/LetBeStExpSetSum (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/LetBeStExpSetSum.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/LetBeStExpSimpleNoCond (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/LetBeStExpSimpleNoCond.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/LetBeStExpTransformedCond (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/LetBeStExpTransformedCond.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/LetBeStNoCondSetSum (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/LetBeStNoCondSetSum.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/LetBeStRemoveSet (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/LetBeStRemoveSet.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/LetBeStThreeBindsCond (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/LetBeStThreeBindsCond.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/LetBeStThreeBindsNoCond (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/LetBeStThreeBindsNoCond.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/LetBeStTransformedCond (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/LetBeStTransformedCond.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/LetBeStWithCond (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/LetBeStWithCond.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/MapCompBlockStm (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/MapCompBlockStm.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/MapCompInLet (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/MapCompInLet.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/MapCompInOpCallInLoop (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/MapCompInOpCallInLoop.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/MapCompRemoveAllMultipleSetBinds (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/MapCompRemoveAllMultipleSetBinds.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/MapCompRemoveOneOfTwoMultipleSetBinds (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/MapCompRemoveOneOfTwoMultipleSetBinds.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/MapCompReturnThreePatternsCond (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/MapCompReturnThreePatternsCond.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/MapCompReturned (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/MapCompReturned.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/MapCompSeveralMultipleSetBindsCond1 (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/MapCompSeveralMultipleSetBindsCond1.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/MapCompSeveralMultipleSetBindsCond2 (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/MapCompSeveralMultipleSetBindsCond2.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/MapCompSeveralMultipleSetBindsCond3 (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/MapCompSeveralMultipleSetBindsCond3.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/MapCompSeveralMultipleSetBindsNoCond (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/MapCompSeveralMultipleSetBindsNoCond.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/MapCompTransformedMaplet (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/MapCompTransformedMaplet.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/MapSeqStateDesignatorChangeRecField (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/MapSeqStateDesignatorChangeRecField.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/MapSeqStateDesignatorMapInMap (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/MapSeqStateDesignatorMapInMap.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/MapSeqStateDesignatorMapSeqToSeq (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/MapSeqStateDesignatorMapSeqToSeq.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/MapSeqStateDesignatorMapUpdate (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/MapSeqStateDesignatorMapUpdate.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/MapSeqStateDesignatorNesting (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/MapSeqStateDesignatorNesting.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/MapSeqStateDesignatorSeqInSeqInSeq (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/MapSeqStateDesignatorSeqInSeqInSeq.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/MapSeqStateDesignatorSeqUpdate (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/MapSeqStateDesignatorSeqUpdate.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/MethodInstantiation (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/MethodInstantiation.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/NotEqualsOptionalType (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/NotEqualsOptionalType.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/OptionalTypedNumberEqual (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/OptionalTypedNumberEqual.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/OptionallyTypedRecordFieldComparison (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/OptionallyTypedRecordFieldComparison.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/OptionallyTypedSetComparison (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/OptionallyTypedSetComparison.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/OptionallyTypedTupleComp (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/OptionallyTypedTupleComp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/OrExpChain (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/OrExpChain.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/OrExpEvalOrder (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/OrExpEvalOrder.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/OrExpExistsExps (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/OrExpExistsExps.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/OrExpOrChainInForAll (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/OrExpOrChainInForAll.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/QuoteLitComparison (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/QuoteLitComparison.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/RecModExpArgToApplyExp (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/RecModExpArgToApplyExp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/RecModExpForAllExp (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/RecModExpForAllExp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/RecModExpInRecModExp (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/RecModExpInRecModExp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/RecModExpSimple1 (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/RecModExpSimple1.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/RecModExpVarExp (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/RecModExpVarExp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/RecordComp (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/RecordComp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/RecordUsageAcrossClass (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/RecordUsageAcrossClass.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/RecordValue (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/RecordValue.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/RecursiveNamedTypeMapApply (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/RecursiveNamedTypeMapApply.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/SeqCompBlockStm (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/SeqCompBlockStm.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/SeqCompInLet (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/SeqCompInLet.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/SeqCompInOpCallInLoop (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/SeqCompInOpCallInLoop.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/SeqCompRemoveEmptySet (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/SeqCompRemoveEmptySet.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/SeqCompReturned (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/SeqCompReturned.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/SeqCompTransformedElement (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/SeqCompTransformedElement.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/SeqConversion (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/SeqConversion.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/SetCompBlockStm (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/SetCompBlockStm.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/SetCompInLet (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/SetCompInLet.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/SetCompInOpCallInLoop (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/SetCompInOpCallInLoop.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/SetCompRemoveAllMultipleSetBinds (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/SetCompRemoveAllMultipleSetBinds.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/SetCompRemoveOneOfTwoMultipleSetBinds (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/SetCompRemoveOneOfTwoMultipleSetBinds.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/SetCompReturnThreePatternsCond (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/SetCompReturnThreePatternsCond.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/SetCompSeveralMultipleSetBindsCond1 (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/SetCompSeveralMultipleSetBindsCond1.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/SetCompSeveralMultipleSetBindsCond2 (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/SetCompSeveralMultipleSetBindsCond2.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/SetCompSeveralMultipleSetBindsCond3 (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/SetCompSeveralMultipleSetBindsCond3.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/SetCompSeveralMultipleSetBindsNoCond (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/SetCompSeveralMultipleSetBindsNoCond.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/SetCompTransformedElement (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/SetCompTransformedElement.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/SuperConstructors (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/SuperConstructors.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/SuperOpCallOfOverwrittenOp (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/SuperOpCallOfOverwrittenOp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/TokenType (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/TokenType.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/UnaryMinusExpArgToFunc (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/UnaryMinusExpArgToFunc.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/UnaryPlusExpArgToFunc (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/UnaryPlusExpArgToFunc.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/WhileStmForAllExpCond (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/WhileStmForAllExpCond.result (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/WhileStmSetSum (100%) rename core/codegen/{ => javagen}/src/test/resources/complex_expressions/WhileStmSetSum.result (100%) rename core/codegen/{ => javagen}/src/test/resources/concurrency/DoubleOperationMutexSharedCounter (100%) rename core/codegen/{ => javagen}/src/test/resources/concurrency/DoubleOperationMutexSharedCounter.result (100%) rename core/codegen/{ => javagen}/src/test/resources/concurrency/DoublePermissionPredSharedCounter (100%) rename core/codegen/{ => javagen}/src/test/resources/concurrency/DoublePermissionPredSharedCounter.result (100%) rename core/codegen/{ => javagen}/src/test/resources/concurrency/FourOperationMutexSharedcounter (100%) rename core/codegen/{ => javagen}/src/test/resources/concurrency/FourOperationMutexSharedcounter.result (100%) rename core/codegen/{ => javagen}/src/test/resources/concurrency/HistoryCounterActSharedResource (100%) rename core/codegen/{ => javagen}/src/test/resources/concurrency/HistoryCounterActSharedResource.result (100%) rename core/codegen/{ => javagen}/src/test/resources/concurrency/HistoryCounterActiveSharedCounter (100%) rename core/codegen/{ => javagen}/src/test/resources/concurrency/HistoryCounterActiveSharedCounter.result (100%) rename core/codegen/{ => javagen}/src/test/resources/concurrency/HistoryCounterFinSharedResource (100%) rename core/codegen/{ => javagen}/src/test/resources/concurrency/HistoryCounterFinSharedResource.result (100%) rename core/codegen/{ => javagen}/src/test/resources/concurrency/HistoryCounterReqSharedResource (100%) rename core/codegen/{ => javagen}/src/test/resources/concurrency/HistoryCounterReqSharedResource.result (100%) rename core/codegen/{ => javagen}/src/test/resources/concurrency/HistoryCounterWaitingSharedCounter (100%) rename core/codegen/{ => javagen}/src/test/resources/concurrency/HistoryCounterWaitingSharedCounter.result (100%) rename core/codegen/{ => javagen}/src/test/resources/concurrency/HistoryCounterandMutexSharedResource (100%) rename core/codegen/{ => javagen}/src/test/resources/concurrency/HistoryCounterandMutexSharedResource.result (100%) rename core/codegen/{ => javagen}/src/test/resources/concurrency/MutexAllSharedCounter (100%) rename core/codegen/{ => javagen}/src/test/resources/concurrency/MutexAllSharedCounter.result (100%) rename core/codegen/{ => javagen}/src/test/resources/concurrency/OverloadedOperation (100%) rename core/codegen/{ => javagen}/src/test/resources/concurrency/OverloadedOperation.result (100%) rename core/codegen/{ => javagen}/src/test/resources/concurrency/ReaderWriterExample (100%) rename core/codegen/{ => javagen}/src/test/resources/concurrency/ReaderWriterExample.result (100%) rename core/codegen/{ => javagen}/src/test/resources/concurrency/SingleLevelInheritance (100%) rename core/codegen/{ => javagen}/src/test/resources/concurrency/SingleLevelInheritance.result (100%) rename core/codegen/{ => javagen}/src/test/resources/concurrency/SingleOperationMutexSharedCounter (100%) rename core/codegen/{ => javagen}/src/test/resources/concurrency/SingleOperationMutexSharedCounter.result (100%) rename core/codegen/{ => javagen}/src/test/resources/concurrency/StartlistdefinitionMutexSynchronized (100%) rename core/codegen/{ => javagen}/src/test/resources/concurrency/StartlistdefinitionMutexSynchronized.result (100%) rename core/codegen/{ => javagen}/src/test/resources/concurrency/ThreadIdSingleThread (91%) rename core/codegen/{ => javagen}/src/test/resources/concurrency/ThreadIdSingleThread.result (100%) rename core/codegen/{ => javagen}/src/test/resources/concurrency/ThreadStart (100%) rename core/codegen/{ => javagen}/src/test/resources/concurrency/ThreadStart.result (100%) rename core/codegen/{ => javagen}/src/test/resources/concurrency_classics_specs/POP3_LogBased_Test1 (100%) rename core/codegen/{ => javagen}/src/test/resources/concurrency_classics_specs/POP3_LogBased_Test1.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/AbsInTuple (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/AbsInTuple.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/AbsOperator (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/AbsOperator.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/AndOfEquivalence (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/AndOfEquivalence.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/AndOperator (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/AndOperator.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/ApplyExpSeqEnum (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/ApplyExpSeqEnum.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/ApplyExpString (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/ApplyExpString.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/BoolLiteralFalse (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/BoolLiteralFalse.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/BoolLiteralTrue (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/BoolLiteralTrue.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/CharLitNewLine (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/CharLitNewLine.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/CharLitSingleQuote (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/CharLitSingleQuote.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/DivOperator (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/DivOperator.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/ElemsSeqOfSeqOfNat1 (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/ElemsSeqOfSeqOfNat1.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/ElemsSeqofNat1 (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/ElemsSeqofNat1.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/EqualsNumeric (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/EqualsNumeric.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/EquivalenceOperator (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/EquivalenceOperator.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/FieldNumberExp (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/FieldNumberExp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/FloorExpression (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/FloorExpression.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/ImplicationOperator (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/ImplicationOperator.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/InverseOfProduct (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/InverseOfProduct.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/InverseOfSum (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/InverseOfSum.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/IsExpBoolFalse (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/IsExpBoolFalse.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/IsExpBoolTrue (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/IsExpBoolTrue.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/IsExpCharFalse (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/IsExpCharFalse.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/IsExpCharTrue (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/IsExpCharTrue.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/IsExpIntFalse (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/IsExpIntFalse.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/IsExpIntTrue (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/IsExpIntTrue.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/IsExpNat1False (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/IsExpNat1False.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/IsExpNat1True (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/IsExpNat1True.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/IsExpNatFalse (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/IsExpNatFalse.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/IsExpNatTrue (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/IsExpNatTrue.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/IsExpRatFalse (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/IsExpRatFalse.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/IsExpRatTrue (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/IsExpRatTrue.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/IsExpTokenFalse (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/IsExpTokenFalse.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/IsExpTokenTrue (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/IsExpTokenTrue.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/MapApplyMapEnumExp (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/MapApplyMapEnumExp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/MapDomEmptyMap (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/MapDomEmptyMap.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/MapDomNatToNatMap (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/MapDomNatToNatMap.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/MapDomResByEmtptySetAndMap (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/MapDomResByEmtptySetAndMap.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/MapDomResByNatToNatMap (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/MapDomResByNatToNatMap.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/MapDomResToEmtptySetAndMap (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/MapDomResToEmtptySetAndMap.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/MapDomResToNatToNatMap (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/MapDomResToNatToNatMap.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/MapEnumExpEmpty (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/MapEnumExpEmpty.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/MapEnumExpMixed (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/MapEnumExpMixed.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/MapEnumExpNats (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/MapEnumExpNats.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/MapInverseNatToNatMap (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/MapInverseNatToNatMap.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/MapMergeEmptyMaps (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/MapMergeEmptyMaps.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/MapMergeNatToNatMaps (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/MapMergeNatToNatMaps.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/MapOverrideEmptyMaps (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/MapOverrideEmptyMaps.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/MapOverrideNatToNatMaps (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/MapOverrideNatToNatMaps.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/MapRangeEmptyMap (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/MapRangeEmptyMap.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/MapRangeNatToNatMap (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/MapRangeNatToNatMap.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/MapRangeResByEmtptySetAndMap (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/MapRangeResByEmtptySetAndMap.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/MapRangeResByNatToNatMap (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/MapRangeResByNatToNatMap.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/MapRangeResToEmtptySetAndMap (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/MapRangeResToEmtptySetAndMap.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/MapRangeResToNatToNatMap (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/MapRangeResToNatToNatMap.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/MapUnionEmptyMaps (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/MapUnionEmptyMaps.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/MapUnionNatToNatMaps (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/MapUnionNatToNatMaps.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/SetEqual (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/SetEqual.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/SetEqualEmpty (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/SetEqualEmpty.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/SetNotEqual (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/SetNotEqual.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/SetNotEqualEmpty (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Maps/SetNotEqualEmpty.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/MkBasicExpEqualsFalse (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/MkBasicExpEqualsFalse.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/MkBasicExpEqualsTrue (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/MkBasicExpEqualsTrue.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/MkBasicExpNotEqualsFalse (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/MkBasicExpNotEqualsFalse.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/MkBasicExpNotEqualsTrue (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/MkBasicExpNotEqualsTrue.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/ModOperator (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/ModOperator.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/NotEqualsNumeric (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/NotEqualsNumeric.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/NotOfImplication (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/NotOfImplication.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/NotOfOr (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/NotOfOr.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/NotOperator (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/NotOperator.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Null (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Null.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/NumericExp (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/NumericExp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/NumericExpOperatorPrecedence (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/NumericExpOperatorPrecedence.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/OrOperator (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/OrOperator.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Power (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Power.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/RealDivideIntegerOperands (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/RealDivideIntegerOperands.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/RealDivideRealOperand (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/RealDivideRealOperand.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/RemOperator (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/RemOperator.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/RemOperatorIsolation (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/RemOperatorIsolation.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/SeqConcatExpStrings (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/SeqConcatExpStrings.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/SeqConcatenationExp (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/SeqConcatenationExp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/SeqDistConcExpEmptySeq (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/SeqDistConcExpEmptySeq.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/SeqDistConcExpEmptySeqs (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/SeqDistConcExpEmptySeqs.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/SeqDistConcExpNoArgs (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/SeqDistConcExpNoArgs.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/SeqDistConcExpOneSeqs (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/SeqDistConcExpOneSeqs.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/SeqDistConcExpThreeSeqs (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/SeqDistConcExpThreeSeqs.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/SeqDistConcStrings (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/SeqDistConcStrings.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/SeqDistConcTuples (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/SeqDistConcTuples.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/SeqElemsExp (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/SeqElemsExp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/SeqEqualsExp (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/SeqEqualsExp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/SeqHdExp (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/SeqHdExp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/SeqHdValueType (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/SeqHdValueType.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/SeqIndexExp (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/SeqIndexExp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/SeqIndexValueTypeExp (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/SeqIndexValueTypeExp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/SeqIndsExp (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/SeqIndsExp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/SeqLenExp (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/SeqLenExp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/SeqModExp (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/SeqModExp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/SeqModExpEmptySeq (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/SeqModExpEmptySeq.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/SeqNotEqualsExp (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/SeqNotEqualsExp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/SeqReverseExp (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/SeqReverseExp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/SeqTlExp (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/SeqTlExp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/StringEqual (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/StringEqual.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/StringNotEqual (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sequences/StringNotEqual.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/SetProperSubsetNatSets (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/SetProperSubsetNatSets.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/SetRangeEmptySet (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/SetRangeEmptySet.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/SetRangeEqualBounds (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/SetRangeEqualBounds.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/SetRangeOneToTen (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/SetRangeOneToTen.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/SetRangeRealBounds (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/SetRangeRealBounds.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sets/SetCardExpEmpty (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sets/SetCardExpEmpty.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sets/SetCardNatSet (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sets/SetCardNatSet.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sets/SetDifferenceNatSets (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sets/SetDifferenceNatSets.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sets/SetDistInterNatSets (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sets/SetDistInterNatSets.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sets/SetDistUnionNatSets (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sets/SetDistUnionNatSets.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sets/SetEnumExpEmpty (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sets/SetEnumExpEmpty.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sets/SetEnumExpNatSet (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sets/SetEnumExpNatSet.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sets/SetEqual (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sets/SetEqual.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sets/SetEqualEmpty (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sets/SetEqualEmpty.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sets/SetInSet (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sets/SetInSet.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sets/SetIntersectNatSets (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sets/SetIntersectNatSets.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sets/SetNotEqual (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sets/SetNotEqual.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sets/SetNotEqualEmpty (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sets/SetNotEqualEmpty.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sets/SetNotInSet (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sets/SetNotInSet.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sets/SetPowerSetEmptySet (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sets/SetPowerSetEmptySet.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sets/SetPowerSetNatSet (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sets/SetPowerSetNatSet.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sets/SetSubsetNatSet (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sets/SetSubsetNatSet.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sets/SetUnionNatSets (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/Sets/SetUnionNatSets.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/StringEscape (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/StringEscape.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/SubSeq1 (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/SubSeq1.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/SubSeq2 (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/SubSeq2.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/SubSeq3 (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/SubSeq3.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/SubSeq4 (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/SubSeq4.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/SubSeq5 (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/SubSeq5.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/SubSeq6 (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/SubSeq6.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/SubtractNumericBinary (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/SubtractNumericBinary.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/TupleEquals (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/TupleEquals.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/TupleNotEquals (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/TupleNotEquals.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/UnaryMinusBinaryExp (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/UnaryMinusBinaryExp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/UnaryMinusOfBinExp (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/UnaryMinusOfBinExp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/UnaryPlusOfBinaryExp (100%) rename core/codegen/{ => javagen}/src/test/resources/expressions/UnaryPlusOfBinaryExp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/function_value_specs/CurriedAdd1 (100%) rename core/codegen/{ => javagen}/src/test/resources/function_value_specs/CurriedAdd1.result (100%) rename core/codegen/{ => javagen}/src/test/resources/function_value_specs/CurriedAdd2 (100%) rename core/codegen/{ => javagen}/src/test/resources/function_value_specs/CurriedAdd2.result (100%) rename core/codegen/{ => javagen}/src/test/resources/function_value_specs/CurriedDifferentParameterTypes (100%) rename core/codegen/{ => javagen}/src/test/resources/function_value_specs/CurriedDifferentParameterTypes.result (100%) rename core/codegen/{ => javagen}/src/test/resources/function_value_specs/FunctionComposeCurried1 (100%) rename core/codegen/{ => javagen}/src/test/resources/function_value_specs/FunctionComposeCurried1.result (100%) rename core/codegen/{ => javagen}/src/test/resources/function_value_specs/FunctionComposeCurried2 (100%) rename core/codegen/{ => javagen}/src/test/resources/function_value_specs/FunctionComposeCurried2.result (100%) rename core/codegen/{ => javagen}/src/test/resources/function_value_specs/FunctionComposeUncurried (100%) rename core/codegen/{ => javagen}/src/test/resources/function_value_specs/FunctionComposeUncurried.result (100%) rename core/codegen/{ => javagen}/src/test/resources/function_value_specs/FunctionReturningFunction (100%) rename core/codegen/{ => javagen}/src/test/resources/function_value_specs/FunctionReturningFunction.result (100%) rename core/codegen/{ => javagen}/src/test/resources/function_value_specs/LambdaCurryAdd (100%) rename core/codegen/{ => javagen}/src/test/resources/function_value_specs/LambdaCurryAdd.result (100%) rename core/codegen/{ => javagen}/src/test/resources/function_value_specs/LambdaInLet (100%) rename core/codegen/{ => javagen}/src/test/resources/function_value_specs/LambdaInLet.result (100%) rename core/codegen/{ => javagen}/src/test/resources/function_value_specs/LambdaReturningSetComp (100%) rename core/codegen/{ => javagen}/src/test/resources/function_value_specs/LambdaReturningSetComp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/function_value_specs/LambdaWithLet (100%) rename core/codegen/{ => javagen}/src/test/resources/function_value_specs/LambdaWithLet.result (100%) rename core/codegen/{ => javagen}/src/test/resources/function_value_specs/MapBoolToNatCurried (100%) rename core/codegen/{ => javagen}/src/test/resources/function_value_specs/MapBoolToNatCurried.result (100%) rename core/codegen/{ => javagen}/src/test/resources/function_value_specs/MapNatCurried (100%) rename core/codegen/{ => javagen}/src/test/resources/function_value_specs/MapNatCurried.result (100%) rename core/codegen/{ => javagen}/src/test/resources/function_value_specs/MapNatToBoolCurried (93%) rename core/codegen/{ => javagen}/src/test/resources/function_value_specs/MapNatToBoolCurried.result (100%) rename core/codegen/{ => javagen}/src/test/resources/function_value_specs/MapNatToChar (100%) rename core/codegen/{ => javagen}/src/test/resources/function_value_specs/MapNatToChar.result (100%) rename core/codegen/{ => javagen}/src/test/resources/function_value_specs/MapUncurried (100%) rename core/codegen/{ => javagen}/src/test/resources/function_value_specs/MapUncurried.result (100%) rename core/codegen/{ => javagen}/src/test/resources/lib/CSV.vdmpp (100%) rename core/codegen/{ => javagen}/src/test/resources/lib/IO.vdmpp (100%) rename core/codegen/{ => javagen}/src/test/resources/lib/MATH.vdmpp (100%) rename core/codegen/{ => javagen}/src/test/resources/lib/VDMUnit.vdmpp (100%) rename core/codegen/{ => javagen}/src/test/resources/lib/VDMUtil.vdmpp (100%) rename core/codegen/{ => javagen}/src/test/resources/package_specs/OneClassUsesQuotes (100%) rename core/codegen/{ => javagen}/src/test/resources/package_specs/OneClassUsesQuotes.result (100%) rename core/codegen/{ => javagen}/src/test/resources/package_specs/RecordUsageAcrossClassSimple (100%) rename core/codegen/{ => javagen}/src/test/resources/package_specs/RecordUsageAcrossClassSimple.result (100%) rename core/codegen/{ => javagen}/src/test/resources/package_specs/TwoClasses (100%) rename core/codegen/{ => javagen}/src/test/resources/package_specs/TwoClasses.result (100%) rename core/codegen/{ => javagen}/src/test/resources/package_specs/UsesRuntimeLib (100%) rename core/codegen/{ => javagen}/src/test/resources/package_specs/UsesRuntimeLib.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/BlockWithInterdependentPatterns (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/BlockWithInterdependentPatterns.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/Bool (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/Bool.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/CasesExpNamedInvariantTypedExp (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/CasesExpNamedInvariantTypedExp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/CasesExpNestingLetExp (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/CasesExpNestingLetExp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/CasesExpOneCaseNoOthers (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/CasesExpOneCaseNoOthers.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/CasesExpRec (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/CasesExpRec.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/CasesExpRecordPatternNamedInvariantUnionTypedExp (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/CasesExpRecordPatternNamedInvariantUnionTypedExp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/CasesExpTuple (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/CasesExpTuple.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/CasesExpUnionTypedConWithSimpleTypes (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/CasesExpUnionTypedConWithSimpleTypes.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/CasesExpUnionTypedCondWithTuples (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/CasesExpUnionTypedCondWithTuples.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/CasesStmBool (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/CasesStmBool.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/CasesStmChar (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/CasesStmChar.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/CasesStmIdentifier (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/CasesStmIdentifier.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/CasesStmIgnore (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/CasesStmIgnore.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/CasesStmInt (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/CasesStmInt.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/CasesStmMultiplePatternsPerAlt (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/CasesStmMultiplePatternsPerAlt.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/CasesStmNamedInvariantTypedExp (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/CasesStmNamedInvariantTypedExp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/CasesStmNil (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/CasesStmNil.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/CasesStmOpCallExp (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/CasesStmOpCallExp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/CasesStmQuote (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/CasesStmQuote.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/CasesStmReal (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/CasesStmReal.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/CasesStmRec (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/CasesStmRec.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/CasesStmRecordPatternNamedInvariantUnionTypedExp (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/CasesStmRecordPatternNamedInvariantUnionTypedExp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/CasesStmString (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/CasesStmString.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/CasesStmTuple (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/CasesStmTuple.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/Char (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/Char.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/ForAllStmIdentifierPattern (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/ForAllStmIdentifierPattern.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/ForAllStmIgnorePattern (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/ForAllStmIgnorePattern.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/ForAllStmIntPattern (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/ForAllStmIntPattern.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/ForAllStmTuplePatternWithIdentifiers (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/ForAllStmTuplePatternWithIdentifiers.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/ForAllStmTuplePatternWithIgnorePattern (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/ForAllStmTuplePatternWithIgnorePattern.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/ForPatternBindIdentifierPattern (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/ForPatternBindIdentifierPattern.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/ForPatternBindIgnorePattern (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/ForPatternBindIgnorePattern.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/ForPatternBindIntPattern (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/ForPatternBindIntPattern.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/ForPatternBindTuplePatternWithIdentifiers (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/ForPatternBindTuplePatternWithIdentifiers.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/ForPatternBindTuplePatternWithIgnorePattern (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/ForPatternBindTuplePatternWithIgnorePattern.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/IgnorePattern (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/IgnorePattern.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/IgnorePatternLastInTuplePattern (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/IgnorePatternLastInTuplePattern.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/Int (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/Int.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/LetBeStRecPattern (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/LetBeStRecPattern.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/LetBeStTuplePattern1 (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/LetBeStTuplePattern1.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/LetBeStTuplePattern2 (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/LetBeStTuplePattern2.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/Nil (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/Nil.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/Quote (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/Quote.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/Real (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/Real.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/RecordLastFieldInt (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/RecordLastFieldInt.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/RecordNoFields (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/RecordNoFields.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/RecordPatternIdentifierPatterns (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/RecordPatternIdentifierPatterns.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/RecordPatternWithSimplePatterns (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/RecordPatternWithSimplePatterns.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/RecordWithIgnorePattern (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/RecordWithIgnorePattern.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/RecordWithTuple (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/RecordWithTuple.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/String (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/String.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/TupleLastFieldIntPattern (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/TupleLastFieldIntPattern.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/TupleNestingTuples (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/TupleNestingTuples.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/TuplePatternIdentifierPatterns (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/TuplePatternIdentifierPatterns.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/TuplePatternNestedInBlocks1 (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/TuplePatternNestedInBlocks1.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/TuplePatternNestedInBlocks2 (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/TuplePatternNestedInBlocks2.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/TupleWithBoolPattern (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/TupleWithBoolPattern.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/TupleWithIgnorePattern (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/TupleWithIgnorePattern.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/TupleWithRecord (100%) rename core/codegen/{ => javagen}/src/test/resources/pattern_specs/TupleWithRecord.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pre_post_specs/ImplicitFunc (100%) rename core/codegen/{ => javagen}/src/test/resources/pre_post_specs/ImplicitFunc.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pre_post_specs/ImplicitOp (100%) rename core/codegen/{ => javagen}/src/test/resources/pre_post_specs/ImplicitOp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pre_post_specs/PostFailureFuncTuplePattern (100%) rename core/codegen/{ => javagen}/src/test/resources/pre_post_specs/PostFailureFuncTuplePattern.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pre_post_specs/PostPassFuncTuplePattern (100%) rename core/codegen/{ => javagen}/src/test/resources/pre_post_specs/PostPassFuncTuplePattern.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pre_post_specs/PostPassNonStaticOp (100%) rename core/codegen/{ => javagen}/src/test/resources/pre_post_specs/PostPassNonStaticOp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pre_post_specs/PreFailureFuncSimple1 (100%) rename core/codegen/{ => javagen}/src/test/resources/pre_post_specs/PreFailureFuncSimple1.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pre_post_specs/PreFailureOpTuplePattern (100%) rename core/codegen/{ => javagen}/src/test/resources/pre_post_specs/PreFailureOpTuplePattern.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pre_post_specs/PrePassFuncSimple1 (100%) rename core/codegen/{ => javagen}/src/test/resources/pre_post_specs/PrePassFuncSimple1.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pre_post_specs/PrePassNonStaticOp (100%) rename core/codegen/{ => javagen}/src/test/resources/pre_post_specs/PrePassNonStaticOp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/pre_post_specs/PrePassOpTuplePattern (100%) rename core/codegen/{ => javagen}/src/test/resources/pre_post_specs/PrePassOpTuplePattern.result (100%) rename core/codegen/{ => javagen}/src/test/resources/renaming_specs/AssignmentDef (100%) rename core/codegen/{ => javagen}/src/test/resources/renaming_specs/AssignmentDef.result (100%) rename core/codegen/{ => javagen}/src/test/resources/renaming_specs/ClassName (100%) rename core/codegen/{ => javagen}/src/test/resources/renaming_specs/ClassName.result (100%) rename core/codegen/{ => javagen}/src/test/resources/renaming_specs/FuncName (100%) rename core/codegen/{ => javagen}/src/test/resources/renaming_specs/FuncName.result (100%) rename core/codegen/{ => javagen}/src/test/resources/renaming_specs/InstanceVar (100%) rename core/codegen/{ => javagen}/src/test/resources/renaming_specs/InstanceVar.result (100%) rename core/codegen/{ => javagen}/src/test/resources/renaming_specs/LetExp (100%) rename core/codegen/{ => javagen}/src/test/resources/renaming_specs/LetExp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/renaming_specs/LetStm (100%) rename core/codegen/{ => javagen}/src/test/resources/renaming_specs/LetStm.result (100%) rename core/codegen/{ => javagen}/src/test/resources/renaming_specs/OpName (100%) rename core/codegen/{ => javagen}/src/test/resources/renaming_specs/OpName.result (100%) rename core/codegen/{ => javagen}/src/test/resources/renaming_specs/SameNameInDifferentOps (100%) rename core/codegen/{ => javagen}/src/test/resources/renaming_specs/SameNameInDifferentOps.result (100%) rename core/codegen/{ => javagen}/src/test/resources/renaming_specs/SamePatchTwoClass (100%) rename core/codegen/{ => javagen}/src/test/resources/renaming_specs/SamePatchTwoClass.result (100%) rename core/codegen/{ => javagen}/src/test/resources/renaming_specs/ValueDef (100%) rename core/codegen/{ => javagen}/src/test/resources/renaming_specs/ValueDef.result (100%) rename core/codegen/{ => javagen}/src/test/resources/rt/AsyncCounterInc (100%) rename core/codegen/{ => javagen}/src/test/resources/rt/AsyncCounterInc.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/ApplyExp (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/ApplyExp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/ApplyExpReturnedString (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/ApplyExpReturnedString.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/AssignmentDefinitionReturn (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/AssignmentDefinitionReturn.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/BlockStmInitialized (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/BlockStmInitialized.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/BlockStmUninitialized (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/BlockStmUninitialized.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/CallObjectStmReturn (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/CallObjectStmReturn.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/CallStm (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/CallStm.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/CallStms (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/CallStms.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/CallStmsDeadCode (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/CallStmsDeadCode.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/ClassComparison (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/ClassComparison.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/ConcMechanismsDoNotGenerate (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/ConcMechanismsDoNotGenerate.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/ConstructorDefault (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/ConstructorDefault.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/ElemsTypeInference (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/ElemsTypeInference.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/Employee (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/Employee.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/ErrorStm (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/ErrorStm.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/FloorAssignment (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/FloorAssignment.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/ForAllSeqLoop (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/ForAllSeqLoop.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/ForAllSetLoop (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/ForAllSetLoop.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/ForIndexCorner (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/ForIndexCorner.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/ForIndexStm (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/ForIndexStm.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/ForIndexStmSimple (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/ForIndexStmSimple.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/Functions (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/Functions.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/IfExp (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/IfExp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/InstanceOf (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/InstanceOf.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/LetDefExp (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/LetDefExp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/MapApplyClone (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/MapApplyClone.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/MapComparisonClone (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/MapComparisonClone.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/MapDomClone (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/MapDomClone.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/MapDomResByClone (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/MapDomResByClone.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/MapDomResToClone (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/MapDomResToClone.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/MapInverseClone (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/MapInverseClone.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/MapMapUnionClone (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/MapMapUnionClone.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/MapMergeClone (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/MapMergeClone.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/MapOverrideClone (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/MapOverrideClone.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/MapPhoneBook (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/MapPhoneBook.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/MapRangeClone (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/MapRangeClone.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/MapRangeResByClone (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/MapRangeResByClone.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/MapRangeResToClone (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/MapRangeResToClone.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/MathLib (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/MathLib.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/NameViolationClassName (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/NameViolationClassName.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/NameViolationsJavakeyword (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/NameViolationsJavakeyword.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/NamedInvariantType (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/NamedInvariantType.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/NotYetSpecified (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/NotYetSpecified.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/ObjectDesignatorField (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/ObjectDesignatorField.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/ObjectDesignatorIdentifier (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/ObjectDesignatorIdentifier.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/ObjectDesignatorNew (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/ObjectDesignatorNew.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/ObjectDesignatorSelf (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/ObjectDesignatorSelf.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/OperationReturnsValueType (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/OperationReturnsValueType.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/OptionalType (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/OptionalType.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/RecordComparison (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/RecordComparison.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/RecordCreation (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/RecordCreation.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/RecordCycle (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/RecordCycle.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/RecordDecls (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/RecordDecls.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/RecordNesting (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/RecordNesting.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/RecordPrimitiveFields (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/RecordPrimitiveFields.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/RecordUsage (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/RecordUsage.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/RecordUsageAcrossClass (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/RecordUsageAcrossClass.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/ReturnVoid (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/ReturnVoid.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/SeqDistConcOpResult (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/SeqDistConcOpResult.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/SeqDistConcatOperationCalls (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/SeqDistConcatOperationCalls.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/SeqModCloning (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/SeqModCloning.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/SeqNoteBook (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/SeqNoteBook.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/SeqReverseBasicTypes (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/SeqReverseBasicTypes.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/SetBag (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/SetBag.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/SetDiffClone (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/SetDiffClone.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/SetDistInterClone (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/SetDistInterClone.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/SetDistUnionClone (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/SetDistUnionClone.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/SetIntersectClone (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/SetIntersectClone.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/SetPowerSetClone (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/SetPowerSetClone.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/SetProperSubsetClone (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/SetProperSubsetClone.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/SetSubsetClone (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/SetSubsetClone.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/SetUnionCloning (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/SetUnionCloning.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/StringType (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/StringType.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/Strings (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/Strings.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/TemplateTypes (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/TemplateTypes.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/TupleUsage (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/TupleUsage.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/Tuples (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/Tuples.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/UnionOfQuotes (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/UnionOfQuotes.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/UnknownTypes (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/UnknownTypes.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/UnsupportedModelingConstructs (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/UnsupportedModelingConstructs.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/ValueRefInAcrossClass (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/ValueRefInAcrossClass.result (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/VariableExpressions (100%) rename core/codegen/{ => javagen}/src/test/resources/specifications/VariableExpressions.result (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/ApplyExpMissingSeqOfCharInOneClass (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/ApplyExpMissingSeqOfCharInOneClass.result (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/Comparison (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/Comparison.result (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/Concat (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/Concat.result (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/DistConcat (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/DistConcat.result (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/Elems (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/Elems.result (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/EqualsNotEqualsSeqConversion (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/EqualsNotEqualsSeqConversion.result (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/EscapedCharacters (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/EscapedCharacters.result (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/Head (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/Head.result (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/Indexing (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/Indexing.result (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/Indices (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/Indices.result (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/Modification (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/Modification.result (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/Reverse (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/Reverse.result (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/SeqConversion (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/SeqConversion.result (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/SeqToStrFieldNumberExp (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/SeqToStrFieldNumberExp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/Size (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/Size.result (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/StringPattern (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/StringPattern.result (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/SubSeqString1 (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/SubSeqString1.result (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/SubSeqString2 (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/SubSeqString2.result (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/SubSeqString3 (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/SubSeqString3.result (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/SubSeqString4 (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/SubSeqString4.result (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/SubSeqString5 (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/SubSeqString5.result (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/SubSeqString6 (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/SubSeqString6.result (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/Tail (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/Tail.result (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/Val2SeqOfChar (100%) rename core/codegen/{ => javagen}/src/test/resources/string_specs/Val2SeqOfChar.result (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/Alternative1 (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/Alternative1.result (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/AlternativeConcurrent1 (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/AlternativeConcurrent1.result (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/AlternativeRepeat1 (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/AlternativeRepeat1.result (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/Concurrent1 (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/Concurrent1.result (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/Concurrent2 (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/Concurrent2.result (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/ConcurrentAlternative1 (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/ConcurrentAlternative1.result (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/ConcurrentRepeat1 (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/ConcurrentRepeat1.result (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/ConcurrentRepeat2 (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/ConcurrentRepeat2.result (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/ConcurrentWithLetBeSt (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/ConcurrentWithLetBeSt.result (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/LetBeSt1 (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/LetBeSt1.result (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/LetBeStNested (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/LetBeStNested.result (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/LetBeStRecPattern (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/LetBeStRecPattern.result (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/LetBeStTupPattern (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/LetBeStTupPattern.result (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/LetDef1 (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/LetDef1.result (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/LetDefConsecutive (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/LetDefConsecutive.result (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/LetDefConsecutiveRepeat (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/LetDefConsecutiveRepeat.result (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/LetDefTuplePattern (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/LetDefTuplePattern.result (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/ObjectBind (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/ObjectBind.result (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/OpCallsUsedToInitLocalDefs (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/OpCallsUsedToInitLocalDefs.result (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/Repeat1 (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/Repeat1.result (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/RepeatAlternative1 (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/RepeatAlternative1.result (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/RepeatConcurrent1 (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/RepeatConcurrent1.result (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/SharedObjectBind (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/SharedObjectBind.result (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/SingleStatement1 (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_expansion_specs/SingleStatement1.result (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_verdict_specs/DivByZero (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_verdict_specs/DivByZero.result (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_verdict_specs/Filter (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_verdict_specs/Filter.result (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_verdict_specs/LetBeStNoBinding (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_verdict_specs/LetBeStNoBinding.result (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_verdict_specs/MapNoSuchKey (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_verdict_specs/MapNoSuchKey.result (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_verdict_specs/NilRefError (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_verdict_specs/NilRefError.result (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_verdict_specs/PreCondViolation (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_verdict_specs/PreCondViolation.result (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_verdict_specs/SameTestTwice (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_verdict_specs/SameTestTwice.result (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_verdict_specs/SeqIndexOutOfRange (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_verdict_specs/SeqIndexOutOfRange.result (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_verdict_specs/UnionTypeFailure (100%) rename core/codegen/{ => javagen}/src/test/resources/traces_verdict_specs/UnionTypeFailure.result (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/ApplyExpInElseIfStm (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/ApplyExpInElseIfStm.result (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/ApplyExpMethodTypeRoot (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/ApplyExpMethodTypeRoot.result (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/ApplyExpMissingFunInOneClass (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/ApplyExpMissingFunInOneClass.result (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/ApplyExpMissingMapInOneClass (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/ApplyExpMissingMapInOneClass.result (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/ApplyExpMissingSeqInOneClass (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/ApplyExpMissingSeqInOneClass.result (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/ApplyExpMissingSeqOfCharInOneClass (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/ApplyExpMissingSeqOfCharInOneClass.result (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/ApplyExpNested (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/ApplyExpNested.result (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/CallObjStmInheritedOpProtected (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/CallObjStmInheritedOpProtected.result (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/CallObjStmInheritedOpPublic (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/CallObjStmInheritedOpPublic.result (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/CallObjStmMissingOpInOneClass (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/CallObjStmMissingOpInOneClass.result (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/CallObjStmNoArgs (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/CallObjStmNoArgs.result (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/CallObjStmNoArgsInLoop (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/CallObjStmNoArgsInLoop.result (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/CallObjStmWithArguments (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/CallObjStmWithArguments.result (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/CallStmInheritedOp (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/CallStmInheritedOp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/CallStmLocalOp (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/CallStmLocalOp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/Card (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/Card.result (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/FieldExpArgToOpCall (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/FieldExpArgToOpCall.result (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/FieldExpInReturnStm (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/FieldExpInReturnStm.result (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/FieldExpMissingRecField (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/FieldExpMissingRecField.result (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/FieldExpNotRootOfApplyExp (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/FieldExpNotRootOfApplyExp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/FieldExpOfRecord (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/FieldExpOfRecord.result (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/FieldExpOfRecordArgToApplyExp (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/FieldExpOfRecordArgToApplyExp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/FieldExpSeqApply (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/FieldExpSeqApply.result (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/FieldExpWithApplyExpParent (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/FieldExpWithApplyExpParent.result (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/FieldExpWithApplyExpParentInIfStm (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/FieldExpWithApplyExpParentInIfStm.result (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/FieldExpWithObjectAsApplyExp (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/FieldExpWithObjectAsApplyExp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/FieldNumberExpArgToApplyExp (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/FieldNumberExpArgToApplyExp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/FieldNumberExpDifferentFieldTyps (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/FieldNumberExpDifferentFieldTyps.result (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/FieldNumberExpUnknownType (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/FieldNumberExpUnknownType.result (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/IfStm (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/IfStm.result (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/Len (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/Len.result (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/LetBeStRecElem (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/LetBeStRecElem.result (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/MapApply (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/MapApply.result (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/MapCompUnionOfMapTypes (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/MapCompUnionOfMapTypes.result (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/NewExpClass (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/NewExpClass.result (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/NewExpRecord (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/NewExpRecord.result (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/NotExp (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/NotExp.result (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/NumericPlus (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/NumericPlus.result (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/ReturnStm (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/ReturnStm.result (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/SeqApply (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/SeqApply.result (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/SeqCompUnionOfSeqTypes (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/SeqCompUnionOfSeqTypes.result (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/SeqConc (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/SeqConc.result (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/SetCompUnionOfSetTypes (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/SetCompUnionOfSetTypes.result (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/UnionOfQuotes (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/UnionOfQuotes.result (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/UnknownTypeInUnionType (100%) rename core/codegen/{ => javagen}/src/test/resources/union_type_specs/UnknownTypeInUnionType.result (100%) rename core/codegen/{ => javagen}/src/test/resources/var_shadowing_specs/CasesExpTuplePattern (100%) rename core/codegen/{ => javagen}/src/test/resources/var_shadowing_specs/CasesStmTuplePattern (100%) rename core/codegen/{ => javagen}/src/test/resources/var_shadowing_specs/DefExp (100%) rename core/codegen/{ => javagen}/src/test/resources/var_shadowing_specs/ExistsTwoMultipleSetBinds (100%) rename core/codegen/{ => javagen}/src/test/resources/var_shadowing_specs/ForAllExpTwoMultipleBinds (100%) rename core/codegen/{ => javagen}/src/test/resources/var_shadowing_specs/ForAllExpTwoMultipleTypeBindsOneName (100%) rename core/codegen/{ => javagen}/src/test/resources/var_shadowing_specs/ForAllExpTwoMultipleTypeBindsTwoNames (100%) rename core/codegen/{ => javagen}/src/test/resources/var_shadowing_specs/ForAllStmTuplePattern (100%) rename core/codegen/{ => javagen}/src/test/resources/var_shadowing_specs/ForIndexLoopVar (100%) rename core/codegen/{ => javagen}/src/test/resources/var_shadowing_specs/ForPatternBindTuple (100%) rename core/codegen/{ => javagen}/src/test/resources/var_shadowing_specs/GenUniqueNameLetStm (100%) rename core/codegen/{ => javagen}/src/test/resources/var_shadowing_specs/IdShadowingVarExp (100%) rename core/codegen/{ => javagen}/src/test/resources/var_shadowing_specs/IdStateDesignatorNestedBlocks (100%) rename core/codegen/{ => javagen}/src/test/resources/var_shadowing_specs/IdStateDesignatorSingleBlock (100%) rename core/codegen/{ => javagen}/src/test/resources/var_shadowing_specs/LambdaInLet (100%) rename core/codegen/{ => javagen}/src/test/resources/var_shadowing_specs/LambdaParam (100%) rename core/codegen/{ => javagen}/src/test/resources/var_shadowing_specs/LetBeStExpNested (100%) rename core/codegen/{ => javagen}/src/test/resources/var_shadowing_specs/LetBeStStmCond (100%) rename core/codegen/{ => javagen}/src/test/resources/var_shadowing_specs/LetBeStStmMultipleSetBind (100%) rename core/codegen/{ => javagen}/src/test/resources/var_shadowing_specs/LetBeStStmMultipleTypeBind (100%) rename core/codegen/{ => javagen}/src/test/resources/var_shadowing_specs/LetBeStTrace (100%) rename core/codegen/{ => javagen}/src/test/resources/var_shadowing_specs/LetBeStTraceMultipleTypeBind (100%) rename core/codegen/{ => javagen}/src/test/resources/var_shadowing_specs/LetStmCrossClassDependency (100%) rename core/codegen/{ => javagen}/src/test/resources/var_shadowing_specs/LetStmHidingAtSameScopeLevel (100%) rename core/codegen/{ => javagen}/src/test/resources/var_shadowing_specs/LetStmNested (100%) rename core/codegen/{ => javagen}/src/test/resources/var_shadowing_specs/LetStmTuplePatterns (100%) rename core/codegen/{ => javagen}/src/test/resources/var_shadowing_specs/LetStmVarHiddenMultipleTimes (100%) rename core/codegen/{ => javagen}/src/test/resources/var_shadowing_specs/LetVarHidesFuncParam (100%) rename core/codegen/{ => javagen}/src/test/resources/var_shadowing_specs/LetVarHidesOpParam (100%) rename core/codegen/{ => javagen}/src/test/resources/var_shadowing_specs/MapCompTwoMultipleSetBinds (100%) rename core/codegen/{ => javagen}/src/test/resources/var_shadowing_specs/SetCompTwoMultipleSetBinds (100%) rename core/codegen/{ => javagen}/src/test/resources/var_shadowing_specs/StmBlockSimple (100%) rename core/codegen/{ => javagen}/src/test/resources/var_shadowing_specs/TixeStmTuplePattern (100%) rename core/codegen/{ => javagen}/src/test/resources/var_shadowing_specs/TrapStmTuplePattern (100%) rename core/codegen/{ => javagen}/src/test/resources/var_shadowing_specs/TuplePatternIdsShadowing (100%) diff --git a/core/cgisa/pom.xml b/core/codegen/cgisa/pom.xml similarity index 100% rename from core/cgisa/pom.xml rename to core/codegen/cgisa/pom.xml diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/ExtIrGenerator.java b/core/codegen/cgisa/src/main/java/org/overturetool/cgisa/ExtIrGenerator.java similarity index 100% rename from core/cgisa/src/main/java/org/overturetool/cgisa/ExtIrGenerator.java rename to core/codegen/cgisa/src/main/java/org/overturetool/cgisa/ExtIrGenerator.java diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaChecks.java b/core/codegen/cgisa/src/main/java/org/overturetool/cgisa/IsaChecks.java similarity index 100% rename from core/cgisa/src/main/java/org/overturetool/cgisa/IsaChecks.java rename to core/codegen/cgisa/src/main/java/org/overturetool/cgisa/IsaChecks.java diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaCodeGen.java b/core/codegen/cgisa/src/main/java/org/overturetool/cgisa/IsaCodeGen.java similarity index 100% rename from core/cgisa/src/main/java/org/overturetool/cgisa/IsaCodeGen.java rename to core/codegen/cgisa/src/main/java/org/overturetool/cgisa/IsaCodeGen.java diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTemplateManager.java b/core/codegen/cgisa/src/main/java/org/overturetool/cgisa/IsaTemplateManager.java similarity index 100% rename from core/cgisa/src/main/java/org/overturetool/cgisa/IsaTemplateManager.java rename to core/codegen/cgisa/src/main/java/org/overturetool/cgisa/IsaTemplateManager.java diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslations.java b/core/codegen/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslations.java similarity index 100% rename from core/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslations.java rename to core/codegen/cgisa/src/main/java/org/overturetool/cgisa/IsaTranslations.java diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/checkers/IsCharTypeVisitor.java b/core/codegen/cgisa/src/main/java/org/overturetool/cgisa/checkers/IsCharTypeVisitor.java similarity index 100% rename from core/cgisa/src/main/java/org/overturetool/cgisa/checkers/IsCharTypeVisitor.java rename to core/codegen/cgisa/src/main/java/org/overturetool/cgisa/checkers/IsCharTypeVisitor.java diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/checkers/IsMethodTypeVisitor.java b/core/codegen/cgisa/src/main/java/org/overturetool/cgisa/checkers/IsMethodTypeVisitor.java similarity index 100% rename from core/cgisa/src/main/java/org/overturetool/cgisa/checkers/IsMethodTypeVisitor.java rename to core/codegen/cgisa/src/main/java/org/overturetool/cgisa/checkers/IsMethodTypeVisitor.java diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/checkers/IsSeqOfCharTypeVisitor.java b/core/codegen/cgisa/src/main/java/org/overturetool/cgisa/checkers/IsSeqOfCharTypeVisitor.java similarity index 100% rename from core/cgisa/src/main/java/org/overturetool/cgisa/checkers/IsSeqOfCharTypeVisitor.java rename to core/codegen/cgisa/src/main/java/org/overturetool/cgisa/checkers/IsSeqOfCharTypeVisitor.java diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/ir/ExtIrClassDeclStatus.java b/core/codegen/cgisa/src/main/java/org/overturetool/cgisa/ir/ExtIrClassDeclStatus.java similarity index 100% rename from core/cgisa/src/main/java/org/overturetool/cgisa/ir/ExtIrClassDeclStatus.java rename to core/codegen/cgisa/src/main/java/org/overturetool/cgisa/ir/ExtIrClassDeclStatus.java diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/transformations/ExtendClass.java b/core/codegen/cgisa/src/main/java/org/overturetool/cgisa/transformations/ExtendClass.java similarity index 100% rename from core/cgisa/src/main/java/org/overturetool/cgisa/transformations/ExtendClass.java rename to core/codegen/cgisa/src/main/java/org/overturetool/cgisa/transformations/ExtendClass.java diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/transformations/GroupMutRecs.java b/core/codegen/cgisa/src/main/java/org/overturetool/cgisa/transformations/GroupMutRecs.java similarity index 100% rename from core/cgisa/src/main/java/org/overturetool/cgisa/transformations/GroupMutRecs.java rename to core/codegen/cgisa/src/main/java/org/overturetool/cgisa/transformations/GroupMutRecs.java diff --git a/core/cgisa/src/main/java/org/overturetool/cgisa/transformations/SortDependencies.java b/core/codegen/cgisa/src/main/java/org/overturetool/cgisa/transformations/SortDependencies.java similarity index 100% rename from core/cgisa/src/main/java/org/overturetool/cgisa/transformations/SortDependencies.java rename to core/codegen/cgisa/src/main/java/org/overturetool/cgisa/transformations/SortDependencies.java diff --git a/core/cgisa/src/main/resources/IsaTemplates/Declarations/Class.vm b/core/codegen/cgisa/src/main/resources/IsaTemplates/Declarations/Class.vm similarity index 100% rename from core/cgisa/src/main/resources/IsaTemplates/Declarations/Class.vm rename to core/codegen/cgisa/src/main/resources/IsaTemplates/Declarations/Class.vm diff --git a/core/cgisa/src/main/resources/IsaTemplates/Declarations/ExtClass.vm b/core/codegen/cgisa/src/main/resources/IsaTemplates/Declarations/ExtClass.vm similarity index 100% rename from core/cgisa/src/main/resources/IsaTemplates/Declarations/ExtClass.vm rename to core/codegen/cgisa/src/main/resources/IsaTemplates/Declarations/ExtClass.vm diff --git a/core/cgisa/src/main/resources/IsaTemplates/Declarations/Field.vm b/core/codegen/cgisa/src/main/resources/IsaTemplates/Declarations/Field.vm similarity index 100% rename from core/cgisa/src/main/resources/IsaTemplates/Declarations/Field.vm rename to core/codegen/cgisa/src/main/resources/IsaTemplates/Declarations/Field.vm diff --git a/core/cgisa/src/main/resources/IsaTemplates/Declarations/Function.vm b/core/codegen/cgisa/src/main/resources/IsaTemplates/Declarations/Function.vm similarity index 100% rename from core/cgisa/src/main/resources/IsaTemplates/Declarations/Function.vm rename to core/codegen/cgisa/src/main/resources/IsaTemplates/Declarations/Function.vm diff --git a/core/cgisa/src/main/resources/IsaTemplates/Declarations/MutRec.vm b/core/codegen/cgisa/src/main/resources/IsaTemplates/Declarations/MutRec.vm similarity index 100% rename from core/cgisa/src/main/resources/IsaTemplates/Declarations/MutRec.vm rename to core/codegen/cgisa/src/main/resources/IsaTemplates/Declarations/MutRec.vm diff --git a/core/cgisa/src/main/resources/IsaTemplates/Expressions/Apply.vm b/core/codegen/cgisa/src/main/resources/IsaTemplates/Expressions/Apply.vm similarity index 100% rename from core/cgisa/src/main/resources/IsaTemplates/Expressions/Apply.vm rename to core/codegen/cgisa/src/main/resources/IsaTemplates/Expressions/Apply.vm diff --git a/core/cgisa/src/main/resources/IsaTemplates/Expressions/Binary/Numeric/Plus.vm b/core/codegen/cgisa/src/main/resources/IsaTemplates/Expressions/Binary/Numeric/Plus.vm similarity index 100% rename from core/cgisa/src/main/resources/IsaTemplates/Expressions/Binary/Numeric/Plus.vm rename to core/codegen/cgisa/src/main/resources/IsaTemplates/Expressions/Binary/Numeric/Plus.vm diff --git a/core/cgisa/src/main/resources/IsaTemplates/Expressions/CharLiteral.vm b/core/codegen/cgisa/src/main/resources/IsaTemplates/Expressions/CharLiteral.vm similarity index 100% rename from core/cgisa/src/main/resources/IsaTemplates/Expressions/CharLiteral.vm rename to core/codegen/cgisa/src/main/resources/IsaTemplates/Expressions/CharLiteral.vm diff --git a/core/cgisa/src/main/resources/IsaTemplates/Expressions/IntLiteral.vm b/core/codegen/cgisa/src/main/resources/IsaTemplates/Expressions/IntLiteral.vm similarity index 100% rename from core/cgisa/src/main/resources/IsaTemplates/Expressions/IntLiteral.vm rename to core/codegen/cgisa/src/main/resources/IsaTemplates/Expressions/IntLiteral.vm diff --git a/core/cgisa/src/main/resources/IsaTemplates/Expressions/Seq/Enum.vm b/core/codegen/cgisa/src/main/resources/IsaTemplates/Expressions/Seq/Enum.vm similarity index 100% rename from core/cgisa/src/main/resources/IsaTemplates/Expressions/Seq/Enum.vm rename to core/codegen/cgisa/src/main/resources/IsaTemplates/Expressions/Seq/Enum.vm diff --git a/core/cgisa/src/main/resources/IsaTemplates/Expressions/Variable.vm b/core/codegen/cgisa/src/main/resources/IsaTemplates/Expressions/Variable.vm similarity index 100% rename from core/cgisa/src/main/resources/IsaTemplates/Expressions/Variable.vm rename to core/codegen/cgisa/src/main/resources/IsaTemplates/Expressions/Variable.vm diff --git a/core/cgisa/src/main/resources/IsaTemplates/LocalDecls/FormalParam.vm b/core/codegen/cgisa/src/main/resources/IsaTemplates/LocalDecls/FormalParam.vm similarity index 100% rename from core/cgisa/src/main/resources/IsaTemplates/LocalDecls/FormalParam.vm rename to core/codegen/cgisa/src/main/resources/IsaTemplates/LocalDecls/FormalParam.vm diff --git a/core/cgisa/src/main/resources/IsaTemplates/Pattern/Identifier.vm b/core/codegen/cgisa/src/main/resources/IsaTemplates/Pattern/Identifier.vm similarity index 100% rename from core/cgisa/src/main/resources/IsaTemplates/Pattern/Identifier.vm rename to core/codegen/cgisa/src/main/resources/IsaTemplates/Pattern/Identifier.vm diff --git a/core/cgisa/src/main/resources/IsaTemplates/Types/Basic/Char.vm b/core/codegen/cgisa/src/main/resources/IsaTemplates/Types/Basic/Char.vm similarity index 100% rename from core/cgisa/src/main/resources/IsaTemplates/Types/Basic/Char.vm rename to core/codegen/cgisa/src/main/resources/IsaTemplates/Types/Basic/Char.vm diff --git a/core/cgisa/src/main/resources/IsaTemplates/Types/Basic/Integer.vm b/core/codegen/cgisa/src/main/resources/IsaTemplates/Types/Basic/Integer.vm similarity index 100% rename from core/cgisa/src/main/resources/IsaTemplates/Types/Basic/Integer.vm rename to core/codegen/cgisa/src/main/resources/IsaTemplates/Types/Basic/Integer.vm diff --git a/core/cgisa/src/main/resources/IsaTemplates/Types/Basic/Nat.vm b/core/codegen/cgisa/src/main/resources/IsaTemplates/Types/Basic/Nat.vm similarity index 100% rename from core/cgisa/src/main/resources/IsaTemplates/Types/Basic/Nat.vm rename to core/codegen/cgisa/src/main/resources/IsaTemplates/Types/Basic/Nat.vm diff --git a/core/cgisa/src/main/resources/IsaTemplates/Types/Basic/Nat1.vm b/core/codegen/cgisa/src/main/resources/IsaTemplates/Types/Basic/Nat1.vm similarity index 100% rename from core/cgisa/src/main/resources/IsaTemplates/Types/Basic/Nat1.vm rename to core/codegen/cgisa/src/main/resources/IsaTemplates/Types/Basic/Nat1.vm diff --git a/core/cgisa/src/main/resources/isacg.ast b/core/codegen/cgisa/src/main/resources/isacg.ast similarity index 100% rename from core/cgisa/src/main/resources/isacg.ast rename to core/codegen/cgisa/src/main/resources/isacg.ast diff --git a/core/cgisa/src/main/resources/isacg.ast.tostring b/core/codegen/cgisa/src/main/resources/isacg.ast.tostring similarity index 100% rename from core/cgisa/src/main/resources/isacg.ast.tostring rename to core/codegen/cgisa/src/main/resources/isacg.ast.tostring diff --git a/core/cgisa/src/test/java/org/overturetool/cgisa/AdHoc.java b/core/codegen/cgisa/src/test/java/org/overturetool/cgisa/AdHoc.java similarity index 100% rename from core/cgisa/src/test/java/org/overturetool/cgisa/AdHoc.java rename to core/codegen/cgisa/src/test/java/org/overturetool/cgisa/AdHoc.java diff --git a/core/cgisa/src/test/java/org/overturetool/cgisa/CgIsaParamTest.java b/core/codegen/cgisa/src/test/java/org/overturetool/cgisa/CgIsaParamTest.java similarity index 100% rename from core/cgisa/src/test/java/org/overturetool/cgisa/CgIsaParamTest.java rename to core/codegen/cgisa/src/test/java/org/overturetool/cgisa/CgIsaParamTest.java diff --git a/core/cgisa/src/test/java/org/overturetool/cgisa/CgIsaTestResult.java b/core/codegen/cgisa/src/test/java/org/overturetool/cgisa/CgIsaTestResult.java similarity index 100% rename from core/cgisa/src/test/java/org/overturetool/cgisa/CgIsaTestResult.java rename to core/codegen/cgisa/src/test/java/org/overturetool/cgisa/CgIsaTestResult.java diff --git a/core/cgisa/src/test/resources/micro/Functions/FuncApply1Param.vdmpp b/core/codegen/cgisa/src/test/resources/micro/Functions/FuncApply1Param.vdmpp similarity index 100% rename from core/cgisa/src/test/resources/micro/Functions/FuncApply1Param.vdmpp rename to core/codegen/cgisa/src/test/resources/micro/Functions/FuncApply1Param.vdmpp diff --git a/core/cgisa/src/test/resources/micro/Functions/FuncApply1Param.vdmpp.result b/core/codegen/cgisa/src/test/resources/micro/Functions/FuncApply1Param.vdmpp.result similarity index 100% rename from core/cgisa/src/test/resources/micro/Functions/FuncApply1Param.vdmpp.result rename to core/codegen/cgisa/src/test/resources/micro/Functions/FuncApply1Param.vdmpp.result diff --git a/core/cgisa/src/test/resources/micro/Functions/FuncApply3Params.vdmpp b/core/codegen/cgisa/src/test/resources/micro/Functions/FuncApply3Params.vdmpp similarity index 100% rename from core/cgisa/src/test/resources/micro/Functions/FuncApply3Params.vdmpp rename to core/codegen/cgisa/src/test/resources/micro/Functions/FuncApply3Params.vdmpp diff --git a/core/cgisa/src/test/resources/micro/Functions/FuncApply3Params.vdmpp.result b/core/codegen/cgisa/src/test/resources/micro/Functions/FuncApply3Params.vdmpp.result similarity index 100% rename from core/cgisa/src/test/resources/micro/Functions/FuncApply3Params.vdmpp.result rename to core/codegen/cgisa/src/test/resources/micro/Functions/FuncApply3Params.vdmpp.result diff --git a/core/cgisa/src/test/resources/micro/Functions/FuncApplyNoParam.vdmpp b/core/codegen/cgisa/src/test/resources/micro/Functions/FuncApplyNoParam.vdmpp similarity index 100% rename from core/cgisa/src/test/resources/micro/Functions/FuncApplyNoParam.vdmpp rename to core/codegen/cgisa/src/test/resources/micro/Functions/FuncApplyNoParam.vdmpp diff --git a/core/cgisa/src/test/resources/micro/Functions/FuncApplyNoParam.vdmpp.result b/core/codegen/cgisa/src/test/resources/micro/Functions/FuncApplyNoParam.vdmpp.result similarity index 100% rename from core/cgisa/src/test/resources/micro/Functions/FuncApplyNoParam.vdmpp.result rename to core/codegen/cgisa/src/test/resources/micro/Functions/FuncApplyNoParam.vdmpp.result diff --git a/core/cgisa/src/test/resources/micro/Functions/FuncDecl1Param.vdmpp b/core/codegen/cgisa/src/test/resources/micro/Functions/FuncDecl1Param.vdmpp similarity index 100% rename from core/cgisa/src/test/resources/micro/Functions/FuncDecl1Param.vdmpp rename to core/codegen/cgisa/src/test/resources/micro/Functions/FuncDecl1Param.vdmpp diff --git a/core/cgisa/src/test/resources/micro/Functions/FuncDecl1Param.vdmpp.result b/core/codegen/cgisa/src/test/resources/micro/Functions/FuncDecl1Param.vdmpp.result similarity index 100% rename from core/cgisa/src/test/resources/micro/Functions/FuncDecl1Param.vdmpp.result rename to core/codegen/cgisa/src/test/resources/micro/Functions/FuncDecl1Param.vdmpp.result diff --git a/core/cgisa/src/test/resources/micro/Functions/FuncDecl2Params.vdmpp b/core/codegen/cgisa/src/test/resources/micro/Functions/FuncDecl2Params.vdmpp similarity index 100% rename from core/cgisa/src/test/resources/micro/Functions/FuncDecl2Params.vdmpp rename to core/codegen/cgisa/src/test/resources/micro/Functions/FuncDecl2Params.vdmpp diff --git a/core/cgisa/src/test/resources/micro/Functions/FuncDecl2Params.vdmpp.result b/core/codegen/cgisa/src/test/resources/micro/Functions/FuncDecl2Params.vdmpp.result similarity index 100% rename from core/cgisa/src/test/resources/micro/Functions/FuncDecl2Params.vdmpp.result rename to core/codegen/cgisa/src/test/resources/micro/Functions/FuncDecl2Params.vdmpp.result diff --git a/core/cgisa/src/test/resources/micro/Functions/FuncDeclNoParam.vdmpp b/core/codegen/cgisa/src/test/resources/micro/Functions/FuncDeclNoParam.vdmpp similarity index 100% rename from core/cgisa/src/test/resources/micro/Functions/FuncDeclNoParam.vdmpp rename to core/codegen/cgisa/src/test/resources/micro/Functions/FuncDeclNoParam.vdmpp diff --git a/core/cgisa/src/test/resources/micro/Functions/FuncDeclNoParam.vdmpp.result b/core/codegen/cgisa/src/test/resources/micro/Functions/FuncDeclNoParam.vdmpp.result similarity index 100% rename from core/cgisa/src/test/resources/micro/Functions/FuncDeclNoParam.vdmpp.result rename to core/codegen/cgisa/src/test/resources/micro/Functions/FuncDeclNoParam.vdmpp.result diff --git a/core/cgisa/src/test/resources/micro/Functions/FuncDepSimple.vdmpp b/core/codegen/cgisa/src/test/resources/micro/Functions/FuncDepSimple.vdmpp similarity index 100% rename from core/cgisa/src/test/resources/micro/Functions/FuncDepSimple.vdmpp rename to core/codegen/cgisa/src/test/resources/micro/Functions/FuncDepSimple.vdmpp diff --git a/core/cgisa/src/test/resources/micro/Functions/FuncDepSimple.vdmpp.result b/core/codegen/cgisa/src/test/resources/micro/Functions/FuncDepSimple.vdmpp.result similarity index 100% rename from core/cgisa/src/test/resources/micro/Functions/FuncDepSimple.vdmpp.result rename to core/codegen/cgisa/src/test/resources/micro/Functions/FuncDepSimple.vdmpp.result diff --git a/core/cgisa/src/test/resources/micro/Values/IntExp.vdmpp b/core/codegen/cgisa/src/test/resources/micro/Values/IntExp.vdmpp similarity index 100% rename from core/cgisa/src/test/resources/micro/Values/IntExp.vdmpp rename to core/codegen/cgisa/src/test/resources/micro/Values/IntExp.vdmpp diff --git a/core/cgisa/src/test/resources/micro/Values/IntExp.vdmpp.result b/core/codegen/cgisa/src/test/resources/micro/Values/IntExp.vdmpp.result similarity index 100% rename from core/cgisa/src/test/resources/micro/Values/IntExp.vdmpp.result rename to core/codegen/cgisa/src/test/resources/micro/Values/IntExp.vdmpp.result diff --git a/core/cgisa/src/test/resources/micro/Values/IntExpVarExp.vdmpp b/core/codegen/cgisa/src/test/resources/micro/Values/IntExpVarExp.vdmpp similarity index 100% rename from core/cgisa/src/test/resources/micro/Values/IntExpVarExp.vdmpp rename to core/codegen/cgisa/src/test/resources/micro/Values/IntExpVarExp.vdmpp diff --git a/core/cgisa/src/test/resources/micro/Values/IntExpVarExp.vdmpp.result b/core/codegen/cgisa/src/test/resources/micro/Values/IntExpVarExp.vdmpp.result similarity index 100% rename from core/cgisa/src/test/resources/micro/Values/IntExpVarExp.vdmpp.result rename to core/codegen/cgisa/src/test/resources/micro/Values/IntExpVarExp.vdmpp.result diff --git a/core/cgisa/src/test/resources/micro/Values/SeqEnumApply.vdmpp b/core/codegen/cgisa/src/test/resources/micro/Values/SeqEnumApply.vdmpp similarity index 100% rename from core/cgisa/src/test/resources/micro/Values/SeqEnumApply.vdmpp rename to core/codegen/cgisa/src/test/resources/micro/Values/SeqEnumApply.vdmpp diff --git a/core/cgisa/src/test/resources/micro/Values/SeqEnumApply.vdmpp.result b/core/codegen/cgisa/src/test/resources/micro/Values/SeqEnumApply.vdmpp.result similarity index 100% rename from core/cgisa/src/test/resources/micro/Values/SeqEnumApply.vdmpp.result rename to core/codegen/cgisa/src/test/resources/micro/Values/SeqEnumApply.vdmpp.result diff --git a/core/cgisa/src/test/resources/micro/Values/StringApply.vdmpp b/core/codegen/cgisa/src/test/resources/micro/Values/StringApply.vdmpp similarity index 100% rename from core/cgisa/src/test/resources/micro/Values/StringApply.vdmpp rename to core/codegen/cgisa/src/test/resources/micro/Values/StringApply.vdmpp diff --git a/core/cgisa/src/test/resources/micro/Values/StringApply.vdmpp.result b/core/codegen/cgisa/src/test/resources/micro/Values/StringApply.vdmpp.result similarity index 100% rename from core/cgisa/src/test/resources/micro/Values/StringApply.vdmpp.result rename to core/codegen/cgisa/src/test/resources/micro/Values/StringApply.vdmpp.result diff --git a/core/cgisa/src/test/resources/test.vdmpp b/core/codegen/cgisa/src/test/resources/test.vdmpp similarity index 100% rename from core/cgisa/src/test/resources/test.vdmpp rename to core/codegen/cgisa/src/test/resources/test.vdmpp diff --git a/core/codegen-plugin/pom.xml b/core/codegen/codegen-maven-plugin/pom.xml similarity index 100% rename from core/codegen-plugin/pom.xml rename to core/codegen/codegen-maven-plugin/pom.xml diff --git a/core/codegen-plugin/src/main/java/org/overture/tools/maven/astcreator/AstCreatorBaseMojo.java b/core/codegen/codegen-maven-plugin/src/main/java/org/overture/tools/maven/astcreator/AstCreatorBaseMojo.java similarity index 100% rename from core/codegen-plugin/src/main/java/org/overture/tools/maven/astcreator/AstCreatorBaseMojo.java rename to core/codegen/codegen-maven-plugin/src/main/java/org/overture/tools/maven/astcreator/AstCreatorBaseMojo.java diff --git a/core/codegen-plugin/src/main/java/org/overture/tools/maven/astcreator/GenerateJavaSources.java b/core/codegen/codegen-maven-plugin/src/main/java/org/overture/tools/maven/astcreator/GenerateJavaSources.java similarity index 100% rename from core/codegen-plugin/src/main/java/org/overture/tools/maven/astcreator/GenerateJavaSources.java rename to core/codegen/codegen-maven-plugin/src/main/java/org/overture/tools/maven/astcreator/GenerateJavaSources.java diff --git a/core/codegen-plugin/src/main/java/org/overture/tools/maven/astcreator/VdmppNameFilter.java b/core/codegen/codegen-maven-plugin/src/main/java/org/overture/tools/maven/astcreator/VdmppNameFilter.java similarity index 100% rename from core/codegen-plugin/src/main/java/org/overture/tools/maven/astcreator/VdmppNameFilter.java rename to core/codegen/codegen-maven-plugin/src/main/java/org/overture/tools/maven/astcreator/VdmppNameFilter.java diff --git a/core/codegen-runtime/README.md b/core/codegen/codegen-runtime/README.md similarity index 100% rename from core/codegen-runtime/README.md rename to core/codegen/codegen-runtime/README.md diff --git a/core/codegen-runtime/pom.xml b/core/codegen/codegen-runtime/pom.xml similarity index 100% rename from core/codegen-runtime/pom.xml rename to core/codegen/codegen-runtime/pom.xml diff --git a/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/EvaluatePP.java b/core/codegen/codegen-runtime/src/main/java/org/overture/codegen/runtime/EvaluatePP.java similarity index 100% rename from core/codegen-runtime/src/main/java/org/overture/codegen/runtime/EvaluatePP.java rename to core/codegen/codegen-runtime/src/main/java/org/overture/codegen/runtime/EvaluatePP.java diff --git a/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/IO.java b/core/codegen/codegen-runtime/src/main/java/org/overture/codegen/runtime/IO.java similarity index 100% rename from core/codegen-runtime/src/main/java/org/overture/codegen/runtime/IO.java rename to core/codegen/codegen-runtime/src/main/java/org/overture/codegen/runtime/IO.java diff --git a/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/MATH.java b/core/codegen/codegen-runtime/src/main/java/org/overture/codegen/runtime/MATH.java similarity index 100% rename from core/codegen-runtime/src/main/java/org/overture/codegen/runtime/MATH.java rename to core/codegen/codegen-runtime/src/main/java/org/overture/codegen/runtime/MATH.java diff --git a/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/MapUtil.java b/core/codegen/codegen-runtime/src/main/java/org/overture/codegen/runtime/MapUtil.java similarity index 100% rename from core/codegen-runtime/src/main/java/org/overture/codegen/runtime/MapUtil.java rename to core/codegen/codegen-runtime/src/main/java/org/overture/codegen/runtime/MapUtil.java diff --git a/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/Maplet.java b/core/codegen/codegen-runtime/src/main/java/org/overture/codegen/runtime/Maplet.java similarity index 100% rename from core/codegen-runtime/src/main/java/org/overture/codegen/runtime/Maplet.java rename to core/codegen/codegen-runtime/src/main/java/org/overture/codegen/runtime/Maplet.java diff --git a/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/Record.java b/core/codegen/codegen-runtime/src/main/java/org/overture/codegen/runtime/Record.java similarity index 100% rename from core/codegen-runtime/src/main/java/org/overture/codegen/runtime/Record.java rename to core/codegen/codegen-runtime/src/main/java/org/overture/codegen/runtime/Record.java diff --git a/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/Sentinel.java b/core/codegen/codegen-runtime/src/main/java/org/overture/codegen/runtime/Sentinel.java similarity index 100% rename from core/codegen-runtime/src/main/java/org/overture/codegen/runtime/Sentinel.java rename to core/codegen/codegen-runtime/src/main/java/org/overture/codegen/runtime/Sentinel.java diff --git a/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/SeqUtil.java b/core/codegen/codegen-runtime/src/main/java/org/overture/codegen/runtime/SeqUtil.java similarity index 100% rename from core/codegen-runtime/src/main/java/org/overture/codegen/runtime/SeqUtil.java rename to core/codegen/codegen-runtime/src/main/java/org/overture/codegen/runtime/SeqUtil.java diff --git a/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/SetUtil.java b/core/codegen/codegen-runtime/src/main/java/org/overture/codegen/runtime/SetUtil.java similarity index 100% rename from core/codegen-runtime/src/main/java/org/overture/codegen/runtime/SetUtil.java rename to core/codegen/codegen-runtime/src/main/java/org/overture/codegen/runtime/SetUtil.java diff --git a/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/StaticOperationsCounters.java b/core/codegen/codegen-runtime/src/main/java/org/overture/codegen/runtime/StaticOperationsCounters.java similarity index 100% rename from core/codegen-runtime/src/main/java/org/overture/codegen/runtime/StaticOperationsCounters.java rename to core/codegen/codegen-runtime/src/main/java/org/overture/codegen/runtime/StaticOperationsCounters.java diff --git a/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/StaticSentinel.java b/core/codegen/codegen-runtime/src/main/java/org/overture/codegen/runtime/StaticSentinel.java similarity index 100% rename from core/codegen-runtime/src/main/java/org/overture/codegen/runtime/StaticSentinel.java rename to core/codegen/codegen-runtime/src/main/java/org/overture/codegen/runtime/StaticSentinel.java diff --git a/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/Token.java b/core/codegen/codegen-runtime/src/main/java/org/overture/codegen/runtime/Token.java similarity index 100% rename from core/codegen-runtime/src/main/java/org/overture/codegen/runtime/Token.java rename to core/codegen/codegen-runtime/src/main/java/org/overture/codegen/runtime/Token.java diff --git a/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/Tuple.java b/core/codegen/codegen-runtime/src/main/java/org/overture/codegen/runtime/Tuple.java similarity index 100% rename from core/codegen-runtime/src/main/java/org/overture/codegen/runtime/Tuple.java rename to core/codegen/codegen-runtime/src/main/java/org/overture/codegen/runtime/Tuple.java diff --git a/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/Utils.java b/core/codegen/codegen-runtime/src/main/java/org/overture/codegen/runtime/Utils.java similarity index 100% rename from core/codegen-runtime/src/main/java/org/overture/codegen/runtime/Utils.java rename to core/codegen/codegen-runtime/src/main/java/org/overture/codegen/runtime/Utils.java diff --git a/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/VDMMap.java b/core/codegen/codegen-runtime/src/main/java/org/overture/codegen/runtime/VDMMap.java similarity index 100% rename from core/codegen-runtime/src/main/java/org/overture/codegen/runtime/VDMMap.java rename to core/codegen/codegen-runtime/src/main/java/org/overture/codegen/runtime/VDMMap.java diff --git a/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/VDMSeq.java b/core/codegen/codegen-runtime/src/main/java/org/overture/codegen/runtime/VDMSeq.java similarity index 100% rename from core/codegen-runtime/src/main/java/org/overture/codegen/runtime/VDMSeq.java rename to core/codegen/codegen-runtime/src/main/java/org/overture/codegen/runtime/VDMSeq.java diff --git a/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/VDMSet.java b/core/codegen/codegen-runtime/src/main/java/org/overture/codegen/runtime/VDMSet.java similarity index 100% rename from core/codegen-runtime/src/main/java/org/overture/codegen/runtime/VDMSet.java rename to core/codegen/codegen-runtime/src/main/java/org/overture/codegen/runtime/VDMSet.java diff --git a/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/VDMThread.java b/core/codegen/codegen-runtime/src/main/java/org/overture/codegen/runtime/VDMThread.java similarity index 100% rename from core/codegen-runtime/src/main/java/org/overture/codegen/runtime/VDMThread.java rename to core/codegen/codegen-runtime/src/main/java/org/overture/codegen/runtime/VDMThread.java diff --git a/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/VDMUtil.java b/core/codegen/codegen-runtime/src/main/java/org/overture/codegen/runtime/VDMUtil.java similarity index 100% rename from core/codegen-runtime/src/main/java/org/overture/codegen/runtime/VDMUtil.java rename to core/codegen/codegen-runtime/src/main/java/org/overture/codegen/runtime/VDMUtil.java diff --git a/core/codegen-runtime/src/main/java/org/overture/codegen/runtime/ValueType.java b/core/codegen/codegen-runtime/src/main/java/org/overture/codegen/runtime/ValueType.java similarity index 100% rename from core/codegen-runtime/src/main/java/org/overture/codegen/runtime/ValueType.java rename to core/codegen/codegen-runtime/src/main/java/org/overture/codegen/runtime/ValueType.java diff --git a/core/codegen-runtime/src/test/java/IOTest.java b/core/codegen/codegen-runtime/src/test/java/IOTest.java similarity index 100% rename from core/codegen-runtime/src/test/java/IOTest.java rename to core/codegen/codegen-runtime/src/test/java/IOTest.java diff --git a/core/codegen/pom.xml b/core/codegen/javagen/pom.xml similarity index 100% rename from core/codegen/pom.xml rename to core/codegen/javagen/pom.xml diff --git a/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/AbstractAnalysis.java b/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/AbstractAnalysis.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/analysis/vdm/AbstractAnalysis.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/AbstractAnalysis.java diff --git a/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/DefinitionInfo.java b/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/DefinitionInfo.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/analysis/vdm/DefinitionInfo.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/DefinitionInfo.java diff --git a/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/IdDesignatorOccurencesCollector.java b/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/IdDesignatorOccurencesCollector.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/analysis/vdm/IdDesignatorOccurencesCollector.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/IdDesignatorOccurencesCollector.java diff --git a/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/IdOccurencesCollector.java b/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/IdOccurencesCollector.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/analysis/vdm/IdOccurencesCollector.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/IdOccurencesCollector.java diff --git a/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/IdStateDesignatorDefCollector.java b/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/IdStateDesignatorDefCollector.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/analysis/vdm/IdStateDesignatorDefCollector.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/IdStateDesignatorDefCollector.java diff --git a/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/JavaIdentifierNormaliser.java b/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/JavaIdentifierNormaliser.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/analysis/vdm/JavaIdentifierNormaliser.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/JavaIdentifierNormaliser.java diff --git a/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/NameCollector.java b/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/NameCollector.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/analysis/vdm/NameCollector.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/NameCollector.java diff --git a/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/QuoteAnalysis.java b/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/QuoteAnalysis.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/analysis/vdm/QuoteAnalysis.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/QuoteAnalysis.java diff --git a/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/RenameAnalysis.java b/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/RenameAnalysis.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/analysis/vdm/RenameAnalysis.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/RenameAnalysis.java diff --git a/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/Renaming.java b/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/Renaming.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/analysis/vdm/Renaming.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/Renaming.java diff --git a/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/UnreachableStmRemover.java b/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/UnreachableStmRemover.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/analysis/vdm/UnreachableStmRemover.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/UnreachableStmRemover.java diff --git a/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/UtilAnalysis.java b/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/UtilAnalysis.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/analysis/vdm/UtilAnalysis.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/UtilAnalysis.java diff --git a/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/VarOccurencesCollector.java b/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/VarOccurencesCollector.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/analysis/vdm/VarOccurencesCollector.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/VarOccurencesCollector.java diff --git a/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/VarRenamer.java b/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/VarRenamer.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/analysis/vdm/VarRenamer.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/VarRenamer.java diff --git a/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/VarShadowingRenameCollector.java b/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/VarShadowingRenameCollector.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/analysis/vdm/VarShadowingRenameCollector.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/VarShadowingRenameCollector.java diff --git a/core/codegen/src/main/java/org/overture/codegen/analysis/vdm/VdmAnalysis.java b/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/VdmAnalysis.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/analysis/vdm/VdmAnalysis.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/VdmAnalysis.java diff --git a/core/codegen/src/main/java/org/overture/codegen/analysis/violations/GeneratedVarComparison.java b/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/violations/GeneratedVarComparison.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/analysis/violations/GeneratedVarComparison.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/analysis/violations/GeneratedVarComparison.java diff --git a/core/codegen/src/main/java/org/overture/codegen/analysis/violations/InvalidNamesResult.java b/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/violations/InvalidNamesResult.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/analysis/violations/InvalidNamesResult.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/analysis/violations/InvalidNamesResult.java diff --git a/core/codegen/src/main/java/org/overture/codegen/analysis/violations/ModelingViolationAnalysis.java b/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/violations/ModelingViolationAnalysis.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/analysis/violations/ModelingViolationAnalysis.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/analysis/violations/ModelingViolationAnalysis.java diff --git a/core/codegen/src/main/java/org/overture/codegen/analysis/violations/NameViolationAnalysis.java b/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/violations/NameViolationAnalysis.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/analysis/violations/NameViolationAnalysis.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/analysis/violations/NameViolationAnalysis.java diff --git a/core/codegen/src/main/java/org/overture/codegen/analysis/violations/NamingComparison.java b/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/violations/NamingComparison.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/analysis/violations/NamingComparison.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/analysis/violations/NamingComparison.java diff --git a/core/codegen/src/main/java/org/overture/codegen/analysis/violations/ReservedWordsComparison.java b/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/violations/ReservedWordsComparison.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/analysis/violations/ReservedWordsComparison.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/analysis/violations/ReservedWordsComparison.java diff --git a/core/codegen/src/main/java/org/overture/codegen/analysis/violations/TypenameComparison.java b/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/violations/TypenameComparison.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/analysis/violations/TypenameComparison.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/analysis/violations/TypenameComparison.java diff --git a/core/codegen/src/main/java/org/overture/codegen/analysis/violations/UnsupportedModelingException.java b/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/violations/UnsupportedModelingException.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/analysis/violations/UnsupportedModelingException.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/analysis/violations/UnsupportedModelingException.java diff --git a/core/codegen/src/main/java/org/overture/codegen/analysis/violations/VdmAstAnalysis.java b/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/violations/VdmAstAnalysis.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/analysis/violations/VdmAstAnalysis.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/analysis/violations/VdmAstAnalysis.java diff --git a/core/codegen/src/main/java/org/overture/codegen/analysis/violations/Violation.java b/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/violations/Violation.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/analysis/violations/Violation.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/analysis/violations/Violation.java diff --git a/core/codegen/src/main/java/org/overture/codegen/analysis/violations/ViolationAnalysis.java b/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/violations/ViolationAnalysis.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/analysis/violations/ViolationAnalysis.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/analysis/violations/ViolationAnalysis.java diff --git a/core/codegen/src/main/java/org/overture/codegen/assistant/AssistantBase.java b/core/codegen/javagen/src/main/java/org/overture/codegen/assistant/AssistantBase.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/assistant/AssistantBase.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/assistant/AssistantBase.java diff --git a/core/codegen/src/main/java/org/overture/codegen/assistant/AssistantManager.java b/core/codegen/javagen/src/main/java/org/overture/codegen/assistant/AssistantManager.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/assistant/AssistantManager.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/assistant/AssistantManager.java diff --git a/core/codegen/src/main/java/org/overture/codegen/assistant/BindAssistantCG.java b/core/codegen/javagen/src/main/java/org/overture/codegen/assistant/BindAssistantCG.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/assistant/BindAssistantCG.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/assistant/BindAssistantCG.java diff --git a/core/codegen/src/main/java/org/overture/codegen/assistant/CollectionTypeStrategy.java b/core/codegen/javagen/src/main/java/org/overture/codegen/assistant/CollectionTypeStrategy.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/assistant/CollectionTypeStrategy.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/assistant/CollectionTypeStrategy.java diff --git a/core/codegen/src/main/java/org/overture/codegen/assistant/DeclAssistantCG.java b/core/codegen/javagen/src/main/java/org/overture/codegen/assistant/DeclAssistantCG.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/assistant/DeclAssistantCG.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/assistant/DeclAssistantCG.java diff --git a/core/codegen/src/main/java/org/overture/codegen/assistant/DeclStrategy.java b/core/codegen/javagen/src/main/java/org/overture/codegen/assistant/DeclStrategy.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/assistant/DeclStrategy.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/assistant/DeclStrategy.java diff --git a/core/codegen/src/main/java/org/overture/codegen/assistant/ExpAssistantCG.java b/core/codegen/javagen/src/main/java/org/overture/codegen/assistant/ExpAssistantCG.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/assistant/ExpAssistantCG.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/assistant/ExpAssistantCG.java diff --git a/core/codegen/src/main/java/org/overture/codegen/assistant/LocationAssistantCG.java b/core/codegen/javagen/src/main/java/org/overture/codegen/assistant/LocationAssistantCG.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/assistant/LocationAssistantCG.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/assistant/LocationAssistantCG.java diff --git a/core/codegen/src/main/java/org/overture/codegen/assistant/StmAssistantCG.java b/core/codegen/javagen/src/main/java/org/overture/codegen/assistant/StmAssistantCG.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/assistant/StmAssistantCG.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/assistant/StmAssistantCG.java diff --git a/core/codegen/src/main/java/org/overture/codegen/assistant/TypeAssistantCG.java b/core/codegen/javagen/src/main/java/org/overture/codegen/assistant/TypeAssistantCG.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/assistant/TypeAssistantCG.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/assistant/TypeAssistantCG.java diff --git a/core/codegen/src/main/java/org/overture/codegen/ir/CodeGenBase.java b/core/codegen/javagen/src/main/java/org/overture/codegen/ir/CodeGenBase.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/ir/CodeGenBase.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/ir/CodeGenBase.java diff --git a/core/codegen/src/main/java/org/overture/codegen/ir/IRAnalysis.java b/core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRAnalysis.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/ir/IRAnalysis.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRAnalysis.java diff --git a/core/codegen/src/main/java/org/overture/codegen/ir/IRClassDeclStatus.java b/core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRClassDeclStatus.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/ir/IRClassDeclStatus.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRClassDeclStatus.java diff --git a/core/codegen/src/main/java/org/overture/codegen/ir/IRConstants.java b/core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRConstants.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/ir/IRConstants.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRConstants.java diff --git a/core/codegen/src/main/java/org/overture/codegen/ir/IRExpStatus.java b/core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRExpStatus.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/ir/IRExpStatus.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRExpStatus.java diff --git a/core/codegen/src/main/java/org/overture/codegen/ir/IRGeneratedTag.java b/core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRGeneratedTag.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/ir/IRGeneratedTag.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRGeneratedTag.java diff --git a/core/codegen/src/main/java/org/overture/codegen/ir/IRGenerator.java b/core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRGenerator.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/ir/IRGenerator.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRGenerator.java diff --git a/core/codegen/src/main/java/org/overture/codegen/ir/IRInfo.java b/core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRInfo.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/ir/IRInfo.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRInfo.java diff --git a/core/codegen/src/main/java/org/overture/codegen/ir/IRNamedTypeInvariantTag.java b/core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRNamedTypeInvariantTag.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/ir/IRNamedTypeInvariantTag.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRNamedTypeInvariantTag.java diff --git a/core/codegen/src/main/java/org/overture/codegen/ir/IROperatorInfo.java b/core/codegen/javagen/src/main/java/org/overture/codegen/ir/IROperatorInfo.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/ir/IROperatorInfo.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/ir/IROperatorInfo.java diff --git a/core/codegen/src/main/java/org/overture/codegen/ir/IROperatorLookup.java b/core/codegen/javagen/src/main/java/org/overture/codegen/ir/IROperatorLookup.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/ir/IROperatorLookup.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/ir/IROperatorLookup.java diff --git a/core/codegen/src/main/java/org/overture/codegen/ir/IRSettings.java b/core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRSettings.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/ir/IRSettings.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRSettings.java diff --git a/core/codegen/src/main/java/org/overture/codegen/ir/IRStatus.java b/core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRStatus.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/ir/IRStatus.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRStatus.java diff --git a/core/codegen/src/main/java/org/overture/codegen/ir/ITempVarGen.java b/core/codegen/javagen/src/main/java/org/overture/codegen/ir/ITempVarGen.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/ir/ITempVarGen.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/ir/ITempVarGen.java diff --git a/core/codegen/src/main/java/org/overture/codegen/ir/IrNodeInfo.java b/core/codegen/javagen/src/main/java/org/overture/codegen/ir/IrNodeInfo.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/ir/IrNodeInfo.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/ir/IrNodeInfo.java diff --git a/core/codegen/src/main/java/org/overture/codegen/ir/SourceNode.java b/core/codegen/javagen/src/main/java/org/overture/codegen/ir/SourceNode.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/ir/SourceNode.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/ir/SourceNode.java diff --git a/core/codegen/src/main/java/org/overture/codegen/ir/TempVarNameGen.java b/core/codegen/javagen/src/main/java/org/overture/codegen/ir/TempVarNameGen.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/ir/TempVarNameGen.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/ir/TempVarNameGen.java diff --git a/core/codegen/src/main/java/org/overture/codegen/ir/VdmNodeInfo.java b/core/codegen/javagen/src/main/java/org/overture/codegen/ir/VdmNodeInfo.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/ir/VdmNodeInfo.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/ir/VdmNodeInfo.java diff --git a/core/codegen/src/main/java/org/overture/codegen/logging/DefaultLogger.java b/core/codegen/javagen/src/main/java/org/overture/codegen/logging/DefaultLogger.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/logging/DefaultLogger.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/logging/DefaultLogger.java diff --git a/core/codegen/src/main/java/org/overture/codegen/logging/ILogger.java b/core/codegen/javagen/src/main/java/org/overture/codegen/logging/ILogger.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/logging/ILogger.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/logging/ILogger.java diff --git a/core/codegen/src/main/java/org/overture/codegen/logging/Logger.java b/core/codegen/javagen/src/main/java/org/overture/codegen/logging/Logger.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/logging/Logger.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/logging/Logger.java diff --git a/core/codegen/src/main/java/org/overture/codegen/merging/MergeContext.java b/core/codegen/javagen/src/main/java/org/overture/codegen/merging/MergeContext.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/merging/MergeContext.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/merging/MergeContext.java diff --git a/core/codegen/src/main/java/org/overture/codegen/merging/MergeVisitor.java b/core/codegen/javagen/src/main/java/org/overture/codegen/merging/MergeVisitor.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/merging/MergeVisitor.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/merging/MergeVisitor.java diff --git a/core/codegen/src/main/java/org/overture/codegen/merging/TemplateCallable.java b/core/codegen/javagen/src/main/java/org/overture/codegen/merging/TemplateCallable.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/merging/TemplateCallable.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/merging/TemplateCallable.java diff --git a/core/codegen/src/main/java/org/overture/codegen/merging/TemplateManager.java b/core/codegen/javagen/src/main/java/org/overture/codegen/merging/TemplateManager.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/merging/TemplateManager.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/merging/TemplateManager.java diff --git a/core/codegen/src/main/java/org/overture/codegen/merging/TemplateStructure.java b/core/codegen/javagen/src/main/java/org/overture/codegen/merging/TemplateStructure.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/merging/TemplateStructure.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/merging/TemplateStructure.java diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/EnsureLocalObjDesignatorAnalysis.java b/core/codegen/javagen/src/main/java/org/overture/codegen/traces/EnsureLocalObjDesignatorAnalysis.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/traces/EnsureLocalObjDesignatorAnalysis.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/traces/EnsureLocalObjDesignatorAnalysis.java diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/ICallStmToStringMethodBuilder.java b/core/codegen/javagen/src/main/java/org/overture/codegen/traces/ICallStmToStringMethodBuilder.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/traces/ICallStmToStringMethodBuilder.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/traces/ICallStmToStringMethodBuilder.java diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/IdentifierPatternCollector.java b/core/codegen/javagen/src/main/java/org/overture/codegen/traces/IdentifierPatternCollector.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/traces/IdentifierPatternCollector.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/traces/IdentifierPatternCollector.java diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/JavaCallStmToStringBuilder.java b/core/codegen/javagen/src/main/java/org/overture/codegen/traces/JavaCallStmToStringBuilder.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/traces/JavaCallStmToStringBuilder.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/traces/JavaCallStmToStringBuilder.java diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/StoreAssistant.java b/core/codegen/javagen/src/main/java/org/overture/codegen/traces/StoreAssistant.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/traces/StoreAssistant.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/traces/StoreAssistant.java diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/TermVisitorCG.java b/core/codegen/javagen/src/main/java/org/overture/codegen/traces/TermVisitorCG.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/traces/TermVisitorCG.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/traces/TermVisitorCG.java diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/TraceCoreDeclVisitorCG.java b/core/codegen/javagen/src/main/java/org/overture/codegen/traces/TraceCoreDeclVisitorCG.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/traces/TraceCoreDeclVisitorCG.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/traces/TraceCoreDeclVisitorCG.java diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/TraceDeclVisitorCG.java b/core/codegen/javagen/src/main/java/org/overture/codegen/traces/TraceDeclVisitorCG.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/traces/TraceDeclVisitorCG.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/traces/TraceDeclVisitorCG.java diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/TraceLetBeStStrategy.java b/core/codegen/javagen/src/main/java/org/overture/codegen/traces/TraceLetBeStStrategy.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/traces/TraceLetBeStStrategy.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/traces/TraceLetBeStStrategy.java diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/TraceNames.java b/core/codegen/javagen/src/main/java/org/overture/codegen/traces/TraceNames.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/traces/TraceNames.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/traces/TraceNames.java diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/TraceNodeData.java b/core/codegen/javagen/src/main/java/org/overture/codegen/traces/TraceNodeData.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/traces/TraceNodeData.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/traces/TraceNodeData.java diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/TraceStmsBuilder.java b/core/codegen/javagen/src/main/java/org/overture/codegen/traces/TraceStmsBuilder.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/traces/TraceStmsBuilder.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/traces/TraceStmsBuilder.java diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/TraceSupportedAnalysis.java b/core/codegen/javagen/src/main/java/org/overture/codegen/traces/TraceSupportedAnalysis.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/traces/TraceSupportedAnalysis.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/traces/TraceSupportedAnalysis.java diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/TracesTransformation.java b/core/codegen/javagen/src/main/java/org/overture/codegen/traces/TracesTransformation.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/traces/TracesTransformation.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/traces/TracesTransformation.java diff --git a/core/codegen/src/main/java/org/overture/codegen/traces/VarExpCasting.java b/core/codegen/javagen/src/main/java/org/overture/codegen/traces/VarExpCasting.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/traces/VarExpCasting.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/traces/VarExpCasting.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/AbstractIterationStrategy.java b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/AbstractIterationStrategy.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/trans/AbstractIterationStrategy.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/trans/AbstractIterationStrategy.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/AssignStmTransformation.java b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/AssignStmTransformation.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/trans/AssignStmTransformation.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/trans/AssignStmTransformation.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/CallObjStmTransformation.java b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/CallObjStmTransformation.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/trans/CallObjStmTransformation.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/trans/CallObjStmTransformation.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/DeclarationTag.java b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/DeclarationTag.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/trans/DeclarationTag.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/trans/DeclarationTag.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/IIterationStrategy.java b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/IIterationStrategy.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/trans/IIterationStrategy.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/trans/IIterationStrategy.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/IPostCheckCreator.java b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/IPostCheckCreator.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/trans/IPostCheckCreator.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/trans/IPostCheckCreator.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/IsExpTransformation.java b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/IsExpTransformation.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/trans/IsExpTransformation.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/trans/IsExpTransformation.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/PostCheckTransformation.java b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/PostCheckTransformation.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/trans/PostCheckTransformation.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/trans/PostCheckTransformation.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/PreCheckTransformation.java b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/PreCheckTransformation.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/trans/PreCheckTransformation.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/trans/PreCheckTransformation.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/PrePostTransformation.java b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/PrePostTransformation.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/trans/PrePostTransformation.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/trans/PrePostTransformation.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/SeqConversionTransformation.java b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/SeqConversionTransformation.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/trans/SeqConversionTransformation.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/trans/SeqConversionTransformation.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/TempVarPrefixes.java b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/TempVarPrefixes.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/trans/TempVarPrefixes.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/trans/TempVarPrefixes.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/TransformationVisitor.java b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/TransformationVisitor.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/trans/TransformationVisitor.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/trans/TransformationVisitor.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/assistants/BaseTransformationAssistant.java b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/assistants/BaseTransformationAssistant.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/trans/assistants/BaseTransformationAssistant.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/trans/assistants/BaseTransformationAssistant.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/assistants/TransAssistantCG.java b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/assistants/TransAssistantCG.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/trans/assistants/TransAssistantCG.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/trans/assistants/TransAssistantCG.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/comp/CompStrategy.java b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/comp/CompStrategy.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/trans/comp/CompStrategy.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/trans/comp/CompStrategy.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/comp/ComplexCompStrategy.java b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/comp/ComplexCompStrategy.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/trans/comp/ComplexCompStrategy.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/trans/comp/ComplexCompStrategy.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/comp/MapCompStrategy.java b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/comp/MapCompStrategy.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/trans/comp/MapCompStrategy.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/trans/comp/MapCompStrategy.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/comp/SeqCompStrategy.java b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/comp/SeqCompStrategy.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/trans/comp/SeqCompStrategy.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/trans/comp/SeqCompStrategy.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/comp/SetCompStrategy.java b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/comp/SetCompStrategy.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/trans/comp/SetCompStrategy.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/trans/comp/SetCompStrategy.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/conc/InstanceVarPPEvalTransformation.java b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/conc/InstanceVarPPEvalTransformation.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/trans/conc/InstanceVarPPEvalTransformation.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/trans/conc/InstanceVarPPEvalTransformation.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/conc/MainClassConcTransformation.java b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/conc/MainClassConcTransformation.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/trans/conc/MainClassConcTransformation.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/trans/conc/MainClassConcTransformation.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/conc/MutexDeclTransformation.java b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/conc/MutexDeclTransformation.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/trans/conc/MutexDeclTransformation.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/trans/conc/MutexDeclTransformation.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/conc/SentinelTransformation.java b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/conc/SentinelTransformation.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/trans/conc/SentinelTransformation.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/trans/conc/SentinelTransformation.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/conv/ObjectDesignatorToExpCG.java b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/conv/ObjectDesignatorToExpCG.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/trans/conv/ObjectDesignatorToExpCG.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/trans/conv/ObjectDesignatorToExpCG.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/conv/StateDesignatorToExpCG.java b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/conv/StateDesignatorToExpCG.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/trans/conv/StateDesignatorToExpCG.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/trans/conv/StateDesignatorToExpCG.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/funcvalues/FunctionValueAssistant.java b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/funcvalues/FunctionValueAssistant.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/trans/funcvalues/FunctionValueAssistant.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/trans/funcvalues/FunctionValueAssistant.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/funcvalues/FunctionValueTransformation.java b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/funcvalues/FunctionValueTransformation.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/trans/funcvalues/FunctionValueTransformation.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/trans/funcvalues/FunctionValueTransformation.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/iterator/AbstractLanguageIterator.java b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/iterator/AbstractLanguageIterator.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/trans/iterator/AbstractLanguageIterator.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/trans/iterator/AbstractLanguageIterator.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/iterator/ILanguageIterator.java b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/iterator/ILanguageIterator.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/trans/iterator/ILanguageIterator.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/trans/iterator/ILanguageIterator.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/iterator/JavaLanguageIterator.java b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/iterator/JavaLanguageIterator.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/trans/iterator/JavaLanguageIterator.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/trans/iterator/JavaLanguageIterator.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/let/LetBeStStrategy.java b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/let/LetBeStStrategy.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/trans/let/LetBeStStrategy.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/trans/let/LetBeStStrategy.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/letexps/FuncTransformation.java b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/letexps/FuncTransformation.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/trans/letexps/FuncTransformation.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/trans/letexps/FuncTransformation.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/letexps/IfExpTransformation.java b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/letexps/IfExpTransformation.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/trans/letexps/IfExpTransformation.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/trans/letexps/IfExpTransformation.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/patterns/DeclBlockPair.java b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/patterns/DeclBlockPair.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/trans/patterns/DeclBlockPair.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/trans/patterns/DeclBlockPair.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/patterns/MismatchHandling.java b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/patterns/MismatchHandling.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/trans/patterns/MismatchHandling.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/trans/patterns/MismatchHandling.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/patterns/PatternBlockData.java b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/patterns/PatternBlockData.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/trans/patterns/PatternBlockData.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/trans/patterns/PatternBlockData.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/patterns/PatternInfo.java b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/patterns/PatternInfo.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/trans/patterns/PatternInfo.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/trans/patterns/PatternInfo.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/patterns/PatternMatchConfig.java b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/patterns/PatternMatchConfig.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/trans/patterns/PatternMatchConfig.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/trans/patterns/PatternMatchConfig.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/patterns/PatternTransformation.java b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/patterns/PatternTransformation.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/trans/patterns/PatternTransformation.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/trans/patterns/PatternTransformation.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/quantifier/Exists1CounterData.java b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/quantifier/Exists1CounterData.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/trans/quantifier/Exists1CounterData.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/trans/quantifier/Exists1CounterData.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/quantifier/Exists1QuantifierStrategy.java b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/quantifier/Exists1QuantifierStrategy.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/trans/quantifier/Exists1QuantifierStrategy.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/trans/quantifier/Exists1QuantifierStrategy.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/quantifier/OrdinaryQuantifier.java b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/quantifier/OrdinaryQuantifier.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/trans/quantifier/OrdinaryQuantifier.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/trans/quantifier/OrdinaryQuantifier.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/quantifier/OrdinaryQuantifierStrategy.java b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/quantifier/OrdinaryQuantifierStrategy.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/trans/quantifier/OrdinaryQuantifierStrategy.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/trans/quantifier/OrdinaryQuantifierStrategy.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/quantifier/QuantifierBaseStrategy.java b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/quantifier/QuantifierBaseStrategy.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/trans/quantifier/QuantifierBaseStrategy.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/trans/quantifier/QuantifierBaseStrategy.java diff --git a/core/codegen/src/main/java/org/overture/codegen/trans/uniontypes/UnionTypeTransformation.java b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/uniontypes/UnionTypeTransformation.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/trans/uniontypes/UnionTypeTransformation.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/trans/uniontypes/UnionTypeTransformation.java diff --git a/core/codegen/src/main/java/org/overture/codegen/utils/AnalysisExceptionCG.java b/core/codegen/javagen/src/main/java/org/overture/codegen/utils/AnalysisExceptionCG.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/utils/AnalysisExceptionCG.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/utils/AnalysisExceptionCG.java diff --git a/core/codegen/src/main/java/org/overture/codegen/utils/GeneralCodeGenUtils.java b/core/codegen/javagen/src/main/java/org/overture/codegen/utils/GeneralCodeGenUtils.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/utils/GeneralCodeGenUtils.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/utils/GeneralCodeGenUtils.java diff --git a/core/codegen/src/main/java/org/overture/codegen/utils/GeneralUtils.java b/core/codegen/javagen/src/main/java/org/overture/codegen/utils/GeneralUtils.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/utils/GeneralUtils.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/utils/GeneralUtils.java diff --git a/core/codegen/src/main/java/org/overture/codegen/utils/Generated.java b/core/codegen/javagen/src/main/java/org/overture/codegen/utils/Generated.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/utils/Generated.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/utils/Generated.java diff --git a/core/codegen/src/main/java/org/overture/codegen/utils/GeneratedData.java b/core/codegen/javagen/src/main/java/org/overture/codegen/utils/GeneratedData.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/utils/GeneratedData.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/utils/GeneratedData.java diff --git a/core/codegen/src/main/java/org/overture/codegen/utils/GeneratedModule.java b/core/codegen/javagen/src/main/java/org/overture/codegen/utils/GeneratedModule.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/utils/GeneratedModule.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/utils/GeneratedModule.java diff --git a/core/codegen/src/main/java/org/overture/codegen/utils/LexNameTokenWrapper.java b/core/codegen/javagen/src/main/java/org/overture/codegen/utils/LexNameTokenWrapper.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/utils/LexNameTokenWrapper.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/utils/LexNameTokenWrapper.java diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/IJavaCodeGenConstants.java b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/IJavaCodeGenConstants.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/vdm2java/IJavaCodeGenConstants.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/IJavaCodeGenConstants.java diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaClassCreator.java b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaClassCreator.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaClassCreator.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaClassCreator.java diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaClassCreatorBase.java b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaClassCreatorBase.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaClassCreatorBase.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaClassCreatorBase.java diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaClassToStringTrans.java b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaClassToStringTrans.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaClassToStringTrans.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaClassToStringTrans.java diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGenMain.java b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGenMain.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGenMain.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGenMain.java diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGenUtil.java b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGenUtil.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGenUtil.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGenUtil.java diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaFormat.java b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaFormat.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaFormat.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaFormat.java diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaFormatAssistant.java b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaFormatAssistant.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaFormatAssistant.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaFormatAssistant.java diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaMainTag.java b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaMainTag.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaMainTag.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaMainTag.java diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaPostCheckCreator.java b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaPostCheckCreator.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaPostCheckCreator.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaPostCheckCreator.java diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaPrecedence.java b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaPrecedence.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaPrecedence.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaPrecedence.java diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaQuoteValueCreator.java b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaQuoteValueCreator.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaQuoteValueCreator.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaQuoteValueCreator.java diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaRecordCreator.java b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaRecordCreator.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaRecordCreator.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaRecordCreator.java diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaSettings.java b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaSettings.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaSettings.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaSettings.java diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaTransSeries.java b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaTransSeries.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaTransSeries.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaTransSeries.java diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaValueSemantics.java b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaValueSemantics.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaValueSemantics.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaValueSemantics.java diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaValueSemanticsTag.java b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaValueSemanticsTag.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/vdm2java/JavaValueSemanticsTag.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaValueSemanticsTag.java diff --git a/core/codegen/src/main/java/org/overture/codegen/vdm2java/TemplateCallableManager.java b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/TemplateCallableManager.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/vdm2java/TemplateCallableManager.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/TemplateCallableManager.java diff --git a/core/codegen/src/main/java/org/overture/codegen/visitor/AbstractVisitorCG.java b/core/codegen/javagen/src/main/java/org/overture/codegen/visitor/AbstractVisitorCG.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/visitor/AbstractVisitorCG.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/visitor/AbstractVisitorCG.java diff --git a/core/codegen/src/main/java/org/overture/codegen/visitor/BindVisitorCG.java b/core/codegen/javagen/src/main/java/org/overture/codegen/visitor/BindVisitorCG.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/visitor/BindVisitorCG.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/visitor/BindVisitorCG.java diff --git a/core/codegen/src/main/java/org/overture/codegen/visitor/CGVisitor.java b/core/codegen/javagen/src/main/java/org/overture/codegen/visitor/CGVisitor.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/visitor/CGVisitor.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/visitor/CGVisitor.java diff --git a/core/codegen/src/main/java/org/overture/codegen/visitor/CGVisitorRecursiveTypeHandler.java b/core/codegen/javagen/src/main/java/org/overture/codegen/visitor/CGVisitorRecursiveTypeHandler.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/visitor/CGVisitorRecursiveTypeHandler.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/visitor/CGVisitorRecursiveTypeHandler.java diff --git a/core/codegen/src/main/java/org/overture/codegen/visitor/ClassVisitorCG.java b/core/codegen/javagen/src/main/java/org/overture/codegen/visitor/ClassVisitorCG.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/visitor/ClassVisitorCG.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/visitor/ClassVisitorCG.java diff --git a/core/codegen/src/main/java/org/overture/codegen/visitor/DeclVisitorCG.java b/core/codegen/javagen/src/main/java/org/overture/codegen/visitor/DeclVisitorCG.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/visitor/DeclVisitorCG.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/visitor/DeclVisitorCG.java diff --git a/core/codegen/src/main/java/org/overture/codegen/visitor/ExpVisitorCG.java b/core/codegen/javagen/src/main/java/org/overture/codegen/visitor/ExpVisitorCG.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/visitor/ExpVisitorCG.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/visitor/ExpVisitorCG.java diff --git a/core/codegen/src/main/java/org/overture/codegen/visitor/ModifierVisitorCG.java b/core/codegen/javagen/src/main/java/org/overture/codegen/visitor/ModifierVisitorCG.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/visitor/ModifierVisitorCG.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/visitor/ModifierVisitorCG.java diff --git a/core/codegen/src/main/java/org/overture/codegen/visitor/MultipleBindVisitorCG.java b/core/codegen/javagen/src/main/java/org/overture/codegen/visitor/MultipleBindVisitorCG.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/visitor/MultipleBindVisitorCG.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/visitor/MultipleBindVisitorCG.java diff --git a/core/codegen/src/main/java/org/overture/codegen/visitor/ObjectDesignatorVisitorCG.java b/core/codegen/javagen/src/main/java/org/overture/codegen/visitor/ObjectDesignatorVisitorCG.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/visitor/ObjectDesignatorVisitorCG.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/visitor/ObjectDesignatorVisitorCG.java diff --git a/core/codegen/src/main/java/org/overture/codegen/visitor/PatternVisitorCG.java b/core/codegen/javagen/src/main/java/org/overture/codegen/visitor/PatternVisitorCG.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/visitor/PatternVisitorCG.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/visitor/PatternVisitorCG.java diff --git a/core/codegen/src/main/java/org/overture/codegen/visitor/StateDesignatorVisitorCG.java b/core/codegen/javagen/src/main/java/org/overture/codegen/visitor/StateDesignatorVisitorCG.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/visitor/StateDesignatorVisitorCG.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/visitor/StateDesignatorVisitorCG.java diff --git a/core/codegen/src/main/java/org/overture/codegen/visitor/StmVisitorCG.java b/core/codegen/javagen/src/main/java/org/overture/codegen/visitor/StmVisitorCG.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/visitor/StmVisitorCG.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/visitor/StmVisitorCG.java diff --git a/core/codegen/src/main/java/org/overture/codegen/visitor/TypeVisitorCG.java b/core/codegen/javagen/src/main/java/org/overture/codegen/visitor/TypeVisitorCG.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/visitor/TypeVisitorCG.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/visitor/TypeVisitorCG.java diff --git a/core/codegen/src/main/java/org/overture/codegen/visitor/VisitorManager.java b/core/codegen/javagen/src/main/java/org/overture/codegen/visitor/VisitorManager.java similarity index 100% rename from core/codegen/src/main/java/org/overture/codegen/visitor/VisitorManager.java rename to core/codegen/javagen/src/main/java/org/overture/codegen/visitor/VisitorManager.java diff --git a/core/codegen/src/main/resources/JavaTemplates/Declarations/CatchClause.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Declarations/CatchClause.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Declarations/CatchClause.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Declarations/CatchClause.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Declarations/Class.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Declarations/Class.vm similarity index 96% rename from core/codegen/src/main/resources/JavaTemplates/Declarations/Class.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Declarations/Class.vm index 46a7ad9585..03634f763d 100644 --- a/core/codegen/src/main/resources/JavaTemplates/Declarations/Class.vm +++ b/core/codegen/javagen/src/main/resources/JavaTemplates/Declarations/Class.vm @@ -1,60 +1,60 @@ -#set( $package = "") -#if (!$JavaFormat.isNull($node.getPackage())) - #set( $package = "package ${node.getPackage()};") -#end -## -$package -## -#if (!$JavaFormat.isInnerClass($node)) -#**#import org.overture.codegen.runtime.*; -#**#import java.util.*; -#elseif ( !$JavaFormat.isInnerClass($node) && !$JavaFormat.isQuote($node)) -#**#import org.overture.codegen.runtime.*; -#end -## -#if ($JavaFormat.importTraceSupport($node)) -#**#import org.overture.codegen.runtime.traces.*;## -#end -## -## -#set( $abstract = "") -#if ($node.getAbstract()) - #set( $abstract = "abstract") -#end -## -#set( $static = "") -#if ($node.getStatic()) - #set( $static = "static") -#end -#set( $threadMethod = "") -#if (!$JavaFormat.isNull($node.getThread())) - #set( $threadMethod = $JavaFormat.format($node.getThread())) -#end -## - -$abstract $node.getAccess() $static class $node.getName() $JavaFormat.formatSuperType($node) $JavaFormat.formatInterfaces($node) -{ - #foreach( $class in $node.getInnerClasses() ) - $JavaFormat.format($class) - #end## - #foreach( $field in $node.getFields() ) - $JavaFormat.format($field) - #end - ## - - #foreach( $method in $node.getMethods() ) - $JavaFormat.format($method) - #end - ## - #if ($JavaFormat.isMainClass($node)) - $node.getTag().getMainMethod() - #end +#set( $package = "") +#if (!$JavaFormat.isNull($node.getPackage())) + #set( $package = "package ${node.getPackage()};") +#end +## +$package +## +#if (!$JavaFormat.isInnerClass($node)) +#**#import org.overture.codegen.runtime.*; +#**#import java.util.*; +#elseif ( !$JavaFormat.isInnerClass($node) && !$JavaFormat.isQuote($node)) +#**#import org.overture.codegen.runtime.*; +#end +## +#if ($JavaFormat.importTraceSupport($node)) +#**#import org.overture.codegen.runtime.traces.*;## +#end +## +## +#set( $abstract = "") +#if ($node.getAbstract()) + #set( $abstract = "abstract") +#end +## +#set( $static = "") +#if ($node.getStatic()) + #set( $static = "static") +#end +#set( $threadMethod = "") +#if (!$JavaFormat.isNull($node.getThread())) + #set( $threadMethod = $JavaFormat.format($node.getThread())) +#end +## + +$abstract $node.getAccess() $static class $node.getName() $JavaFormat.formatSuperType($node) $JavaFormat.formatInterfaces($node) +{ + #foreach( $class in $node.getInnerClasses() ) + $JavaFormat.format($class) + #end## + #foreach( $field in $node.getFields() ) + $JavaFormat.format($field) + #end + ## - #foreach( $typeDecl in $node.getTypeDecls() ) - #if (!$JavaFormat.isNamedTypeDecl($typeDecl)) - $JavaFormat.format($typeDecl) + #foreach( $method in $node.getMethods() ) + $JavaFormat.format($method) + #end + ## + #if ($JavaFormat.isMainClass($node)) + $node.getTag().getMainMethod() + #end + + #foreach( $typeDecl in $node.getTypeDecls() ) + #if (!$JavaFormat.isNamedTypeDecl($typeDecl)) + $JavaFormat.format($typeDecl) #end - #end - ## - ${threadMethod}## + #end + ## + ${threadMethod}## } \ No newline at end of file diff --git a/core/codegen/src/main/resources/JavaTemplates/Declarations/Field.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Declarations/Field.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Declarations/Field.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Declarations/Field.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Declarations/Interface.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Declarations/Interface.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Declarations/Interface.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Declarations/Interface.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Declarations/LocalVar.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Declarations/LocalVar.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Declarations/LocalVar.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Declarations/LocalVar.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Declarations/Method.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Declarations/Method.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Declarations/Method.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Declarations/Method.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Declarations/Record.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Declarations/Record.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Declarations/Record.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Declarations/Record.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Declarations/Thread.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Declarations/Thread.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Declarations/Thread.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Declarations/Thread.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Declarations/Type.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Declarations/Type.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Declarations/Type.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Declarations/Type.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/AnonymousClass.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/AnonymousClass.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/AnonymousClass.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/AnonymousClass.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Apply.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Apply.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Apply.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Apply.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/AddrEquals.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/AddrEquals.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/AddrEquals.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/AddrEquals.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/AddrNotEquals.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/AddrNotEquals.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/AddrNotEquals.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/AddrNotEquals.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/Bool/And.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/Bool/And.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/Bool/And.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/Bool/And.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/Bool/Or.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/Bool/Or.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/Bool/Or.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/Bool/Or.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/Bool/Xor.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/Bool/Xor.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/Bool/Xor.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/Bool/Xor.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/DomResBy.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/DomResBy.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/DomResBy.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/DomResBy.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/DomResTo.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/DomResTo.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/DomResTo.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/DomResTo.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/Equals.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/Equals.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/Equals.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/Equals.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/InSet.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/InSet.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/InSet.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/InSet.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/MapOverride.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/MapOverride.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/MapOverride.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/MapOverride.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/MapUnion.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/MapUnion.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/MapUnion.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/MapUnion.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/NotEquals.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/NotEquals.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/NotEquals.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/NotEquals.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Divide.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Divide.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Divide.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Divide.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Greater.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Greater.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Greater.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Greater.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/GreaterEqual.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/GreaterEqual.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/GreaterEqual.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/GreaterEqual.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/IntDiv.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/IntDiv.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/IntDiv.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/IntDiv.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Less.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Less.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Less.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Less.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/LessEqual.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/LessEqual.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/LessEqual.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/LessEqual.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Minus.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Minus.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Minus.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Minus.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Mod.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Mod.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Mod.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Mod.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Mul.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Mul.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Mul.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Mul.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Plus.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Plus.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Plus.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Plus.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Power.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Power.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Power.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Power.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Rem.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Rem.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Rem.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Rem.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/RngResBy.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/RngResBy.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/RngResBy.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/RngResBy.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/RngResTo.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/RngResTo.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/RngResTo.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/RngResTo.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/SeqConcat.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/SeqConcat.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/SeqConcat.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/SeqConcat.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/SeqModification.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/SeqModification.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/SeqModification.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/SeqModification.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/SetDifference.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/SetDifference.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/SetDifference.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/SetDifference.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/SetIntersect.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/SetIntersect.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/SetIntersect.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/SetIntersect.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/SetProperSubset.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/SetProperSubset.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/SetProperSubset.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/SetProperSubset.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/SetSubset.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/SetSubset.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/SetSubset.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/SetSubset.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/SetUnion.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/SetUnion.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Binary/SetUnion.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/SetUnion.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/BoolLiteral.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/BoolLiteral.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/BoolLiteral.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/BoolLiteral.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/CharLiteral.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/CharLiteral.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/CharLiteral.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/CharLiteral.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/ExplicitVariable.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/ExplicitVariable.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/ExplicitVariable.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/ExplicitVariable.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/External.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/External.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/External.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/External.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Field.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Field.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Field.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Field.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/FieldNumber.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/FieldNumber.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/FieldNumber.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/FieldNumber.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/HistoryExp.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/HistoryExp.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/HistoryExp.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/HistoryExp.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/InstanceOf.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/InstanceOf.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/InstanceOf.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/InstanceOf.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/IntLiteral.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/IntLiteral.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/IntLiteral.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/IntLiteral.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Is/Bool.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Is/Bool.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Is/Bool.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Is/Bool.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Is/Char.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Is/Char.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Is/Char.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Is/Char.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Is/General.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Is/General.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Is/General.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Is/General.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Is/Int.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Is/Int.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Is/Int.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Is/Int.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Is/Nat.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Is/Nat.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Is/Nat.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Is/Nat.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Is/Nat1.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Is/Nat1.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Is/Nat1.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Is/Nat1.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Is/Rat.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Is/Rat.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Is/Rat.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Is/Rat.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Is/Real.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Is/Real.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Is/Real.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Is/Real.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Is/Token.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Is/Token.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Is/Token.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Is/Token.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Is/Tuple.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Is/Tuple.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Is/Tuple.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Is/Tuple.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Map/Enum.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Map/Enum.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Map/Enum.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Map/Enum.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/MapSeqGet.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/MapSeqGet.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/MapSeqGet.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/MapSeqGet.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Maplet.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Maplet.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Maplet.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Maplet.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/MethodInstantiation.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/MethodInstantiation.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/MethodInstantiation.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/MethodInstantiation.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/MkBasic.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/MkBasic.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/MkBasic.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/MkBasic.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/New.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/New.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/New.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/New.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/NotImplemented.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/NotImplemented.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/NotImplemented.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/NotImplemented.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Null.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Null.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Null.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Null.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/QuoteLiteral.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/QuoteLiteral.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/QuoteLiteral.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/QuoteLiteral.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/RealLiteral.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/RealLiteral.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/RealLiteral.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/RealLiteral.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/RuntimeError/LetBeStNoBinding.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/RuntimeError/LetBeStNoBinding.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/RuntimeError/LetBeStNoBinding.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/RuntimeError/LetBeStNoBinding.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/RuntimeError/MissingMember.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/RuntimeError/MissingMember.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/RuntimeError/MissingMember.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/RuntimeError/MissingMember.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/RuntimeError/PatternMatch.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/RuntimeError/PatternMatch.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/RuntimeError/PatternMatch.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/RuntimeError/PatternMatch.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/RuntimeError/PreCond.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/RuntimeError/PreCond.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/RuntimeError/PreCond.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/RuntimeError/PreCond.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Self.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Self.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Self.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Self.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Seq/Enum.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Seq/Enum.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Seq/Enum.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Seq/Enum.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Set/Enum.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Set/Enum.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Set/Enum.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Set/Enum.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Set/Range.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Set/Range.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Set/Range.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Set/Range.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/StringLiteral.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/StringLiteral.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/StringLiteral.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/StringLiteral.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/SubSeq.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/SubSeq.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/SubSeq.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/SubSeq.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/SuperVariable.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/SuperVariable.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/SuperVariable.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/SuperVariable.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/TernaryIf.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/TernaryIf.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/TernaryIf.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/TernaryIf.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/ThreadId.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/ThreadId.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/ThreadId.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/ThreadId.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Tuple.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Tuple.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Tuple.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Tuple.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/TupleCompatibility.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/TupleCompatibility.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/TupleCompatibility.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/TupleCompatibility.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/TupleSize.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/TupleSize.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/TupleSize.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/TupleSize.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/TypeArg.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/TypeArg.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/TypeArg.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/TypeArg.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Unary/Abs.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/Abs.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Unary/Abs.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/Abs.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Unary/Cast.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/Cast.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Unary/Cast.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/Cast.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Unary/DistConcat.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/DistConcat.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Unary/DistConcat.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/DistConcat.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Unary/DistInter.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/DistInter.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Unary/DistInter.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/DistInter.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Unary/DistMerge.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/DistMerge.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Unary/DistMerge.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/DistMerge.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Unary/DistUnion.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/DistUnion.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Unary/DistUnion.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/DistUnion.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Unary/Elems.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/Elems.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Unary/Elems.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/Elems.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Unary/Floor.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/Floor.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Unary/Floor.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/Floor.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Unary/Head.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/Head.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Unary/Head.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/Head.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Unary/Indices.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/Indices.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Unary/Indices.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/Indices.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Unary/Isolation.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/Isolation.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Unary/Isolation.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/Isolation.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Unary/Len_Card.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/Len_Card.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Unary/Len_Card.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/Len_Card.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Unary/MapDom.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/MapDom.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Unary/MapDom.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/MapDom.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Unary/MapInverse.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/MapInverse.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Unary/MapInverse.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/MapInverse.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Unary/MapRange.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/MapRange.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Unary/MapRange.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/MapRange.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Unary/Minus.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/Minus.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Unary/Minus.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/Minus.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Unary/Not.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/Not.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Unary/Not.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/Not.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Unary/Plus.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/Plus.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Unary/Plus.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/Plus.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Unary/PowerSet.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/PowerSet.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Unary/PowerSet.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/PowerSet.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Unary/Reverse.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/Reverse.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Unary/Reverse.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/Reverse.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Unary/SeqToString.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/SeqToString.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Unary/SeqToString.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/SeqToString.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Unary/StringToSeq.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/StringToSeq.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Unary/StringToSeq.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/StringToSeq.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Unary/Tail.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/Tail.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Unary/Tail.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/Tail.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Undefined.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Undefined.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Undefined.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Undefined.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Expressions/Variable.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Variable.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Expressions/Variable.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Variable.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/LocalDecls/FormalParam.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/LocalDecls/FormalParam.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/LocalDecls/FormalParam.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/LocalDecls/FormalParam.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Pattern/Identifier.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Pattern/Identifier.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Pattern/Identifier.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Pattern/Identifier.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Statements/Assignment.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Statements/Assignment.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Statements/Assignment.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Statements/Assignment.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Statements/Block.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Statements/Block.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Statements/Block.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Statements/Block.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Statements/Break.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Statements/Break.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Statements/Break.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Statements/Break.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Statements/Call.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Statements/Call.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Statements/Call.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Statements/Call.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Statements/CallObject.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Statements/CallObject.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Statements/CallObject.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Statements/CallObject.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Statements/CallObjectExp.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Statements/CallObjectExp.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Statements/CallObjectExp.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Statements/CallObjectExp.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Statements/Continue.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Statements/Continue.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Statements/Continue.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Statements/Continue.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Statements/Decrement.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Statements/Decrement.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Statements/Decrement.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Statements/Decrement.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Statements/Error.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Statements/Error.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Statements/Error.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Statements/Error.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Statements/ForAll.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Statements/ForAll.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Statements/ForAll.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Statements/ForAll.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Statements/ForIndex.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Statements/ForIndex.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Statements/ForIndex.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Statements/ForIndex.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Statements/ForLoop.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Statements/ForLoop.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Statements/ForLoop.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Statements/ForLoop.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Statements/If.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Statements/If.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Statements/If.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Statements/If.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Statements/Increment.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Statements/Increment.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Statements/Increment.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Statements/Increment.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Statements/LocalAssignment.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Statements/LocalAssignment.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Statements/LocalAssignment.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Statements/LocalAssignment.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Statements/LocalPatternAssignment.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Statements/LocalPatternAssignment.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Statements/LocalPatternAssignment.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Statements/LocalPatternAssignment.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Statements/MapSeqUpdate.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Statements/MapSeqUpdate.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Statements/MapSeqUpdate.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Statements/MapSeqUpdate.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Statements/NotImplemented.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Statements/NotImplemented.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Statements/NotImplemented.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Statements/NotImplemented.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Statements/RaiseError.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Statements/RaiseError.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Statements/RaiseError.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Statements/RaiseError.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Statements/Return.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Statements/Return.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Statements/Return.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Statements/Return.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Statements/Skip.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Statements/Skip.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Statements/Skip.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Statements/Skip.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Statements/Start.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Statements/Start.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Statements/Start.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Statements/Start.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Statements/Startlist.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Statements/Startlist.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Statements/Startlist.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Statements/Startlist.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Statements/SuperCall.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Statements/SuperCall.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Statements/SuperCall.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Statements/SuperCall.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Statements/Throw.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Statements/Throw.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Statements/Throw.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Statements/Throw.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Statements/Try.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Statements/Try.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Statements/Try.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Statements/Try.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Statements/While.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Statements/While.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Statements/While.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Statements/While.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Types/Basic/Bool.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Types/Basic/Bool.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Types/Basic/Bool.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Types/Basic/Bool.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Types/Basic/Char.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Types/Basic/Char.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Types/Basic/Char.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Types/Basic/Char.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Types/Basic/Integer.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Types/Basic/Integer.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Types/Basic/Integer.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Types/Basic/Integer.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Types/Basic/Nat.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Types/Basic/Nat.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Types/Basic/Nat.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Types/Basic/Nat.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Types/Basic/Nat1.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Types/Basic/Nat1.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Types/Basic/Nat1.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Types/Basic/Nat1.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Types/Basic/Rat.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Types/Basic/Rat.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Types/Basic/Rat.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Types/Basic/Rat.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Types/Basic/Real.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Types/Basic/Real.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Types/Basic/Real.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Types/Basic/Real.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Types/Basic/Token.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Types/Basic/Token.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Types/Basic/Token.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Types/Basic/Token.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Types/BasicWrappers/Bool.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Types/BasicWrappers/Bool.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Types/BasicWrappers/Bool.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Types/BasicWrappers/Bool.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Types/BasicWrappers/Char.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Types/BasicWrappers/Char.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Types/BasicWrappers/Char.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Types/BasicWrappers/Char.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Types/BasicWrappers/Integer.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Types/BasicWrappers/Integer.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Types/BasicWrappers/Integer.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Types/BasicWrappers/Integer.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Types/BasicWrappers/Nat.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Types/BasicWrappers/Nat.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Types/BasicWrappers/Nat.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Types/BasicWrappers/Nat.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Types/BasicWrappers/Nat1.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Types/BasicWrappers/Nat1.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Types/BasicWrappers/Nat1.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Types/BasicWrappers/Nat1.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Types/BasicWrappers/Rat.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Types/BasicWrappers/Rat.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Types/BasicWrappers/Rat.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Types/BasicWrappers/Rat.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Types/BasicWrappers/Real.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Types/BasicWrappers/Real.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Types/BasicWrappers/Real.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Types/BasicWrappers/Real.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Types/Class.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Types/Class.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Types/Class.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Types/Class.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Types/External.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Types/External.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Types/External.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Types/External.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Types/Interface.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Types/Interface.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Types/Interface.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Types/Interface.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Types/Map/Map.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Types/Map/Map.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Types/Map/Map.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Types/Map/Map.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Types/Method.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Types/Method.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Types/Method.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Types/Method.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Types/Null.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Types/Null.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Types/Null.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Types/Null.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Types/Object.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Types/Object.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Types/Object.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Types/Object.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Types/Quote.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Types/Quote.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Types/Quote.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Types/Quote.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Types/Record.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Types/Record.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Types/Record.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Types/Record.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Types/Seq/Seq.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Types/Seq/Seq.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Types/Seq/Seq.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Types/Seq/Seq.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Types/Set/Set.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Types/Set/Set.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Types/Set/Set.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Types/Set/Set.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Types/String.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Types/String.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Types/String.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Types/String.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Types/Template.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Types/Template.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Types/Template.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Types/Template.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Types/Tuple.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Types/Tuple.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Types/Tuple.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Types/Tuple.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Types/Union.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Types/Union.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Types/Union.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Types/Union.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Types/Unknown.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Types/Unknown.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Types/Unknown.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Types/Unknown.vm diff --git a/core/codegen/src/main/resources/JavaTemplates/Types/Void.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Types/Void.vm similarity index 100% rename from core/codegen/src/main/resources/JavaTemplates/Types/Void.vm rename to core/codegen/javagen/src/main/resources/JavaTemplates/Types/Void.vm diff --git a/core/codegen/src/main/resources/cg.astv2 b/core/codegen/javagen/src/main/resources/cg.astv2 similarity index 100% rename from core/codegen/src/main/resources/cg.astv2 rename to core/codegen/javagen/src/main/resources/cg.astv2 diff --git a/core/codegen/src/main/resources/cg.astv2.tostring b/core/codegen/javagen/src/main/resources/cg.astv2.tostring similarity index 100% rename from core/codegen/src/main/resources/cg.astv2.tostring rename to core/codegen/javagen/src/main/resources/cg.astv2.tostring diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/BindTest.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/BindTest.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/BindTest.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/BindTest.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/ClassesToSkipParsingTest.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/ClassesToSkipParsingTest.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/ClassesToSkipParsingTest.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/ClassesToSkipParsingTest.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/ClassicSpecTest.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/ClassicSpecTest.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/ClassicSpecTest.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/ClassicSpecTest.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/ClassicSpecTestCase.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/ClassicSpecTestCase.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/ClassicSpecTestCase.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/ClassicSpecTestCase.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/CodeGenBaseTestCase.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/CodeGenBaseTestCase.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/CodeGenBaseTestCase.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/CodeGenBaseTestCase.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/ComplexExpressionTest.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/ComplexExpressionTest.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/ComplexExpressionTest.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/ComplexExpressionTest.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/ConcurrencyClassicSpecTestCase.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/ConcurrencyClassicSpecTestCase.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/ConcurrencyClassicSpecTestCase.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/ConcurrencyClassicSpecTestCase.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/ConcurrencyClassicSpecTests.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/ConcurrencyClassicSpecTests.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/ConcurrencyClassicSpecTests.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/ConcurrencyClassicSpecTests.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/ConcurrencyTestCase.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/ConcurrencyTestCase.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/ConcurrencyTestCase.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/ConcurrencyTestCase.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/ConcurrencyTests.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/ConcurrencyTests.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/ConcurrencyTests.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/ConcurrencyTests.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/ConfiguredCloningTest.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/ConfiguredCloningTest.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/ConfiguredCloningTest.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/ConfiguredCloningTest.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/ConfiguredCloningTestCase.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/ConfiguredCloningTestCase.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/ConfiguredCloningTestCase.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/ConfiguredCloningTestCase.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/ConfiguredStringGenerationTest.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/ConfiguredStringGenerationTest.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/ConfiguredStringGenerationTest.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/ConfiguredStringGenerationTest.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/ConfiguredStringGenerationTestCase.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/ConfiguredStringGenerationTestCase.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/ConfiguredStringGenerationTestCase.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/ConfiguredStringGenerationTestCase.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/ExpressionTest.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/ExpressionTest.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/ExpressionTest.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/ExpressionTest.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/ExpressionTestCase.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/ExpressionTestCase.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/ExpressionTestCase.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/ExpressionTestCase.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/FunctionValueTest.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/FunctionValueTest.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/FunctionValueTest.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/FunctionValueTest.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/IRTest.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/IRTest.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/IRTest.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/IRTest.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/NameNormalising.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/NameNormalising.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/NameNormalising.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/NameNormalising.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/PackageTest.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/PackageTest.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/PackageTest.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/PackageTest.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/PackageTestCase.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/PackageTestCase.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/PackageTestCase.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/PackageTestCase.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/PatternTest.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/PatternTest.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/PatternTest.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/PatternTest.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/PrePostTest.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/PrePostTest.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/PrePostTest.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/PrePostTest.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/PrePostTestCase.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/PrePostTestCase.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/PrePostTestCase.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/PrePostTestCase.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/RtTest.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/RtTest.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/RtTest.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/RtTest.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/RtTestCase.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/RtTestCase.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/RtTestCase.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/RtTestCase.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/SpecificationTest.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/SpecificationTest.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/SpecificationTest.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/SpecificationTest.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/SpecificationTestCase.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/SpecificationTestCase.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/SpecificationTestCase.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/SpecificationTestCase.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/TestFlags.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/TestFlags.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/TestFlags.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/TestFlags.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/TracesExpansionTest.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/TracesExpansionTest.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/TracesExpansionTest.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/TracesExpansionTest.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/TracesExpansionTestCase.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/TracesExpansionTestCase.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/TracesExpansionTestCase.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/TracesExpansionTestCase.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/TracesVerdictTest.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/TracesVerdictTest.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/TracesVerdictTest.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/TracesVerdictTest.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/TracesVerdictTestCase.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/TracesVerdictTestCase.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/TracesVerdictTestCase.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/TracesVerdictTestCase.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/UnionTypeTest.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/UnionTypeTest.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/UnionTypeTest.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/UnionTypeTest.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/UtilsTest.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/UtilsTest.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/UtilsTest.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/UtilsTest.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/VarShadowingTest.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/VarShadowingTest.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/VarShadowingTest.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/VarShadowingTest.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/VarShadowingTestCase.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/VarShadowingTestCase.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/VarShadowingTestCase.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/VarShadowingTestCase.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/ComparisonCG.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/utils/ComparisonCG.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/utils/ComparisonCG.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/utils/ComparisonCG.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/CompileTests.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/utils/CompileTests.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/utils/CompileTests.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/utils/CompileTests.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/EntryBasedTestHandler.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/utils/EntryBasedTestHandler.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/utils/EntryBasedTestHandler.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/utils/EntryBasedTestHandler.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExecutableSpecTestHandler.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/utils/ExecutableSpecTestHandler.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/utils/ExecutableSpecTestHandler.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/utils/ExecutableSpecTestHandler.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExecutableTestHandler.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/utils/ExecutableTestHandler.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/utils/ExecutableTestHandler.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/utils/ExecutableTestHandler.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExecutionResult.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/utils/ExecutionResult.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/utils/ExecutionResult.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/utils/ExecutionResult.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/ExpressionTestHandler.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/utils/ExpressionTestHandler.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/utils/ExpressionTestHandler.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/utils/ExpressionTestHandler.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/FileComparator.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/utils/FileComparator.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/utils/FileComparator.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/utils/FileComparator.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/JavaCommandLineCompiler.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/utils/JavaCommandLineCompiler.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/utils/JavaCommandLineCompiler.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/utils/JavaCommandLineCompiler.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/JavaExecution.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/utils/JavaExecution.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/utils/JavaExecution.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/utils/JavaExecution.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/JavaToolsUtils.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/utils/JavaToolsUtils.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/utils/JavaToolsUtils.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/utils/JavaToolsUtils.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/NonExecutableSpecTestHandler.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/utils/NonExecutableSpecTestHandler.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/utils/NonExecutableSpecTestHandler.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/utils/NonExecutableSpecTestHandler.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/TestHandler.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/utils/TestHandler.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/utils/TestHandler.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/utils/TestHandler.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/TestUtils.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/utils/TestUtils.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/utils/TestUtils.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/utils/TestUtils.java diff --git a/core/codegen/src/test/java/org/overture/codegen/tests/utils/TraceHandler.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/utils/TraceHandler.java similarity index 100% rename from core/codegen/src/test/java/org/overture/codegen/tests/utils/TraceHandler.java rename to core/codegen/javagen/src/test/java/org/overture/codegen/tests/utils/TraceHandler.java diff --git a/core/codegen/src/test/resources/bind_specs/Exists1QuantifierWithTuplePattern b/core/codegen/javagen/src/test/resources/bind_specs/Exists1QuantifierWithTuplePattern similarity index 100% rename from core/codegen/src/test/resources/bind_specs/Exists1QuantifierWithTuplePattern rename to core/codegen/javagen/src/test/resources/bind_specs/Exists1QuantifierWithTuplePattern diff --git a/core/codegen/src/test/resources/bind_specs/Exists1QuantifierWithTuplePattern.result b/core/codegen/javagen/src/test/resources/bind_specs/Exists1QuantifierWithTuplePattern.result similarity index 100% rename from core/codegen/src/test/resources/bind_specs/Exists1QuantifierWithTuplePattern.result rename to core/codegen/javagen/src/test/resources/bind_specs/Exists1QuantifierWithTuplePattern.result diff --git a/core/codegen/src/test/resources/bind_specs/ExistsQuantifierWithTuplePattern b/core/codegen/javagen/src/test/resources/bind_specs/ExistsQuantifierWithTuplePattern similarity index 100% rename from core/codegen/src/test/resources/bind_specs/ExistsQuantifierWithTuplePattern rename to core/codegen/javagen/src/test/resources/bind_specs/ExistsQuantifierWithTuplePattern diff --git a/core/codegen/src/test/resources/bind_specs/ExistsQuantifierWithTuplePattern.result b/core/codegen/javagen/src/test/resources/bind_specs/ExistsQuantifierWithTuplePattern.result similarity index 100% rename from core/codegen/src/test/resources/bind_specs/ExistsQuantifierWithTuplePattern.result rename to core/codegen/javagen/src/test/resources/bind_specs/ExistsQuantifierWithTuplePattern.result diff --git a/core/codegen/src/test/resources/bind_specs/ForAllQuantifierWithTuplePattern b/core/codegen/javagen/src/test/resources/bind_specs/ForAllQuantifierWithTuplePattern similarity index 100% rename from core/codegen/src/test/resources/bind_specs/ForAllQuantifierWithTuplePattern rename to core/codegen/javagen/src/test/resources/bind_specs/ForAllQuantifierWithTuplePattern diff --git a/core/codegen/src/test/resources/bind_specs/ForAllQuantifierWithTuplePattern.result b/core/codegen/javagen/src/test/resources/bind_specs/ForAllQuantifierWithTuplePattern.result similarity index 100% rename from core/codegen/src/test/resources/bind_specs/ForAllQuantifierWithTuplePattern.result rename to core/codegen/javagen/src/test/resources/bind_specs/ForAllQuantifierWithTuplePattern.result diff --git a/core/codegen/src/test/resources/bind_specs/LetBeStExpMultipleBindWithTuplePattern b/core/codegen/javagen/src/test/resources/bind_specs/LetBeStExpMultipleBindWithTuplePattern similarity index 100% rename from core/codegen/src/test/resources/bind_specs/LetBeStExpMultipleBindWithTuplePattern rename to core/codegen/javagen/src/test/resources/bind_specs/LetBeStExpMultipleBindWithTuplePattern diff --git a/core/codegen/src/test/resources/bind_specs/LetBeStExpMultipleBindWithTuplePattern.result b/core/codegen/javagen/src/test/resources/bind_specs/LetBeStExpMultipleBindWithTuplePattern.result similarity index 100% rename from core/codegen/src/test/resources/bind_specs/LetBeStExpMultipleBindWithTuplePattern.result rename to core/codegen/javagen/src/test/resources/bind_specs/LetBeStExpMultipleBindWithTuplePattern.result diff --git a/core/codegen/src/test/resources/bind_specs/LetBeStExpWithTuplePattern b/core/codegen/javagen/src/test/resources/bind_specs/LetBeStExpWithTuplePattern similarity index 100% rename from core/codegen/src/test/resources/bind_specs/LetBeStExpWithTuplePattern rename to core/codegen/javagen/src/test/resources/bind_specs/LetBeStExpWithTuplePattern diff --git a/core/codegen/src/test/resources/bind_specs/LetBeStExpWithTuplePattern.result b/core/codegen/javagen/src/test/resources/bind_specs/LetBeStExpWithTuplePattern.result similarity index 100% rename from core/codegen/src/test/resources/bind_specs/LetBeStExpWithTuplePattern.result rename to core/codegen/javagen/src/test/resources/bind_specs/LetBeStExpWithTuplePattern.result diff --git a/core/codegen/src/test/resources/bind_specs/LetBeStStmWithRecPattern b/core/codegen/javagen/src/test/resources/bind_specs/LetBeStStmWithRecPattern similarity index 100% rename from core/codegen/src/test/resources/bind_specs/LetBeStStmWithRecPattern rename to core/codegen/javagen/src/test/resources/bind_specs/LetBeStStmWithRecPattern diff --git a/core/codegen/src/test/resources/bind_specs/LetBeStStmWithRecPattern.result b/core/codegen/javagen/src/test/resources/bind_specs/LetBeStStmWithRecPattern.result similarity index 100% rename from core/codegen/src/test/resources/bind_specs/LetBeStStmWithRecPattern.result rename to core/codegen/javagen/src/test/resources/bind_specs/LetBeStStmWithRecPattern.result diff --git a/core/codegen/src/test/resources/bind_specs/MapCompWithTuplePattern b/core/codegen/javagen/src/test/resources/bind_specs/MapCompWithTuplePattern similarity index 100% rename from core/codegen/src/test/resources/bind_specs/MapCompWithTuplePattern rename to core/codegen/javagen/src/test/resources/bind_specs/MapCompWithTuplePattern diff --git a/core/codegen/src/test/resources/bind_specs/MapCompWithTuplePattern.result b/core/codegen/javagen/src/test/resources/bind_specs/MapCompWithTuplePattern.result similarity index 100% rename from core/codegen/src/test/resources/bind_specs/MapCompWithTuplePattern.result rename to core/codegen/javagen/src/test/resources/bind_specs/MapCompWithTuplePattern.result diff --git a/core/codegen/src/test/resources/bind_specs/SeqCompWithTuplePattern b/core/codegen/javagen/src/test/resources/bind_specs/SeqCompWithTuplePattern similarity index 100% rename from core/codegen/src/test/resources/bind_specs/SeqCompWithTuplePattern rename to core/codegen/javagen/src/test/resources/bind_specs/SeqCompWithTuplePattern diff --git a/core/codegen/src/test/resources/bind_specs/SeqCompWithTuplePattern.result b/core/codegen/javagen/src/test/resources/bind_specs/SeqCompWithTuplePattern.result similarity index 100% rename from core/codegen/src/test/resources/bind_specs/SeqCompWithTuplePattern.result rename to core/codegen/javagen/src/test/resources/bind_specs/SeqCompWithTuplePattern.result diff --git a/core/codegen/src/test/resources/bind_specs/SetCompMultipleSetBindWithTuplePatterns b/core/codegen/javagen/src/test/resources/bind_specs/SetCompMultipleSetBindWithTuplePatterns similarity index 100% rename from core/codegen/src/test/resources/bind_specs/SetCompMultipleSetBindWithTuplePatterns rename to core/codegen/javagen/src/test/resources/bind_specs/SetCompMultipleSetBindWithTuplePatterns diff --git a/core/codegen/src/test/resources/bind_specs/SetCompMultipleSetBindWithTuplePatterns.result b/core/codegen/javagen/src/test/resources/bind_specs/SetCompMultipleSetBindWithTuplePatterns.result similarity index 100% rename from core/codegen/src/test/resources/bind_specs/SetCompMultipleSetBindWithTuplePatterns.result rename to core/codegen/javagen/src/test/resources/bind_specs/SetCompMultipleSetBindWithTuplePatterns.result diff --git a/core/codegen/src/test/resources/bind_specs/SetCompWithIntPattern b/core/codegen/javagen/src/test/resources/bind_specs/SetCompWithIntPattern similarity index 100% rename from core/codegen/src/test/resources/bind_specs/SetCompWithIntPattern rename to core/codegen/javagen/src/test/resources/bind_specs/SetCompWithIntPattern diff --git a/core/codegen/src/test/resources/bind_specs/SetCompWithIntPattern.result b/core/codegen/javagen/src/test/resources/bind_specs/SetCompWithIntPattern.result similarity index 100% rename from core/codegen/src/test/resources/bind_specs/SetCompWithIntPattern.result rename to core/codegen/javagen/src/test/resources/bind_specs/SetCompWithIntPattern.result diff --git a/core/codegen/src/test/resources/bind_specs/SetCompWithTuplePattern b/core/codegen/javagen/src/test/resources/bind_specs/SetCompWithTuplePattern similarity index 100% rename from core/codegen/src/test/resources/bind_specs/SetCompWithTuplePattern rename to core/codegen/javagen/src/test/resources/bind_specs/SetCompWithTuplePattern diff --git a/core/codegen/src/test/resources/bind_specs/SetCompWithTuplePattern.result b/core/codegen/javagen/src/test/resources/bind_specs/SetCompWithTuplePattern.result similarity index 100% rename from core/codegen/src/test/resources/bind_specs/SetCompWithTuplePattern.result rename to core/codegen/javagen/src/test/resources/bind_specs/SetCompWithTuplePattern.result diff --git a/core/codegen/src/test/resources/classic_specs/AlarmTraces b/core/codegen/javagen/src/test/resources/classic_specs/AlarmTraces similarity index 100% rename from core/codegen/src/test/resources/classic_specs/AlarmTraces rename to core/codegen/javagen/src/test/resources/classic_specs/AlarmTraces diff --git a/core/codegen/src/test/resources/classic_specs/AlarmTraces.result b/core/codegen/javagen/src/test/resources/classic_specs/AlarmTraces.result similarity index 100% rename from core/codegen/src/test/resources/classic_specs/AlarmTraces.result rename to core/codegen/javagen/src/test/resources/classic_specs/AlarmTraces.result diff --git a/core/codegen/src/test/resources/classic_specs/CashDispenserPP b/core/codegen/javagen/src/test/resources/classic_specs/CashDispenserPP similarity index 100% rename from core/codegen/src/test/resources/classic_specs/CashDispenserPP rename to core/codegen/javagen/src/test/resources/classic_specs/CashDispenserPP diff --git a/core/codegen/src/test/resources/classic_specs/CashDispenserPP.result b/core/codegen/javagen/src/test/resources/classic_specs/CashDispenserPP.result similarity index 100% rename from core/codegen/src/test/resources/classic_specs/CashDispenserPP.result rename to core/codegen/javagen/src/test/resources/classic_specs/CashDispenserPP.result diff --git a/core/codegen/src/test/resources/cloning_specs/AlarmTraces b/core/codegen/javagen/src/test/resources/cloning_specs/AlarmTraces similarity index 100% rename from core/codegen/src/test/resources/cloning_specs/AlarmTraces rename to core/codegen/javagen/src/test/resources/cloning_specs/AlarmTraces diff --git a/core/codegen/src/test/resources/cloning_specs/AlarmTraces.result b/core/codegen/javagen/src/test/resources/cloning_specs/AlarmTraces.result similarity index 100% rename from core/codegen/src/test/resources/cloning_specs/AlarmTraces.result rename to core/codegen/javagen/src/test/resources/cloning_specs/AlarmTraces.result diff --git a/core/codegen/src/test/resources/cloning_specs/CashDispenserPP b/core/codegen/javagen/src/test/resources/cloning_specs/CashDispenserPP similarity index 100% rename from core/codegen/src/test/resources/cloning_specs/CashDispenserPP rename to core/codegen/javagen/src/test/resources/cloning_specs/CashDispenserPP diff --git a/core/codegen/src/test/resources/cloning_specs/CashDispenserPP.result b/core/codegen/javagen/src/test/resources/cloning_specs/CashDispenserPP.result similarity index 100% rename from core/codegen/src/test/resources/cloning_specs/CashDispenserPP.result rename to core/codegen/javagen/src/test/resources/cloning_specs/CashDispenserPP.result diff --git a/core/codegen/src/test/resources/cloning_specs/TupleUsage b/core/codegen/javagen/src/test/resources/cloning_specs/TupleUsage similarity index 100% rename from core/codegen/src/test/resources/cloning_specs/TupleUsage rename to core/codegen/javagen/src/test/resources/cloning_specs/TupleUsage diff --git a/core/codegen/src/test/resources/cloning_specs/TupleUsage.result b/core/codegen/javagen/src/test/resources/cloning_specs/TupleUsage.result similarity index 100% rename from core/codegen/src/test/resources/cloning_specs/TupleUsage.result rename to core/codegen/javagen/src/test/resources/cloning_specs/TupleUsage.result diff --git a/core/codegen/src/test/resources/complex_expressions/AbsNumberDereference b/core/codegen/javagen/src/test/resources/complex_expressions/AbsNumberDereference similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/AbsNumberDereference rename to core/codegen/javagen/src/test/resources/complex_expressions/AbsNumberDereference diff --git a/core/codegen/src/test/resources/complex_expressions/AbsNumberDereference.result b/core/codegen/javagen/src/test/resources/complex_expressions/AbsNumberDereference.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/AbsNumberDereference.result rename to core/codegen/javagen/src/test/resources/complex_expressions/AbsNumberDereference.result diff --git a/core/codegen/src/test/resources/complex_expressions/AndExpAndChainInForAll b/core/codegen/javagen/src/test/resources/complex_expressions/AndExpAndChainInForAll similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/AndExpAndChainInForAll rename to core/codegen/javagen/src/test/resources/complex_expressions/AndExpAndChainInForAll diff --git a/core/codegen/src/test/resources/complex_expressions/AndExpAndChainInForAll.result b/core/codegen/javagen/src/test/resources/complex_expressions/AndExpAndChainInForAll.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/AndExpAndChainInForAll.result rename to core/codegen/javagen/src/test/resources/complex_expressions/AndExpAndChainInForAll.result diff --git a/core/codegen/src/test/resources/complex_expressions/AndExpChain b/core/codegen/javagen/src/test/resources/complex_expressions/AndExpChain similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/AndExpChain rename to core/codegen/javagen/src/test/resources/complex_expressions/AndExpChain diff --git a/core/codegen/src/test/resources/complex_expressions/AndExpChain.result b/core/codegen/javagen/src/test/resources/complex_expressions/AndExpChain.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/AndExpChain.result rename to core/codegen/javagen/src/test/resources/complex_expressions/AndExpChain.result diff --git a/core/codegen/src/test/resources/complex_expressions/AndExpEvalOrder b/core/codegen/javagen/src/test/resources/complex_expressions/AndExpEvalOrder similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/AndExpEvalOrder rename to core/codegen/javagen/src/test/resources/complex_expressions/AndExpEvalOrder diff --git a/core/codegen/src/test/resources/complex_expressions/AndExpEvalOrder.result b/core/codegen/javagen/src/test/resources/complex_expressions/AndExpEvalOrder.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/AndExpEvalOrder.result rename to core/codegen/javagen/src/test/resources/complex_expressions/AndExpEvalOrder.result diff --git a/core/codegen/src/test/resources/complex_expressions/AndExpForAllExps b/core/codegen/javagen/src/test/resources/complex_expressions/AndExpForAllExps similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/AndExpForAllExps rename to core/codegen/javagen/src/test/resources/complex_expressions/AndExpForAllExps diff --git a/core/codegen/src/test/resources/complex_expressions/AndExpForAllExps.result b/core/codegen/javagen/src/test/resources/complex_expressions/AndExpForAllExps.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/AndExpForAllExps.result rename to core/codegen/javagen/src/test/resources/complex_expressions/AndExpForAllExps.result diff --git a/core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorClone b/core/codegen/javagen/src/test/resources/complex_expressions/ApplyObjectDesignatorClone similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorClone rename to core/codegen/javagen/src/test/resources/complex_expressions/ApplyObjectDesignatorClone diff --git a/core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorClone.result b/core/codegen/javagen/src/test/resources/complex_expressions/ApplyObjectDesignatorClone.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorClone.result rename to core/codegen/javagen/src/test/resources/complex_expressions/ApplyObjectDesignatorClone.result diff --git a/core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorField b/core/codegen/javagen/src/test/resources/complex_expressions/ApplyObjectDesignatorField similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorField rename to core/codegen/javagen/src/test/resources/complex_expressions/ApplyObjectDesignatorField diff --git a/core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorField.result b/core/codegen/javagen/src/test/resources/complex_expressions/ApplyObjectDesignatorField.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorField.result rename to core/codegen/javagen/src/test/resources/complex_expressions/ApplyObjectDesignatorField.result diff --git a/core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorMapLookup b/core/codegen/javagen/src/test/resources/complex_expressions/ApplyObjectDesignatorMapLookup similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorMapLookup rename to core/codegen/javagen/src/test/resources/complex_expressions/ApplyObjectDesignatorMapLookup diff --git a/core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorMapLookup.result b/core/codegen/javagen/src/test/resources/complex_expressions/ApplyObjectDesignatorMapLookup.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorMapLookup.result rename to core/codegen/javagen/src/test/resources/complex_expressions/ApplyObjectDesignatorMapLookup.result diff --git a/core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorMapType b/core/codegen/javagen/src/test/resources/complex_expressions/ApplyObjectDesignatorMapType similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorMapType rename to core/codegen/javagen/src/test/resources/complex_expressions/ApplyObjectDesignatorMapType diff --git a/core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorMapType.result b/core/codegen/javagen/src/test/resources/complex_expressions/ApplyObjectDesignatorMapType.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorMapType.result rename to core/codegen/javagen/src/test/resources/complex_expressions/ApplyObjectDesignatorMapType.result diff --git a/core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorNoClone b/core/codegen/javagen/src/test/resources/complex_expressions/ApplyObjectDesignatorNoClone similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorNoClone rename to core/codegen/javagen/src/test/resources/complex_expressions/ApplyObjectDesignatorNoClone diff --git a/core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorNoClone.result b/core/codegen/javagen/src/test/resources/complex_expressions/ApplyObjectDesignatorNoClone.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorNoClone.result rename to core/codegen/javagen/src/test/resources/complex_expressions/ApplyObjectDesignatorNoClone.result diff --git a/core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorWithRecFieldObj1 b/core/codegen/javagen/src/test/resources/complex_expressions/ApplyObjectDesignatorWithRecFieldObj1 similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorWithRecFieldObj1 rename to core/codegen/javagen/src/test/resources/complex_expressions/ApplyObjectDesignatorWithRecFieldObj1 diff --git a/core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorWithRecFieldObj1.result b/core/codegen/javagen/src/test/resources/complex_expressions/ApplyObjectDesignatorWithRecFieldObj1.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorWithRecFieldObj1.result rename to core/codegen/javagen/src/test/resources/complex_expressions/ApplyObjectDesignatorWithRecFieldObj1.result diff --git a/core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorWithRecFieldObj2 b/core/codegen/javagen/src/test/resources/complex_expressions/ApplyObjectDesignatorWithRecFieldObj2 similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorWithRecFieldObj2 rename to core/codegen/javagen/src/test/resources/complex_expressions/ApplyObjectDesignatorWithRecFieldObj2 diff --git a/core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorWithRecFieldObj2.result b/core/codegen/javagen/src/test/resources/complex_expressions/ApplyObjectDesignatorWithRecFieldObj2.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ApplyObjectDesignatorWithRecFieldObj2.result rename to core/codegen/javagen/src/test/resources/complex_expressions/ApplyObjectDesignatorWithRecFieldObj2.result diff --git a/core/codegen/src/test/resources/complex_expressions/AtomicStm b/core/codegen/javagen/src/test/resources/complex_expressions/AtomicStm similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/AtomicStm rename to core/codegen/javagen/src/test/resources/complex_expressions/AtomicStm diff --git a/core/codegen/src/test/resources/complex_expressions/AtomicStm.result b/core/codegen/javagen/src/test/resources/complex_expressions/AtomicStm.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/AtomicStm.result rename to core/codegen/javagen/src/test/resources/complex_expressions/AtomicStm.result diff --git a/core/codegen/src/test/resources/complex_expressions/BlockStmScoping b/core/codegen/javagen/src/test/resources/complex_expressions/BlockStmScoping similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/BlockStmScoping rename to core/codegen/javagen/src/test/resources/complex_expressions/BlockStmScoping diff --git a/core/codegen/src/test/resources/complex_expressions/BlockStmScoping.result b/core/codegen/javagen/src/test/resources/complex_expressions/BlockStmScoping.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/BlockStmScoping.result rename to core/codegen/javagen/src/test/resources/complex_expressions/BlockStmScoping.result diff --git a/core/codegen/src/test/resources/complex_expressions/CallStmInherited b/core/codegen/javagen/src/test/resources/complex_expressions/CallStmInherited similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/CallStmInherited rename to core/codegen/javagen/src/test/resources/complex_expressions/CallStmInherited diff --git a/core/codegen/src/test/resources/complex_expressions/CallStmInherited.result b/core/codegen/javagen/src/test/resources/complex_expressions/CallStmInherited.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/CallStmInherited.result rename to core/codegen/javagen/src/test/resources/complex_expressions/CallStmInherited.result diff --git a/core/codegen/src/test/resources/complex_expressions/DeadCodeNestedBlocks b/core/codegen/javagen/src/test/resources/complex_expressions/DeadCodeNestedBlocks similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/DeadCodeNestedBlocks rename to core/codegen/javagen/src/test/resources/complex_expressions/DeadCodeNestedBlocks diff --git a/core/codegen/src/test/resources/complex_expressions/DeadCodeNestedBlocks.result b/core/codegen/javagen/src/test/resources/complex_expressions/DeadCodeNestedBlocks.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/DeadCodeNestedBlocks.result rename to core/codegen/javagen/src/test/resources/complex_expressions/DeadCodeNestedBlocks.result diff --git a/core/codegen/src/test/resources/complex_expressions/DeflattenBlockStm b/core/codegen/javagen/src/test/resources/complex_expressions/DeflattenBlockStm similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/DeflattenBlockStm rename to core/codegen/javagen/src/test/resources/complex_expressions/DeflattenBlockStm diff --git a/core/codegen/src/test/resources/complex_expressions/DeflattenBlockStm.result b/core/codegen/javagen/src/test/resources/complex_expressions/DeflattenBlockStm.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/DeflattenBlockStm.result rename to core/codegen/javagen/src/test/resources/complex_expressions/DeflattenBlockStm.result diff --git a/core/codegen/src/test/resources/complex_expressions/DeflattenLetBeStStm b/core/codegen/javagen/src/test/resources/complex_expressions/DeflattenLetBeStStm similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/DeflattenLetBeStStm rename to core/codegen/javagen/src/test/resources/complex_expressions/DeflattenLetBeStStm diff --git a/core/codegen/src/test/resources/complex_expressions/DeflattenLetBeStStm.result b/core/codegen/javagen/src/test/resources/complex_expressions/DeflattenLetBeStStm.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/DeflattenLetBeStStm.result rename to core/codegen/javagen/src/test/resources/complex_expressions/DeflattenLetBeStStm.result diff --git a/core/codegen/src/test/resources/complex_expressions/DeflattenLetDefExp b/core/codegen/javagen/src/test/resources/complex_expressions/DeflattenLetDefExp similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/DeflattenLetDefExp rename to core/codegen/javagen/src/test/resources/complex_expressions/DeflattenLetDefExp diff --git a/core/codegen/src/test/resources/complex_expressions/DeflattenLetDefExp.result b/core/codegen/javagen/src/test/resources/complex_expressions/DeflattenLetDefExp.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/DeflattenLetDefExp.result rename to core/codegen/javagen/src/test/resources/complex_expressions/DeflattenLetDefExp.result diff --git a/core/codegen/src/test/resources/complex_expressions/ElseIfWithSetComp b/core/codegen/javagen/src/test/resources/complex_expressions/ElseIfWithSetComp similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ElseIfWithSetComp rename to core/codegen/javagen/src/test/resources/complex_expressions/ElseIfWithSetComp diff --git a/core/codegen/src/test/resources/complex_expressions/ElseIfWithSetComp.result b/core/codegen/javagen/src/test/resources/complex_expressions/ElseIfWithSetComp.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ElseIfWithSetComp.result rename to core/codegen/javagen/src/test/resources/complex_expressions/ElseIfWithSetComp.result diff --git a/core/codegen/src/test/resources/complex_expressions/EmptyRecords b/core/codegen/javagen/src/test/resources/complex_expressions/EmptyRecords similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/EmptyRecords rename to core/codegen/javagen/src/test/resources/complex_expressions/EmptyRecords diff --git a/core/codegen/src/test/resources/complex_expressions/EmptyRecords.result b/core/codegen/javagen/src/test/resources/complex_expressions/EmptyRecords.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/EmptyRecords.result rename to core/codegen/javagen/src/test/resources/complex_expressions/EmptyRecords.result diff --git a/core/codegen/src/test/resources/complex_expressions/EqualsDef b/core/codegen/javagen/src/test/resources/complex_expressions/EqualsDef similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/EqualsDef rename to core/codegen/javagen/src/test/resources/complex_expressions/EqualsDef diff --git a/core/codegen/src/test/resources/complex_expressions/EqualsDef.result b/core/codegen/javagen/src/test/resources/complex_expressions/EqualsDef.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/EqualsDef.result rename to core/codegen/javagen/src/test/resources/complex_expressions/EqualsDef.result diff --git a/core/codegen/src/test/resources/complex_expressions/EqualsOptionalType b/core/codegen/javagen/src/test/resources/complex_expressions/EqualsOptionalType similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/EqualsOptionalType rename to core/codegen/javagen/src/test/resources/complex_expressions/EqualsOptionalType diff --git a/core/codegen/src/test/resources/complex_expressions/EqualsOptionalType.result b/core/codegen/javagen/src/test/resources/complex_expressions/EqualsOptionalType.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/EqualsOptionalType.result rename to core/codegen/javagen/src/test/resources/complex_expressions/EqualsOptionalType.result diff --git a/core/codegen/src/test/resources/complex_expressions/Exist1ExpTransformedCond b/core/codegen/javagen/src/test/resources/complex_expressions/Exist1ExpTransformedCond similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/Exist1ExpTransformedCond rename to core/codegen/javagen/src/test/resources/complex_expressions/Exist1ExpTransformedCond diff --git a/core/codegen/src/test/resources/complex_expressions/Exist1ExpTransformedCond.result b/core/codegen/javagen/src/test/resources/complex_expressions/Exist1ExpTransformedCond.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/Exist1ExpTransformedCond.result rename to core/codegen/javagen/src/test/resources/complex_expressions/Exist1ExpTransformedCond.result diff --git a/core/codegen/src/test/resources/complex_expressions/ExistExpTransformedCond b/core/codegen/javagen/src/test/resources/complex_expressions/ExistExpTransformedCond similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ExistExpTransformedCond rename to core/codegen/javagen/src/test/resources/complex_expressions/ExistExpTransformedCond diff --git a/core/codegen/src/test/resources/complex_expressions/ExistExpTransformedCond.result b/core/codegen/javagen/src/test/resources/complex_expressions/ExistExpTransformedCond.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ExistExpTransformedCond.result rename to core/codegen/javagen/src/test/resources/complex_expressions/ExistExpTransformedCond.result diff --git a/core/codegen/src/test/resources/complex_expressions/Exists1ExpBindRemoved b/core/codegen/javagen/src/test/resources/complex_expressions/Exists1ExpBindRemoved similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/Exists1ExpBindRemoved rename to core/codegen/javagen/src/test/resources/complex_expressions/Exists1ExpBindRemoved diff --git a/core/codegen/src/test/resources/complex_expressions/Exists1ExpBindRemoved.result b/core/codegen/javagen/src/test/resources/complex_expressions/Exists1ExpBindRemoved.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/Exists1ExpBindRemoved.result rename to core/codegen/javagen/src/test/resources/complex_expressions/Exists1ExpBindRemoved.result diff --git a/core/codegen/src/test/resources/complex_expressions/Exists1ExpBlockStm b/core/codegen/javagen/src/test/resources/complex_expressions/Exists1ExpBlockStm similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/Exists1ExpBlockStm rename to core/codegen/javagen/src/test/resources/complex_expressions/Exists1ExpBlockStm diff --git a/core/codegen/src/test/resources/complex_expressions/Exists1ExpBlockStm.result b/core/codegen/javagen/src/test/resources/complex_expressions/Exists1ExpBlockStm.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/Exists1ExpBlockStm.result rename to core/codegen/javagen/src/test/resources/complex_expressions/Exists1ExpBlockStm.result diff --git a/core/codegen/src/test/resources/complex_expressions/Exists1ExpInIfExp b/core/codegen/javagen/src/test/resources/complex_expressions/Exists1ExpInIfExp similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/Exists1ExpInIfExp rename to core/codegen/javagen/src/test/resources/complex_expressions/Exists1ExpInIfExp diff --git a/core/codegen/src/test/resources/complex_expressions/Exists1ExpInIfExp.result b/core/codegen/javagen/src/test/resources/complex_expressions/Exists1ExpInIfExp.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/Exists1ExpInIfExp.result rename to core/codegen/javagen/src/test/resources/complex_expressions/Exists1ExpInIfExp.result diff --git a/core/codegen/src/test/resources/complex_expressions/Exists1ExpInLet b/core/codegen/javagen/src/test/resources/complex_expressions/Exists1ExpInLet similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/Exists1ExpInLet rename to core/codegen/javagen/src/test/resources/complex_expressions/Exists1ExpInLet diff --git a/core/codegen/src/test/resources/complex_expressions/Exists1ExpInLet.result b/core/codegen/javagen/src/test/resources/complex_expressions/Exists1ExpInLet.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/Exists1ExpInLet.result rename to core/codegen/javagen/src/test/resources/complex_expressions/Exists1ExpInLet.result diff --git a/core/codegen/src/test/resources/complex_expressions/Exists1ExpReturned b/core/codegen/javagen/src/test/resources/complex_expressions/Exists1ExpReturned similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/Exists1ExpReturned rename to core/codegen/javagen/src/test/resources/complex_expressions/Exists1ExpReturned diff --git a/core/codegen/src/test/resources/complex_expressions/Exists1ExpReturned.result b/core/codegen/javagen/src/test/resources/complex_expressions/Exists1ExpReturned.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/Exists1ExpReturned.result rename to core/codegen/javagen/src/test/resources/complex_expressions/Exists1ExpReturned.result diff --git a/core/codegen/src/test/resources/complex_expressions/ExistsExpBlockStm b/core/codegen/javagen/src/test/resources/complex_expressions/ExistsExpBlockStm similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ExistsExpBlockStm rename to core/codegen/javagen/src/test/resources/complex_expressions/ExistsExpBlockStm diff --git a/core/codegen/src/test/resources/complex_expressions/ExistsExpBlockStm.result b/core/codegen/javagen/src/test/resources/complex_expressions/ExistsExpBlockStm.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ExistsExpBlockStm.result rename to core/codegen/javagen/src/test/resources/complex_expressions/ExistsExpBlockStm.result diff --git a/core/codegen/src/test/resources/complex_expressions/ExistsExpInIfExp b/core/codegen/javagen/src/test/resources/complex_expressions/ExistsExpInIfExp similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ExistsExpInIfExp rename to core/codegen/javagen/src/test/resources/complex_expressions/ExistsExpInIfExp diff --git a/core/codegen/src/test/resources/complex_expressions/ExistsExpInIfExp.result b/core/codegen/javagen/src/test/resources/complex_expressions/ExistsExpInIfExp.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ExistsExpInIfExp.result rename to core/codegen/javagen/src/test/resources/complex_expressions/ExistsExpInIfExp.result diff --git a/core/codegen/src/test/resources/complex_expressions/ExistsExpInLet b/core/codegen/javagen/src/test/resources/complex_expressions/ExistsExpInLet similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ExistsExpInLet rename to core/codegen/javagen/src/test/resources/complex_expressions/ExistsExpInLet diff --git a/core/codegen/src/test/resources/complex_expressions/ExistsExpInLet.result b/core/codegen/javagen/src/test/resources/complex_expressions/ExistsExpInLet.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ExistsExpInLet.result rename to core/codegen/javagen/src/test/resources/complex_expressions/ExistsExpInLet.result diff --git a/core/codegen/src/test/resources/complex_expressions/ExistsExpReturned b/core/codegen/javagen/src/test/resources/complex_expressions/ExistsExpReturned similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ExistsExpReturned rename to core/codegen/javagen/src/test/resources/complex_expressions/ExistsExpReturned diff --git a/core/codegen/src/test/resources/complex_expressions/ExistsExpReturned.result b/core/codegen/javagen/src/test/resources/complex_expressions/ExistsExpReturned.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ExistsExpReturned.result rename to core/codegen/javagen/src/test/resources/complex_expressions/ExistsExpReturned.result diff --git a/core/codegen/src/test/resources/complex_expressions/ExistsExpSeveralMultipleSetBindsCond1 b/core/codegen/javagen/src/test/resources/complex_expressions/ExistsExpSeveralMultipleSetBindsCond1 similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ExistsExpSeveralMultipleSetBindsCond1 rename to core/codegen/javagen/src/test/resources/complex_expressions/ExistsExpSeveralMultipleSetBindsCond1 diff --git a/core/codegen/src/test/resources/complex_expressions/ExistsExpSeveralMultipleSetBindsCond1.result b/core/codegen/javagen/src/test/resources/complex_expressions/ExistsExpSeveralMultipleSetBindsCond1.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ExistsExpSeveralMultipleSetBindsCond1.result rename to core/codegen/javagen/src/test/resources/complex_expressions/ExistsExpSeveralMultipleSetBindsCond1.result diff --git a/core/codegen/src/test/resources/complex_expressions/ExistsRemoveAllMultipleSetBinds b/core/codegen/javagen/src/test/resources/complex_expressions/ExistsRemoveAllMultipleSetBinds similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ExistsRemoveAllMultipleSetBinds rename to core/codegen/javagen/src/test/resources/complex_expressions/ExistsRemoveAllMultipleSetBinds diff --git a/core/codegen/src/test/resources/complex_expressions/ExistsRemoveAllMultipleSetBinds.result b/core/codegen/javagen/src/test/resources/complex_expressions/ExistsRemoveAllMultipleSetBinds.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ExistsRemoveAllMultipleSetBinds.result rename to core/codegen/javagen/src/test/resources/complex_expressions/ExistsRemoveAllMultipleSetBinds.result diff --git a/core/codegen/src/test/resources/complex_expressions/ExistsRemoveOneOfTwoMultipleSetBinds b/core/codegen/javagen/src/test/resources/complex_expressions/ExistsRemoveOneOfTwoMultipleSetBinds similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ExistsRemoveOneOfTwoMultipleSetBinds rename to core/codegen/javagen/src/test/resources/complex_expressions/ExistsRemoveOneOfTwoMultipleSetBinds diff --git a/core/codegen/src/test/resources/complex_expressions/ExistsRemoveOneOfTwoMultipleSetBinds.result b/core/codegen/javagen/src/test/resources/complex_expressions/ExistsRemoveOneOfTwoMultipleSetBinds.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ExistsRemoveOneOfTwoMultipleSetBinds.result rename to core/codegen/javagen/src/test/resources/complex_expressions/ExistsRemoveOneOfTwoMultipleSetBinds.result diff --git a/core/codegen/src/test/resources/complex_expressions/ExplicitNameCallStm b/core/codegen/javagen/src/test/resources/complex_expressions/ExplicitNameCallStm similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ExplicitNameCallStm rename to core/codegen/javagen/src/test/resources/complex_expressions/ExplicitNameCallStm diff --git a/core/codegen/src/test/resources/complex_expressions/ExplicitNameCallStm.result b/core/codegen/javagen/src/test/resources/complex_expressions/ExplicitNameCallStm.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ExplicitNameCallStm.result rename to core/codegen/javagen/src/test/resources/complex_expressions/ExplicitNameCallStm.result diff --git a/core/codegen/src/test/resources/complex_expressions/ExplicitNameVarExp b/core/codegen/javagen/src/test/resources/complex_expressions/ExplicitNameVarExp similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ExplicitNameVarExp rename to core/codegen/javagen/src/test/resources/complex_expressions/ExplicitNameVarExp diff --git a/core/codegen/src/test/resources/complex_expressions/ExplicitNameVarExp.result b/core/codegen/javagen/src/test/resources/complex_expressions/ExplicitNameVarExp.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ExplicitNameVarExp.result rename to core/codegen/javagen/src/test/resources/complex_expressions/ExplicitNameVarExp.result diff --git a/core/codegen/src/test/resources/complex_expressions/FieldDesignatorOfRecObj b/core/codegen/javagen/src/test/resources/complex_expressions/FieldDesignatorOfRecObj similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/FieldDesignatorOfRecObj rename to core/codegen/javagen/src/test/resources/complex_expressions/FieldDesignatorOfRecObj diff --git a/core/codegen/src/test/resources/complex_expressions/FieldDesignatorOfRecObj.result b/core/codegen/javagen/src/test/resources/complex_expressions/FieldDesignatorOfRecObj.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/FieldDesignatorOfRecObj.result rename to core/codegen/javagen/src/test/resources/complex_expressions/FieldDesignatorOfRecObj.result diff --git a/core/codegen/src/test/resources/complex_expressions/FieldDesignatorOfRecObjChainOfThree b/core/codegen/javagen/src/test/resources/complex_expressions/FieldDesignatorOfRecObjChainOfThree similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/FieldDesignatorOfRecObjChainOfThree rename to core/codegen/javagen/src/test/resources/complex_expressions/FieldDesignatorOfRecObjChainOfThree diff --git a/core/codegen/src/test/resources/complex_expressions/FieldDesignatorOfRecObjChainOfThree.result b/core/codegen/javagen/src/test/resources/complex_expressions/FieldDesignatorOfRecObjChainOfThree.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/FieldDesignatorOfRecObjChainOfThree.result rename to core/codegen/javagen/src/test/resources/complex_expressions/FieldDesignatorOfRecObjChainOfThree.result diff --git a/core/codegen/src/test/resources/complex_expressions/FieldDesignatorOfRecObjChainOfTwo b/core/codegen/javagen/src/test/resources/complex_expressions/FieldDesignatorOfRecObjChainOfTwo similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/FieldDesignatorOfRecObjChainOfTwo rename to core/codegen/javagen/src/test/resources/complex_expressions/FieldDesignatorOfRecObjChainOfTwo diff --git a/core/codegen/src/test/resources/complex_expressions/FieldDesignatorOfRecObjChainOfTwo.result b/core/codegen/javagen/src/test/resources/complex_expressions/FieldDesignatorOfRecObjChainOfTwo.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/FieldDesignatorOfRecObjChainOfTwo.result rename to core/codegen/javagen/src/test/resources/complex_expressions/FieldDesignatorOfRecObjChainOfTwo.result diff --git a/core/codegen/src/test/resources/complex_expressions/ForAllExpBlockStm b/core/codegen/javagen/src/test/resources/complex_expressions/ForAllExpBlockStm similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ForAllExpBlockStm rename to core/codegen/javagen/src/test/resources/complex_expressions/ForAllExpBlockStm diff --git a/core/codegen/src/test/resources/complex_expressions/ForAllExpBlockStm.result b/core/codegen/javagen/src/test/resources/complex_expressions/ForAllExpBlockStm.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ForAllExpBlockStm.result rename to core/codegen/javagen/src/test/resources/complex_expressions/ForAllExpBlockStm.result diff --git a/core/codegen/src/test/resources/complex_expressions/ForAllExpInIfExp b/core/codegen/javagen/src/test/resources/complex_expressions/ForAllExpInIfExp similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ForAllExpInIfExp rename to core/codegen/javagen/src/test/resources/complex_expressions/ForAllExpInIfExp diff --git a/core/codegen/src/test/resources/complex_expressions/ForAllExpInIfExp.result b/core/codegen/javagen/src/test/resources/complex_expressions/ForAllExpInIfExp.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ForAllExpInIfExp.result rename to core/codegen/javagen/src/test/resources/complex_expressions/ForAllExpInIfExp.result diff --git a/core/codegen/src/test/resources/complex_expressions/ForAllExpInLet b/core/codegen/javagen/src/test/resources/complex_expressions/ForAllExpInLet similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ForAllExpInLet rename to core/codegen/javagen/src/test/resources/complex_expressions/ForAllExpInLet diff --git a/core/codegen/src/test/resources/complex_expressions/ForAllExpInLet.result b/core/codegen/javagen/src/test/resources/complex_expressions/ForAllExpInLet.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ForAllExpInLet.result rename to core/codegen/javagen/src/test/resources/complex_expressions/ForAllExpInLet.result diff --git a/core/codegen/src/test/resources/complex_expressions/ForAllExpReturned b/core/codegen/javagen/src/test/resources/complex_expressions/ForAllExpReturned similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ForAllExpReturned rename to core/codegen/javagen/src/test/resources/complex_expressions/ForAllExpReturned diff --git a/core/codegen/src/test/resources/complex_expressions/ForAllExpReturned.result b/core/codegen/javagen/src/test/resources/complex_expressions/ForAllExpReturned.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ForAllExpReturned.result rename to core/codegen/javagen/src/test/resources/complex_expressions/ForAllExpReturned.result diff --git a/core/codegen/src/test/resources/complex_expressions/ForAllExpSeveralMultipleSetBindsCond1 b/core/codegen/javagen/src/test/resources/complex_expressions/ForAllExpSeveralMultipleSetBindsCond1 similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ForAllExpSeveralMultipleSetBindsCond1 rename to core/codegen/javagen/src/test/resources/complex_expressions/ForAllExpSeveralMultipleSetBindsCond1 diff --git a/core/codegen/src/test/resources/complex_expressions/ForAllExpSeveralMultipleSetBindsCond1.result b/core/codegen/javagen/src/test/resources/complex_expressions/ForAllExpSeveralMultipleSetBindsCond1.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ForAllExpSeveralMultipleSetBindsCond1.result rename to core/codegen/javagen/src/test/resources/complex_expressions/ForAllExpSeveralMultipleSetBindsCond1.result diff --git a/core/codegen/src/test/resources/complex_expressions/ForAllExpTransformedCond b/core/codegen/javagen/src/test/resources/complex_expressions/ForAllExpTransformedCond similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ForAllExpTransformedCond rename to core/codegen/javagen/src/test/resources/complex_expressions/ForAllExpTransformedCond diff --git a/core/codegen/src/test/resources/complex_expressions/ForAllExpTransformedCond.result b/core/codegen/javagen/src/test/resources/complex_expressions/ForAllExpTransformedCond.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ForAllExpTransformedCond.result rename to core/codegen/javagen/src/test/resources/complex_expressions/ForAllExpTransformedCond.result diff --git a/core/codegen/src/test/resources/complex_expressions/ForAllRemoveAllMultipleSetBinds b/core/codegen/javagen/src/test/resources/complex_expressions/ForAllRemoveAllMultipleSetBinds similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ForAllRemoveAllMultipleSetBinds rename to core/codegen/javagen/src/test/resources/complex_expressions/ForAllRemoveAllMultipleSetBinds diff --git a/core/codegen/src/test/resources/complex_expressions/ForAllRemoveAllMultipleSetBinds.result b/core/codegen/javagen/src/test/resources/complex_expressions/ForAllRemoveAllMultipleSetBinds.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ForAllRemoveAllMultipleSetBinds.result rename to core/codegen/javagen/src/test/resources/complex_expressions/ForAllRemoveAllMultipleSetBinds.result diff --git a/core/codegen/src/test/resources/complex_expressions/ForAllRemoveOneOfTwoMultipleSetBinds b/core/codegen/javagen/src/test/resources/complex_expressions/ForAllRemoveOneOfTwoMultipleSetBinds similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ForAllRemoveOneOfTwoMultipleSetBinds rename to core/codegen/javagen/src/test/resources/complex_expressions/ForAllRemoveOneOfTwoMultipleSetBinds diff --git a/core/codegen/src/test/resources/complex_expressions/ForAllRemoveOneOfTwoMultipleSetBinds.result b/core/codegen/javagen/src/test/resources/complex_expressions/ForAllRemoveOneOfTwoMultipleSetBinds.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/ForAllRemoveOneOfTwoMultipleSetBinds.result rename to core/codegen/javagen/src/test/resources/complex_expressions/ForAllRemoveOneOfTwoMultipleSetBinds.result diff --git a/core/codegen/src/test/resources/complex_expressions/HdExpNumberDeref b/core/codegen/javagen/src/test/resources/complex_expressions/HdExpNumberDeref similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/HdExpNumberDeref rename to core/codegen/javagen/src/test/resources/complex_expressions/HdExpNumberDeref diff --git a/core/codegen/src/test/resources/complex_expressions/HdExpNumberDeref.result b/core/codegen/javagen/src/test/resources/complex_expressions/HdExpNumberDeref.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/HdExpNumberDeref.result rename to core/codegen/javagen/src/test/resources/complex_expressions/HdExpNumberDeref.result diff --git a/core/codegen/src/test/resources/complex_expressions/IfExpAndExpBranch b/core/codegen/javagen/src/test/resources/complex_expressions/IfExpAndExpBranch similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/IfExpAndExpBranch rename to core/codegen/javagen/src/test/resources/complex_expressions/IfExpAndExpBranch diff --git a/core/codegen/src/test/resources/complex_expressions/IfExpAndExpBranch.result b/core/codegen/javagen/src/test/resources/complex_expressions/IfExpAndExpBranch.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/IfExpAndExpBranch.result rename to core/codegen/javagen/src/test/resources/complex_expressions/IfExpAndExpBranch.result diff --git a/core/codegen/src/test/resources/complex_expressions/InheritedFieldAccess b/core/codegen/javagen/src/test/resources/complex_expressions/InheritedFieldAccess similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/InheritedFieldAccess rename to core/codegen/javagen/src/test/resources/complex_expressions/InheritedFieldAccess diff --git a/core/codegen/src/test/resources/complex_expressions/InheritedFieldAccess.result b/core/codegen/javagen/src/test/resources/complex_expressions/InheritedFieldAccess.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/InheritedFieldAccess.result rename to core/codegen/javagen/src/test/resources/complex_expressions/InheritedFieldAccess.result diff --git a/core/codegen/src/test/resources/complex_expressions/InheritedFuncInvoke b/core/codegen/javagen/src/test/resources/complex_expressions/InheritedFuncInvoke similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/InheritedFuncInvoke rename to core/codegen/javagen/src/test/resources/complex_expressions/InheritedFuncInvoke diff --git a/core/codegen/src/test/resources/complex_expressions/InheritedFuncInvoke.result b/core/codegen/javagen/src/test/resources/complex_expressions/InheritedFuncInvoke.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/InheritedFuncInvoke.result rename to core/codegen/javagen/src/test/resources/complex_expressions/InheritedFuncInvoke.result diff --git a/core/codegen/src/test/resources/complex_expressions/IsExp b/core/codegen/javagen/src/test/resources/complex_expressions/IsExp similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/IsExp rename to core/codegen/javagen/src/test/resources/complex_expressions/IsExp diff --git a/core/codegen/src/test/resources/complex_expressions/IsExp.result b/core/codegen/javagen/src/test/resources/complex_expressions/IsExp.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/IsExp.result rename to core/codegen/javagen/src/test/resources/complex_expressions/IsExp.result diff --git a/core/codegen/src/test/resources/complex_expressions/IsExpNamedTypeInvariantRecursiveTypes b/core/codegen/javagen/src/test/resources/complex_expressions/IsExpNamedTypeInvariantRecursiveTypes similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/IsExpNamedTypeInvariantRecursiveTypes rename to core/codegen/javagen/src/test/resources/complex_expressions/IsExpNamedTypeInvariantRecursiveTypes diff --git a/core/codegen/src/test/resources/complex_expressions/IsExpNamedTypeInvariantRecursiveTypes.result b/core/codegen/javagen/src/test/resources/complex_expressions/IsExpNamedTypeInvariantRecursiveTypes.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/IsExpNamedTypeInvariantRecursiveTypes.result rename to core/codegen/javagen/src/test/resources/complex_expressions/IsExpNamedTypeInvariantRecursiveTypes.result diff --git a/core/codegen/src/test/resources/complex_expressions/IsExpNamedTypeInvariantUnionOfQuotes b/core/codegen/javagen/src/test/resources/complex_expressions/IsExpNamedTypeInvariantUnionOfQuotes similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/IsExpNamedTypeInvariantUnionOfQuotes rename to core/codegen/javagen/src/test/resources/complex_expressions/IsExpNamedTypeInvariantUnionOfQuotes diff --git a/core/codegen/src/test/resources/complex_expressions/IsExpNamedTypeInvariantUnionOfQuotes.result b/core/codegen/javagen/src/test/resources/complex_expressions/IsExpNamedTypeInvariantUnionOfQuotes.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/IsExpNamedTypeInvariantUnionOfQuotes.result rename to core/codegen/javagen/src/test/resources/complex_expressions/IsExpNamedTypeInvariantUnionOfQuotes.result diff --git a/core/codegen/src/test/resources/complex_expressions/IsExpNatUnionBool b/core/codegen/javagen/src/test/resources/complex_expressions/IsExpNatUnionBool similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/IsExpNatUnionBool rename to core/codegen/javagen/src/test/resources/complex_expressions/IsExpNatUnionBool diff --git a/core/codegen/src/test/resources/complex_expressions/IsExpNatUnionBool.result b/core/codegen/javagen/src/test/resources/complex_expressions/IsExpNatUnionBool.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/IsExpNatUnionBool.result rename to core/codegen/javagen/src/test/resources/complex_expressions/IsExpNatUnionBool.result diff --git a/core/codegen/src/test/resources/complex_expressions/IsExpQuoteType b/core/codegen/javagen/src/test/resources/complex_expressions/IsExpQuoteType similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/IsExpQuoteType rename to core/codegen/javagen/src/test/resources/complex_expressions/IsExpQuoteType diff --git a/core/codegen/src/test/resources/complex_expressions/IsExpQuoteType.result b/core/codegen/javagen/src/test/resources/complex_expressions/IsExpQuoteType.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/IsExpQuoteType.result rename to core/codegen/javagen/src/test/resources/complex_expressions/IsExpQuoteType.result diff --git a/core/codegen/src/test/resources/complex_expressions/LetBeExpWithLetExp b/core/codegen/javagen/src/test/resources/complex_expressions/LetBeExpWithLetExp similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/LetBeExpWithLetExp rename to core/codegen/javagen/src/test/resources/complex_expressions/LetBeExpWithLetExp diff --git a/core/codegen/src/test/resources/complex_expressions/LetBeExpWithLetExp.result b/core/codegen/javagen/src/test/resources/complex_expressions/LetBeExpWithLetExp.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/LetBeExpWithLetExp.result rename to core/codegen/javagen/src/test/resources/complex_expressions/LetBeExpWithLetExp.result diff --git a/core/codegen/src/test/resources/complex_expressions/LetBeStExpInBlock b/core/codegen/javagen/src/test/resources/complex_expressions/LetBeStExpInBlock similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/LetBeStExpInBlock rename to core/codegen/javagen/src/test/resources/complex_expressions/LetBeStExpInBlock diff --git a/core/codegen/src/test/resources/complex_expressions/LetBeStExpInBlock.result b/core/codegen/javagen/src/test/resources/complex_expressions/LetBeStExpInBlock.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/LetBeStExpInBlock.result rename to core/codegen/javagen/src/test/resources/complex_expressions/LetBeStExpInBlock.result diff --git a/core/codegen/src/test/resources/complex_expressions/LetBeStExpInFuncWithCond b/core/codegen/javagen/src/test/resources/complex_expressions/LetBeStExpInFuncWithCond similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/LetBeStExpInFuncWithCond rename to core/codegen/javagen/src/test/resources/complex_expressions/LetBeStExpInFuncWithCond diff --git a/core/codegen/src/test/resources/complex_expressions/LetBeStExpInFuncWithCond.result b/core/codegen/javagen/src/test/resources/complex_expressions/LetBeStExpInFuncWithCond.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/LetBeStExpInFuncWithCond.result rename to core/codegen/javagen/src/test/resources/complex_expressions/LetBeStExpInFuncWithCond.result diff --git a/core/codegen/src/test/resources/complex_expressions/LetBeStExpInLetDef b/core/codegen/javagen/src/test/resources/complex_expressions/LetBeStExpInLetDef similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/LetBeStExpInLetDef rename to core/codegen/javagen/src/test/resources/complex_expressions/LetBeStExpInLetDef diff --git a/core/codegen/src/test/resources/complex_expressions/LetBeStExpInLetDef.result b/core/codegen/javagen/src/test/resources/complex_expressions/LetBeStExpInLetDef.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/LetBeStExpInLetDef.result rename to core/codegen/javagen/src/test/resources/complex_expressions/LetBeStExpInLetDef.result diff --git a/core/codegen/src/test/resources/complex_expressions/LetBeStExpInReturnWithCond b/core/codegen/javagen/src/test/resources/complex_expressions/LetBeStExpInReturnWithCond similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/LetBeStExpInReturnWithCond rename to core/codegen/javagen/src/test/resources/complex_expressions/LetBeStExpInReturnWithCond diff --git a/core/codegen/src/test/resources/complex_expressions/LetBeStExpInReturnWithCond.result b/core/codegen/javagen/src/test/resources/complex_expressions/LetBeStExpInReturnWithCond.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/LetBeStExpInReturnWithCond.result rename to core/codegen/javagen/src/test/resources/complex_expressions/LetBeStExpInReturnWithCond.result diff --git a/core/codegen/src/test/resources/complex_expressions/LetBeStExpRemoveSet b/core/codegen/javagen/src/test/resources/complex_expressions/LetBeStExpRemoveSet similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/LetBeStExpRemoveSet rename to core/codegen/javagen/src/test/resources/complex_expressions/LetBeStExpRemoveSet diff --git a/core/codegen/src/test/resources/complex_expressions/LetBeStExpRemoveSet.result b/core/codegen/javagen/src/test/resources/complex_expressions/LetBeStExpRemoveSet.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/LetBeStExpRemoveSet.result rename to core/codegen/javagen/src/test/resources/complex_expressions/LetBeStExpRemoveSet.result diff --git a/core/codegen/src/test/resources/complex_expressions/LetBeStExpSetSum b/core/codegen/javagen/src/test/resources/complex_expressions/LetBeStExpSetSum similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/LetBeStExpSetSum rename to core/codegen/javagen/src/test/resources/complex_expressions/LetBeStExpSetSum diff --git a/core/codegen/src/test/resources/complex_expressions/LetBeStExpSetSum.result b/core/codegen/javagen/src/test/resources/complex_expressions/LetBeStExpSetSum.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/LetBeStExpSetSum.result rename to core/codegen/javagen/src/test/resources/complex_expressions/LetBeStExpSetSum.result diff --git a/core/codegen/src/test/resources/complex_expressions/LetBeStExpSimpleNoCond b/core/codegen/javagen/src/test/resources/complex_expressions/LetBeStExpSimpleNoCond similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/LetBeStExpSimpleNoCond rename to core/codegen/javagen/src/test/resources/complex_expressions/LetBeStExpSimpleNoCond diff --git a/core/codegen/src/test/resources/complex_expressions/LetBeStExpSimpleNoCond.result b/core/codegen/javagen/src/test/resources/complex_expressions/LetBeStExpSimpleNoCond.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/LetBeStExpSimpleNoCond.result rename to core/codegen/javagen/src/test/resources/complex_expressions/LetBeStExpSimpleNoCond.result diff --git a/core/codegen/src/test/resources/complex_expressions/LetBeStExpTransformedCond b/core/codegen/javagen/src/test/resources/complex_expressions/LetBeStExpTransformedCond similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/LetBeStExpTransformedCond rename to core/codegen/javagen/src/test/resources/complex_expressions/LetBeStExpTransformedCond diff --git a/core/codegen/src/test/resources/complex_expressions/LetBeStExpTransformedCond.result b/core/codegen/javagen/src/test/resources/complex_expressions/LetBeStExpTransformedCond.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/LetBeStExpTransformedCond.result rename to core/codegen/javagen/src/test/resources/complex_expressions/LetBeStExpTransformedCond.result diff --git a/core/codegen/src/test/resources/complex_expressions/LetBeStNoCondSetSum b/core/codegen/javagen/src/test/resources/complex_expressions/LetBeStNoCondSetSum similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/LetBeStNoCondSetSum rename to core/codegen/javagen/src/test/resources/complex_expressions/LetBeStNoCondSetSum diff --git a/core/codegen/src/test/resources/complex_expressions/LetBeStNoCondSetSum.result b/core/codegen/javagen/src/test/resources/complex_expressions/LetBeStNoCondSetSum.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/LetBeStNoCondSetSum.result rename to core/codegen/javagen/src/test/resources/complex_expressions/LetBeStNoCondSetSum.result diff --git a/core/codegen/src/test/resources/complex_expressions/LetBeStRemoveSet b/core/codegen/javagen/src/test/resources/complex_expressions/LetBeStRemoveSet similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/LetBeStRemoveSet rename to core/codegen/javagen/src/test/resources/complex_expressions/LetBeStRemoveSet diff --git a/core/codegen/src/test/resources/complex_expressions/LetBeStRemoveSet.result b/core/codegen/javagen/src/test/resources/complex_expressions/LetBeStRemoveSet.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/LetBeStRemoveSet.result rename to core/codegen/javagen/src/test/resources/complex_expressions/LetBeStRemoveSet.result diff --git a/core/codegen/src/test/resources/complex_expressions/LetBeStThreeBindsCond b/core/codegen/javagen/src/test/resources/complex_expressions/LetBeStThreeBindsCond similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/LetBeStThreeBindsCond rename to core/codegen/javagen/src/test/resources/complex_expressions/LetBeStThreeBindsCond diff --git a/core/codegen/src/test/resources/complex_expressions/LetBeStThreeBindsCond.result b/core/codegen/javagen/src/test/resources/complex_expressions/LetBeStThreeBindsCond.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/LetBeStThreeBindsCond.result rename to core/codegen/javagen/src/test/resources/complex_expressions/LetBeStThreeBindsCond.result diff --git a/core/codegen/src/test/resources/complex_expressions/LetBeStThreeBindsNoCond b/core/codegen/javagen/src/test/resources/complex_expressions/LetBeStThreeBindsNoCond similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/LetBeStThreeBindsNoCond rename to core/codegen/javagen/src/test/resources/complex_expressions/LetBeStThreeBindsNoCond diff --git a/core/codegen/src/test/resources/complex_expressions/LetBeStThreeBindsNoCond.result b/core/codegen/javagen/src/test/resources/complex_expressions/LetBeStThreeBindsNoCond.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/LetBeStThreeBindsNoCond.result rename to core/codegen/javagen/src/test/resources/complex_expressions/LetBeStThreeBindsNoCond.result diff --git a/core/codegen/src/test/resources/complex_expressions/LetBeStTransformedCond b/core/codegen/javagen/src/test/resources/complex_expressions/LetBeStTransformedCond similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/LetBeStTransformedCond rename to core/codegen/javagen/src/test/resources/complex_expressions/LetBeStTransformedCond diff --git a/core/codegen/src/test/resources/complex_expressions/LetBeStTransformedCond.result b/core/codegen/javagen/src/test/resources/complex_expressions/LetBeStTransformedCond.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/LetBeStTransformedCond.result rename to core/codegen/javagen/src/test/resources/complex_expressions/LetBeStTransformedCond.result diff --git a/core/codegen/src/test/resources/complex_expressions/LetBeStWithCond b/core/codegen/javagen/src/test/resources/complex_expressions/LetBeStWithCond similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/LetBeStWithCond rename to core/codegen/javagen/src/test/resources/complex_expressions/LetBeStWithCond diff --git a/core/codegen/src/test/resources/complex_expressions/LetBeStWithCond.result b/core/codegen/javagen/src/test/resources/complex_expressions/LetBeStWithCond.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/LetBeStWithCond.result rename to core/codegen/javagen/src/test/resources/complex_expressions/LetBeStWithCond.result diff --git a/core/codegen/src/test/resources/complex_expressions/MapCompBlockStm b/core/codegen/javagen/src/test/resources/complex_expressions/MapCompBlockStm similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/MapCompBlockStm rename to core/codegen/javagen/src/test/resources/complex_expressions/MapCompBlockStm diff --git a/core/codegen/src/test/resources/complex_expressions/MapCompBlockStm.result b/core/codegen/javagen/src/test/resources/complex_expressions/MapCompBlockStm.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/MapCompBlockStm.result rename to core/codegen/javagen/src/test/resources/complex_expressions/MapCompBlockStm.result diff --git a/core/codegen/src/test/resources/complex_expressions/MapCompInLet b/core/codegen/javagen/src/test/resources/complex_expressions/MapCompInLet similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/MapCompInLet rename to core/codegen/javagen/src/test/resources/complex_expressions/MapCompInLet diff --git a/core/codegen/src/test/resources/complex_expressions/MapCompInLet.result b/core/codegen/javagen/src/test/resources/complex_expressions/MapCompInLet.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/MapCompInLet.result rename to core/codegen/javagen/src/test/resources/complex_expressions/MapCompInLet.result diff --git a/core/codegen/src/test/resources/complex_expressions/MapCompInOpCallInLoop b/core/codegen/javagen/src/test/resources/complex_expressions/MapCompInOpCallInLoop similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/MapCompInOpCallInLoop rename to core/codegen/javagen/src/test/resources/complex_expressions/MapCompInOpCallInLoop diff --git a/core/codegen/src/test/resources/complex_expressions/MapCompInOpCallInLoop.result b/core/codegen/javagen/src/test/resources/complex_expressions/MapCompInOpCallInLoop.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/MapCompInOpCallInLoop.result rename to core/codegen/javagen/src/test/resources/complex_expressions/MapCompInOpCallInLoop.result diff --git a/core/codegen/src/test/resources/complex_expressions/MapCompRemoveAllMultipleSetBinds b/core/codegen/javagen/src/test/resources/complex_expressions/MapCompRemoveAllMultipleSetBinds similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/MapCompRemoveAllMultipleSetBinds rename to core/codegen/javagen/src/test/resources/complex_expressions/MapCompRemoveAllMultipleSetBinds diff --git a/core/codegen/src/test/resources/complex_expressions/MapCompRemoveAllMultipleSetBinds.result b/core/codegen/javagen/src/test/resources/complex_expressions/MapCompRemoveAllMultipleSetBinds.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/MapCompRemoveAllMultipleSetBinds.result rename to core/codegen/javagen/src/test/resources/complex_expressions/MapCompRemoveAllMultipleSetBinds.result diff --git a/core/codegen/src/test/resources/complex_expressions/MapCompRemoveOneOfTwoMultipleSetBinds b/core/codegen/javagen/src/test/resources/complex_expressions/MapCompRemoveOneOfTwoMultipleSetBinds similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/MapCompRemoveOneOfTwoMultipleSetBinds rename to core/codegen/javagen/src/test/resources/complex_expressions/MapCompRemoveOneOfTwoMultipleSetBinds diff --git a/core/codegen/src/test/resources/complex_expressions/MapCompRemoveOneOfTwoMultipleSetBinds.result b/core/codegen/javagen/src/test/resources/complex_expressions/MapCompRemoveOneOfTwoMultipleSetBinds.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/MapCompRemoveOneOfTwoMultipleSetBinds.result rename to core/codegen/javagen/src/test/resources/complex_expressions/MapCompRemoveOneOfTwoMultipleSetBinds.result diff --git a/core/codegen/src/test/resources/complex_expressions/MapCompReturnThreePatternsCond b/core/codegen/javagen/src/test/resources/complex_expressions/MapCompReturnThreePatternsCond similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/MapCompReturnThreePatternsCond rename to core/codegen/javagen/src/test/resources/complex_expressions/MapCompReturnThreePatternsCond diff --git a/core/codegen/src/test/resources/complex_expressions/MapCompReturnThreePatternsCond.result b/core/codegen/javagen/src/test/resources/complex_expressions/MapCompReturnThreePatternsCond.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/MapCompReturnThreePatternsCond.result rename to core/codegen/javagen/src/test/resources/complex_expressions/MapCompReturnThreePatternsCond.result diff --git a/core/codegen/src/test/resources/complex_expressions/MapCompReturned b/core/codegen/javagen/src/test/resources/complex_expressions/MapCompReturned similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/MapCompReturned rename to core/codegen/javagen/src/test/resources/complex_expressions/MapCompReturned diff --git a/core/codegen/src/test/resources/complex_expressions/MapCompReturned.result b/core/codegen/javagen/src/test/resources/complex_expressions/MapCompReturned.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/MapCompReturned.result rename to core/codegen/javagen/src/test/resources/complex_expressions/MapCompReturned.result diff --git a/core/codegen/src/test/resources/complex_expressions/MapCompSeveralMultipleSetBindsCond1 b/core/codegen/javagen/src/test/resources/complex_expressions/MapCompSeveralMultipleSetBindsCond1 similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/MapCompSeveralMultipleSetBindsCond1 rename to core/codegen/javagen/src/test/resources/complex_expressions/MapCompSeveralMultipleSetBindsCond1 diff --git a/core/codegen/src/test/resources/complex_expressions/MapCompSeveralMultipleSetBindsCond1.result b/core/codegen/javagen/src/test/resources/complex_expressions/MapCompSeveralMultipleSetBindsCond1.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/MapCompSeveralMultipleSetBindsCond1.result rename to core/codegen/javagen/src/test/resources/complex_expressions/MapCompSeveralMultipleSetBindsCond1.result diff --git a/core/codegen/src/test/resources/complex_expressions/MapCompSeveralMultipleSetBindsCond2 b/core/codegen/javagen/src/test/resources/complex_expressions/MapCompSeveralMultipleSetBindsCond2 similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/MapCompSeveralMultipleSetBindsCond2 rename to core/codegen/javagen/src/test/resources/complex_expressions/MapCompSeveralMultipleSetBindsCond2 diff --git a/core/codegen/src/test/resources/complex_expressions/MapCompSeveralMultipleSetBindsCond2.result b/core/codegen/javagen/src/test/resources/complex_expressions/MapCompSeveralMultipleSetBindsCond2.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/MapCompSeveralMultipleSetBindsCond2.result rename to core/codegen/javagen/src/test/resources/complex_expressions/MapCompSeveralMultipleSetBindsCond2.result diff --git a/core/codegen/src/test/resources/complex_expressions/MapCompSeveralMultipleSetBindsCond3 b/core/codegen/javagen/src/test/resources/complex_expressions/MapCompSeveralMultipleSetBindsCond3 similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/MapCompSeveralMultipleSetBindsCond3 rename to core/codegen/javagen/src/test/resources/complex_expressions/MapCompSeveralMultipleSetBindsCond3 diff --git a/core/codegen/src/test/resources/complex_expressions/MapCompSeveralMultipleSetBindsCond3.result b/core/codegen/javagen/src/test/resources/complex_expressions/MapCompSeveralMultipleSetBindsCond3.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/MapCompSeveralMultipleSetBindsCond3.result rename to core/codegen/javagen/src/test/resources/complex_expressions/MapCompSeveralMultipleSetBindsCond3.result diff --git a/core/codegen/src/test/resources/complex_expressions/MapCompSeveralMultipleSetBindsNoCond b/core/codegen/javagen/src/test/resources/complex_expressions/MapCompSeveralMultipleSetBindsNoCond similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/MapCompSeveralMultipleSetBindsNoCond rename to core/codegen/javagen/src/test/resources/complex_expressions/MapCompSeveralMultipleSetBindsNoCond diff --git a/core/codegen/src/test/resources/complex_expressions/MapCompSeveralMultipleSetBindsNoCond.result b/core/codegen/javagen/src/test/resources/complex_expressions/MapCompSeveralMultipleSetBindsNoCond.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/MapCompSeveralMultipleSetBindsNoCond.result rename to core/codegen/javagen/src/test/resources/complex_expressions/MapCompSeveralMultipleSetBindsNoCond.result diff --git a/core/codegen/src/test/resources/complex_expressions/MapCompTransformedMaplet b/core/codegen/javagen/src/test/resources/complex_expressions/MapCompTransformedMaplet similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/MapCompTransformedMaplet rename to core/codegen/javagen/src/test/resources/complex_expressions/MapCompTransformedMaplet diff --git a/core/codegen/src/test/resources/complex_expressions/MapCompTransformedMaplet.result b/core/codegen/javagen/src/test/resources/complex_expressions/MapCompTransformedMaplet.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/MapCompTransformedMaplet.result rename to core/codegen/javagen/src/test/resources/complex_expressions/MapCompTransformedMaplet.result diff --git a/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorChangeRecField b/core/codegen/javagen/src/test/resources/complex_expressions/MapSeqStateDesignatorChangeRecField similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorChangeRecField rename to core/codegen/javagen/src/test/resources/complex_expressions/MapSeqStateDesignatorChangeRecField diff --git a/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorChangeRecField.result b/core/codegen/javagen/src/test/resources/complex_expressions/MapSeqStateDesignatorChangeRecField.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorChangeRecField.result rename to core/codegen/javagen/src/test/resources/complex_expressions/MapSeqStateDesignatorChangeRecField.result diff --git a/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapInMap b/core/codegen/javagen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapInMap similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapInMap rename to core/codegen/javagen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapInMap diff --git a/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapInMap.result b/core/codegen/javagen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapInMap.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapInMap.result rename to core/codegen/javagen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapInMap.result diff --git a/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapSeqToSeq b/core/codegen/javagen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapSeqToSeq similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapSeqToSeq rename to core/codegen/javagen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapSeqToSeq diff --git a/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapSeqToSeq.result b/core/codegen/javagen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapSeqToSeq.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapSeqToSeq.result rename to core/codegen/javagen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapSeqToSeq.result diff --git a/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapUpdate b/core/codegen/javagen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapUpdate similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapUpdate rename to core/codegen/javagen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapUpdate diff --git a/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapUpdate.result b/core/codegen/javagen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapUpdate.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapUpdate.result rename to core/codegen/javagen/src/test/resources/complex_expressions/MapSeqStateDesignatorMapUpdate.result diff --git a/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorNesting b/core/codegen/javagen/src/test/resources/complex_expressions/MapSeqStateDesignatorNesting similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorNesting rename to core/codegen/javagen/src/test/resources/complex_expressions/MapSeqStateDesignatorNesting diff --git a/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorNesting.result b/core/codegen/javagen/src/test/resources/complex_expressions/MapSeqStateDesignatorNesting.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorNesting.result rename to core/codegen/javagen/src/test/resources/complex_expressions/MapSeqStateDesignatorNesting.result diff --git a/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorSeqInSeqInSeq b/core/codegen/javagen/src/test/resources/complex_expressions/MapSeqStateDesignatorSeqInSeqInSeq similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorSeqInSeqInSeq rename to core/codegen/javagen/src/test/resources/complex_expressions/MapSeqStateDesignatorSeqInSeqInSeq diff --git a/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorSeqInSeqInSeq.result b/core/codegen/javagen/src/test/resources/complex_expressions/MapSeqStateDesignatorSeqInSeqInSeq.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorSeqInSeqInSeq.result rename to core/codegen/javagen/src/test/resources/complex_expressions/MapSeqStateDesignatorSeqInSeqInSeq.result diff --git a/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorSeqUpdate b/core/codegen/javagen/src/test/resources/complex_expressions/MapSeqStateDesignatorSeqUpdate similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorSeqUpdate rename to core/codegen/javagen/src/test/resources/complex_expressions/MapSeqStateDesignatorSeqUpdate diff --git a/core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorSeqUpdate.result b/core/codegen/javagen/src/test/resources/complex_expressions/MapSeqStateDesignatorSeqUpdate.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/MapSeqStateDesignatorSeqUpdate.result rename to core/codegen/javagen/src/test/resources/complex_expressions/MapSeqStateDesignatorSeqUpdate.result diff --git a/core/codegen/src/test/resources/complex_expressions/MethodInstantiation b/core/codegen/javagen/src/test/resources/complex_expressions/MethodInstantiation similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/MethodInstantiation rename to core/codegen/javagen/src/test/resources/complex_expressions/MethodInstantiation diff --git a/core/codegen/src/test/resources/complex_expressions/MethodInstantiation.result b/core/codegen/javagen/src/test/resources/complex_expressions/MethodInstantiation.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/MethodInstantiation.result rename to core/codegen/javagen/src/test/resources/complex_expressions/MethodInstantiation.result diff --git a/core/codegen/src/test/resources/complex_expressions/NotEqualsOptionalType b/core/codegen/javagen/src/test/resources/complex_expressions/NotEqualsOptionalType similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/NotEqualsOptionalType rename to core/codegen/javagen/src/test/resources/complex_expressions/NotEqualsOptionalType diff --git a/core/codegen/src/test/resources/complex_expressions/NotEqualsOptionalType.result b/core/codegen/javagen/src/test/resources/complex_expressions/NotEqualsOptionalType.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/NotEqualsOptionalType.result rename to core/codegen/javagen/src/test/resources/complex_expressions/NotEqualsOptionalType.result diff --git a/core/codegen/src/test/resources/complex_expressions/OptionalTypedNumberEqual b/core/codegen/javagen/src/test/resources/complex_expressions/OptionalTypedNumberEqual similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/OptionalTypedNumberEqual rename to core/codegen/javagen/src/test/resources/complex_expressions/OptionalTypedNumberEqual diff --git a/core/codegen/src/test/resources/complex_expressions/OptionalTypedNumberEqual.result b/core/codegen/javagen/src/test/resources/complex_expressions/OptionalTypedNumberEqual.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/OptionalTypedNumberEqual.result rename to core/codegen/javagen/src/test/resources/complex_expressions/OptionalTypedNumberEqual.result diff --git a/core/codegen/src/test/resources/complex_expressions/OptionallyTypedRecordFieldComparison b/core/codegen/javagen/src/test/resources/complex_expressions/OptionallyTypedRecordFieldComparison similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/OptionallyTypedRecordFieldComparison rename to core/codegen/javagen/src/test/resources/complex_expressions/OptionallyTypedRecordFieldComparison diff --git a/core/codegen/src/test/resources/complex_expressions/OptionallyTypedRecordFieldComparison.result b/core/codegen/javagen/src/test/resources/complex_expressions/OptionallyTypedRecordFieldComparison.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/OptionallyTypedRecordFieldComparison.result rename to core/codegen/javagen/src/test/resources/complex_expressions/OptionallyTypedRecordFieldComparison.result diff --git a/core/codegen/src/test/resources/complex_expressions/OptionallyTypedSetComparison b/core/codegen/javagen/src/test/resources/complex_expressions/OptionallyTypedSetComparison similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/OptionallyTypedSetComparison rename to core/codegen/javagen/src/test/resources/complex_expressions/OptionallyTypedSetComparison diff --git a/core/codegen/src/test/resources/complex_expressions/OptionallyTypedSetComparison.result b/core/codegen/javagen/src/test/resources/complex_expressions/OptionallyTypedSetComparison.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/OptionallyTypedSetComparison.result rename to core/codegen/javagen/src/test/resources/complex_expressions/OptionallyTypedSetComparison.result diff --git a/core/codegen/src/test/resources/complex_expressions/OptionallyTypedTupleComp b/core/codegen/javagen/src/test/resources/complex_expressions/OptionallyTypedTupleComp similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/OptionallyTypedTupleComp rename to core/codegen/javagen/src/test/resources/complex_expressions/OptionallyTypedTupleComp diff --git a/core/codegen/src/test/resources/complex_expressions/OptionallyTypedTupleComp.result b/core/codegen/javagen/src/test/resources/complex_expressions/OptionallyTypedTupleComp.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/OptionallyTypedTupleComp.result rename to core/codegen/javagen/src/test/resources/complex_expressions/OptionallyTypedTupleComp.result diff --git a/core/codegen/src/test/resources/complex_expressions/OrExpChain b/core/codegen/javagen/src/test/resources/complex_expressions/OrExpChain similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/OrExpChain rename to core/codegen/javagen/src/test/resources/complex_expressions/OrExpChain diff --git a/core/codegen/src/test/resources/complex_expressions/OrExpChain.result b/core/codegen/javagen/src/test/resources/complex_expressions/OrExpChain.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/OrExpChain.result rename to core/codegen/javagen/src/test/resources/complex_expressions/OrExpChain.result diff --git a/core/codegen/src/test/resources/complex_expressions/OrExpEvalOrder b/core/codegen/javagen/src/test/resources/complex_expressions/OrExpEvalOrder similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/OrExpEvalOrder rename to core/codegen/javagen/src/test/resources/complex_expressions/OrExpEvalOrder diff --git a/core/codegen/src/test/resources/complex_expressions/OrExpEvalOrder.result b/core/codegen/javagen/src/test/resources/complex_expressions/OrExpEvalOrder.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/OrExpEvalOrder.result rename to core/codegen/javagen/src/test/resources/complex_expressions/OrExpEvalOrder.result diff --git a/core/codegen/src/test/resources/complex_expressions/OrExpExistsExps b/core/codegen/javagen/src/test/resources/complex_expressions/OrExpExistsExps similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/OrExpExistsExps rename to core/codegen/javagen/src/test/resources/complex_expressions/OrExpExistsExps diff --git a/core/codegen/src/test/resources/complex_expressions/OrExpExistsExps.result b/core/codegen/javagen/src/test/resources/complex_expressions/OrExpExistsExps.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/OrExpExistsExps.result rename to core/codegen/javagen/src/test/resources/complex_expressions/OrExpExistsExps.result diff --git a/core/codegen/src/test/resources/complex_expressions/OrExpOrChainInForAll b/core/codegen/javagen/src/test/resources/complex_expressions/OrExpOrChainInForAll similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/OrExpOrChainInForAll rename to core/codegen/javagen/src/test/resources/complex_expressions/OrExpOrChainInForAll diff --git a/core/codegen/src/test/resources/complex_expressions/OrExpOrChainInForAll.result b/core/codegen/javagen/src/test/resources/complex_expressions/OrExpOrChainInForAll.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/OrExpOrChainInForAll.result rename to core/codegen/javagen/src/test/resources/complex_expressions/OrExpOrChainInForAll.result diff --git a/core/codegen/src/test/resources/complex_expressions/QuoteLitComparison b/core/codegen/javagen/src/test/resources/complex_expressions/QuoteLitComparison similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/QuoteLitComparison rename to core/codegen/javagen/src/test/resources/complex_expressions/QuoteLitComparison diff --git a/core/codegen/src/test/resources/complex_expressions/QuoteLitComparison.result b/core/codegen/javagen/src/test/resources/complex_expressions/QuoteLitComparison.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/QuoteLitComparison.result rename to core/codegen/javagen/src/test/resources/complex_expressions/QuoteLitComparison.result diff --git a/core/codegen/src/test/resources/complex_expressions/RecModExpArgToApplyExp b/core/codegen/javagen/src/test/resources/complex_expressions/RecModExpArgToApplyExp similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/RecModExpArgToApplyExp rename to core/codegen/javagen/src/test/resources/complex_expressions/RecModExpArgToApplyExp diff --git a/core/codegen/src/test/resources/complex_expressions/RecModExpArgToApplyExp.result b/core/codegen/javagen/src/test/resources/complex_expressions/RecModExpArgToApplyExp.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/RecModExpArgToApplyExp.result rename to core/codegen/javagen/src/test/resources/complex_expressions/RecModExpArgToApplyExp.result diff --git a/core/codegen/src/test/resources/complex_expressions/RecModExpForAllExp b/core/codegen/javagen/src/test/resources/complex_expressions/RecModExpForAllExp similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/RecModExpForAllExp rename to core/codegen/javagen/src/test/resources/complex_expressions/RecModExpForAllExp diff --git a/core/codegen/src/test/resources/complex_expressions/RecModExpForAllExp.result b/core/codegen/javagen/src/test/resources/complex_expressions/RecModExpForAllExp.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/RecModExpForAllExp.result rename to core/codegen/javagen/src/test/resources/complex_expressions/RecModExpForAllExp.result diff --git a/core/codegen/src/test/resources/complex_expressions/RecModExpInRecModExp b/core/codegen/javagen/src/test/resources/complex_expressions/RecModExpInRecModExp similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/RecModExpInRecModExp rename to core/codegen/javagen/src/test/resources/complex_expressions/RecModExpInRecModExp diff --git a/core/codegen/src/test/resources/complex_expressions/RecModExpInRecModExp.result b/core/codegen/javagen/src/test/resources/complex_expressions/RecModExpInRecModExp.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/RecModExpInRecModExp.result rename to core/codegen/javagen/src/test/resources/complex_expressions/RecModExpInRecModExp.result diff --git a/core/codegen/src/test/resources/complex_expressions/RecModExpSimple1 b/core/codegen/javagen/src/test/resources/complex_expressions/RecModExpSimple1 similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/RecModExpSimple1 rename to core/codegen/javagen/src/test/resources/complex_expressions/RecModExpSimple1 diff --git a/core/codegen/src/test/resources/complex_expressions/RecModExpSimple1.result b/core/codegen/javagen/src/test/resources/complex_expressions/RecModExpSimple1.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/RecModExpSimple1.result rename to core/codegen/javagen/src/test/resources/complex_expressions/RecModExpSimple1.result diff --git a/core/codegen/src/test/resources/complex_expressions/RecModExpVarExp b/core/codegen/javagen/src/test/resources/complex_expressions/RecModExpVarExp similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/RecModExpVarExp rename to core/codegen/javagen/src/test/resources/complex_expressions/RecModExpVarExp diff --git a/core/codegen/src/test/resources/complex_expressions/RecModExpVarExp.result b/core/codegen/javagen/src/test/resources/complex_expressions/RecModExpVarExp.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/RecModExpVarExp.result rename to core/codegen/javagen/src/test/resources/complex_expressions/RecModExpVarExp.result diff --git a/core/codegen/src/test/resources/complex_expressions/RecordComp b/core/codegen/javagen/src/test/resources/complex_expressions/RecordComp similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/RecordComp rename to core/codegen/javagen/src/test/resources/complex_expressions/RecordComp diff --git a/core/codegen/src/test/resources/complex_expressions/RecordComp.result b/core/codegen/javagen/src/test/resources/complex_expressions/RecordComp.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/RecordComp.result rename to core/codegen/javagen/src/test/resources/complex_expressions/RecordComp.result diff --git a/core/codegen/src/test/resources/complex_expressions/RecordUsageAcrossClass b/core/codegen/javagen/src/test/resources/complex_expressions/RecordUsageAcrossClass similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/RecordUsageAcrossClass rename to core/codegen/javagen/src/test/resources/complex_expressions/RecordUsageAcrossClass diff --git a/core/codegen/src/test/resources/complex_expressions/RecordUsageAcrossClass.result b/core/codegen/javagen/src/test/resources/complex_expressions/RecordUsageAcrossClass.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/RecordUsageAcrossClass.result rename to core/codegen/javagen/src/test/resources/complex_expressions/RecordUsageAcrossClass.result diff --git a/core/codegen/src/test/resources/complex_expressions/RecordValue b/core/codegen/javagen/src/test/resources/complex_expressions/RecordValue similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/RecordValue rename to core/codegen/javagen/src/test/resources/complex_expressions/RecordValue diff --git a/core/codegen/src/test/resources/complex_expressions/RecordValue.result b/core/codegen/javagen/src/test/resources/complex_expressions/RecordValue.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/RecordValue.result rename to core/codegen/javagen/src/test/resources/complex_expressions/RecordValue.result diff --git a/core/codegen/src/test/resources/complex_expressions/RecursiveNamedTypeMapApply b/core/codegen/javagen/src/test/resources/complex_expressions/RecursiveNamedTypeMapApply similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/RecursiveNamedTypeMapApply rename to core/codegen/javagen/src/test/resources/complex_expressions/RecursiveNamedTypeMapApply diff --git a/core/codegen/src/test/resources/complex_expressions/RecursiveNamedTypeMapApply.result b/core/codegen/javagen/src/test/resources/complex_expressions/RecursiveNamedTypeMapApply.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/RecursiveNamedTypeMapApply.result rename to core/codegen/javagen/src/test/resources/complex_expressions/RecursiveNamedTypeMapApply.result diff --git a/core/codegen/src/test/resources/complex_expressions/SeqCompBlockStm b/core/codegen/javagen/src/test/resources/complex_expressions/SeqCompBlockStm similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/SeqCompBlockStm rename to core/codegen/javagen/src/test/resources/complex_expressions/SeqCompBlockStm diff --git a/core/codegen/src/test/resources/complex_expressions/SeqCompBlockStm.result b/core/codegen/javagen/src/test/resources/complex_expressions/SeqCompBlockStm.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/SeqCompBlockStm.result rename to core/codegen/javagen/src/test/resources/complex_expressions/SeqCompBlockStm.result diff --git a/core/codegen/src/test/resources/complex_expressions/SeqCompInLet b/core/codegen/javagen/src/test/resources/complex_expressions/SeqCompInLet similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/SeqCompInLet rename to core/codegen/javagen/src/test/resources/complex_expressions/SeqCompInLet diff --git a/core/codegen/src/test/resources/complex_expressions/SeqCompInLet.result b/core/codegen/javagen/src/test/resources/complex_expressions/SeqCompInLet.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/SeqCompInLet.result rename to core/codegen/javagen/src/test/resources/complex_expressions/SeqCompInLet.result diff --git a/core/codegen/src/test/resources/complex_expressions/SeqCompInOpCallInLoop b/core/codegen/javagen/src/test/resources/complex_expressions/SeqCompInOpCallInLoop similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/SeqCompInOpCallInLoop rename to core/codegen/javagen/src/test/resources/complex_expressions/SeqCompInOpCallInLoop diff --git a/core/codegen/src/test/resources/complex_expressions/SeqCompInOpCallInLoop.result b/core/codegen/javagen/src/test/resources/complex_expressions/SeqCompInOpCallInLoop.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/SeqCompInOpCallInLoop.result rename to core/codegen/javagen/src/test/resources/complex_expressions/SeqCompInOpCallInLoop.result diff --git a/core/codegen/src/test/resources/complex_expressions/SeqCompRemoveEmptySet b/core/codegen/javagen/src/test/resources/complex_expressions/SeqCompRemoveEmptySet similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/SeqCompRemoveEmptySet rename to core/codegen/javagen/src/test/resources/complex_expressions/SeqCompRemoveEmptySet diff --git a/core/codegen/src/test/resources/complex_expressions/SeqCompRemoveEmptySet.result b/core/codegen/javagen/src/test/resources/complex_expressions/SeqCompRemoveEmptySet.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/SeqCompRemoveEmptySet.result rename to core/codegen/javagen/src/test/resources/complex_expressions/SeqCompRemoveEmptySet.result diff --git a/core/codegen/src/test/resources/complex_expressions/SeqCompReturned b/core/codegen/javagen/src/test/resources/complex_expressions/SeqCompReturned similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/SeqCompReturned rename to core/codegen/javagen/src/test/resources/complex_expressions/SeqCompReturned diff --git a/core/codegen/src/test/resources/complex_expressions/SeqCompReturned.result b/core/codegen/javagen/src/test/resources/complex_expressions/SeqCompReturned.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/SeqCompReturned.result rename to core/codegen/javagen/src/test/resources/complex_expressions/SeqCompReturned.result diff --git a/core/codegen/src/test/resources/complex_expressions/SeqCompTransformedElement b/core/codegen/javagen/src/test/resources/complex_expressions/SeqCompTransformedElement similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/SeqCompTransformedElement rename to core/codegen/javagen/src/test/resources/complex_expressions/SeqCompTransformedElement diff --git a/core/codegen/src/test/resources/complex_expressions/SeqCompTransformedElement.result b/core/codegen/javagen/src/test/resources/complex_expressions/SeqCompTransformedElement.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/SeqCompTransformedElement.result rename to core/codegen/javagen/src/test/resources/complex_expressions/SeqCompTransformedElement.result diff --git a/core/codegen/src/test/resources/complex_expressions/SeqConversion b/core/codegen/javagen/src/test/resources/complex_expressions/SeqConversion similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/SeqConversion rename to core/codegen/javagen/src/test/resources/complex_expressions/SeqConversion diff --git a/core/codegen/src/test/resources/complex_expressions/SeqConversion.result b/core/codegen/javagen/src/test/resources/complex_expressions/SeqConversion.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/SeqConversion.result rename to core/codegen/javagen/src/test/resources/complex_expressions/SeqConversion.result diff --git a/core/codegen/src/test/resources/complex_expressions/SetCompBlockStm b/core/codegen/javagen/src/test/resources/complex_expressions/SetCompBlockStm similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/SetCompBlockStm rename to core/codegen/javagen/src/test/resources/complex_expressions/SetCompBlockStm diff --git a/core/codegen/src/test/resources/complex_expressions/SetCompBlockStm.result b/core/codegen/javagen/src/test/resources/complex_expressions/SetCompBlockStm.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/SetCompBlockStm.result rename to core/codegen/javagen/src/test/resources/complex_expressions/SetCompBlockStm.result diff --git a/core/codegen/src/test/resources/complex_expressions/SetCompInLet b/core/codegen/javagen/src/test/resources/complex_expressions/SetCompInLet similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/SetCompInLet rename to core/codegen/javagen/src/test/resources/complex_expressions/SetCompInLet diff --git a/core/codegen/src/test/resources/complex_expressions/SetCompInLet.result b/core/codegen/javagen/src/test/resources/complex_expressions/SetCompInLet.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/SetCompInLet.result rename to core/codegen/javagen/src/test/resources/complex_expressions/SetCompInLet.result diff --git a/core/codegen/src/test/resources/complex_expressions/SetCompInOpCallInLoop b/core/codegen/javagen/src/test/resources/complex_expressions/SetCompInOpCallInLoop similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/SetCompInOpCallInLoop rename to core/codegen/javagen/src/test/resources/complex_expressions/SetCompInOpCallInLoop diff --git a/core/codegen/src/test/resources/complex_expressions/SetCompInOpCallInLoop.result b/core/codegen/javagen/src/test/resources/complex_expressions/SetCompInOpCallInLoop.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/SetCompInOpCallInLoop.result rename to core/codegen/javagen/src/test/resources/complex_expressions/SetCompInOpCallInLoop.result diff --git a/core/codegen/src/test/resources/complex_expressions/SetCompRemoveAllMultipleSetBinds b/core/codegen/javagen/src/test/resources/complex_expressions/SetCompRemoveAllMultipleSetBinds similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/SetCompRemoveAllMultipleSetBinds rename to core/codegen/javagen/src/test/resources/complex_expressions/SetCompRemoveAllMultipleSetBinds diff --git a/core/codegen/src/test/resources/complex_expressions/SetCompRemoveAllMultipleSetBinds.result b/core/codegen/javagen/src/test/resources/complex_expressions/SetCompRemoveAllMultipleSetBinds.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/SetCompRemoveAllMultipleSetBinds.result rename to core/codegen/javagen/src/test/resources/complex_expressions/SetCompRemoveAllMultipleSetBinds.result diff --git a/core/codegen/src/test/resources/complex_expressions/SetCompRemoveOneOfTwoMultipleSetBinds b/core/codegen/javagen/src/test/resources/complex_expressions/SetCompRemoveOneOfTwoMultipleSetBinds similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/SetCompRemoveOneOfTwoMultipleSetBinds rename to core/codegen/javagen/src/test/resources/complex_expressions/SetCompRemoveOneOfTwoMultipleSetBinds diff --git a/core/codegen/src/test/resources/complex_expressions/SetCompRemoveOneOfTwoMultipleSetBinds.result b/core/codegen/javagen/src/test/resources/complex_expressions/SetCompRemoveOneOfTwoMultipleSetBinds.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/SetCompRemoveOneOfTwoMultipleSetBinds.result rename to core/codegen/javagen/src/test/resources/complex_expressions/SetCompRemoveOneOfTwoMultipleSetBinds.result diff --git a/core/codegen/src/test/resources/complex_expressions/SetCompReturnThreePatternsCond b/core/codegen/javagen/src/test/resources/complex_expressions/SetCompReturnThreePatternsCond similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/SetCompReturnThreePatternsCond rename to core/codegen/javagen/src/test/resources/complex_expressions/SetCompReturnThreePatternsCond diff --git a/core/codegen/src/test/resources/complex_expressions/SetCompReturnThreePatternsCond.result b/core/codegen/javagen/src/test/resources/complex_expressions/SetCompReturnThreePatternsCond.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/SetCompReturnThreePatternsCond.result rename to core/codegen/javagen/src/test/resources/complex_expressions/SetCompReturnThreePatternsCond.result diff --git a/core/codegen/src/test/resources/complex_expressions/SetCompSeveralMultipleSetBindsCond1 b/core/codegen/javagen/src/test/resources/complex_expressions/SetCompSeveralMultipleSetBindsCond1 similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/SetCompSeveralMultipleSetBindsCond1 rename to core/codegen/javagen/src/test/resources/complex_expressions/SetCompSeveralMultipleSetBindsCond1 diff --git a/core/codegen/src/test/resources/complex_expressions/SetCompSeveralMultipleSetBindsCond1.result b/core/codegen/javagen/src/test/resources/complex_expressions/SetCompSeveralMultipleSetBindsCond1.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/SetCompSeveralMultipleSetBindsCond1.result rename to core/codegen/javagen/src/test/resources/complex_expressions/SetCompSeveralMultipleSetBindsCond1.result diff --git a/core/codegen/src/test/resources/complex_expressions/SetCompSeveralMultipleSetBindsCond2 b/core/codegen/javagen/src/test/resources/complex_expressions/SetCompSeveralMultipleSetBindsCond2 similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/SetCompSeveralMultipleSetBindsCond2 rename to core/codegen/javagen/src/test/resources/complex_expressions/SetCompSeveralMultipleSetBindsCond2 diff --git a/core/codegen/src/test/resources/complex_expressions/SetCompSeveralMultipleSetBindsCond2.result b/core/codegen/javagen/src/test/resources/complex_expressions/SetCompSeveralMultipleSetBindsCond2.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/SetCompSeveralMultipleSetBindsCond2.result rename to core/codegen/javagen/src/test/resources/complex_expressions/SetCompSeveralMultipleSetBindsCond2.result diff --git a/core/codegen/src/test/resources/complex_expressions/SetCompSeveralMultipleSetBindsCond3 b/core/codegen/javagen/src/test/resources/complex_expressions/SetCompSeveralMultipleSetBindsCond3 similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/SetCompSeveralMultipleSetBindsCond3 rename to core/codegen/javagen/src/test/resources/complex_expressions/SetCompSeveralMultipleSetBindsCond3 diff --git a/core/codegen/src/test/resources/complex_expressions/SetCompSeveralMultipleSetBindsCond3.result b/core/codegen/javagen/src/test/resources/complex_expressions/SetCompSeveralMultipleSetBindsCond3.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/SetCompSeveralMultipleSetBindsCond3.result rename to core/codegen/javagen/src/test/resources/complex_expressions/SetCompSeveralMultipleSetBindsCond3.result diff --git a/core/codegen/src/test/resources/complex_expressions/SetCompSeveralMultipleSetBindsNoCond b/core/codegen/javagen/src/test/resources/complex_expressions/SetCompSeveralMultipleSetBindsNoCond similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/SetCompSeveralMultipleSetBindsNoCond rename to core/codegen/javagen/src/test/resources/complex_expressions/SetCompSeveralMultipleSetBindsNoCond diff --git a/core/codegen/src/test/resources/complex_expressions/SetCompSeveralMultipleSetBindsNoCond.result b/core/codegen/javagen/src/test/resources/complex_expressions/SetCompSeveralMultipleSetBindsNoCond.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/SetCompSeveralMultipleSetBindsNoCond.result rename to core/codegen/javagen/src/test/resources/complex_expressions/SetCompSeveralMultipleSetBindsNoCond.result diff --git a/core/codegen/src/test/resources/complex_expressions/SetCompTransformedElement b/core/codegen/javagen/src/test/resources/complex_expressions/SetCompTransformedElement similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/SetCompTransformedElement rename to core/codegen/javagen/src/test/resources/complex_expressions/SetCompTransformedElement diff --git a/core/codegen/src/test/resources/complex_expressions/SetCompTransformedElement.result b/core/codegen/javagen/src/test/resources/complex_expressions/SetCompTransformedElement.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/SetCompTransformedElement.result rename to core/codegen/javagen/src/test/resources/complex_expressions/SetCompTransformedElement.result diff --git a/core/codegen/src/test/resources/complex_expressions/SuperConstructors b/core/codegen/javagen/src/test/resources/complex_expressions/SuperConstructors similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/SuperConstructors rename to core/codegen/javagen/src/test/resources/complex_expressions/SuperConstructors diff --git a/core/codegen/src/test/resources/complex_expressions/SuperConstructors.result b/core/codegen/javagen/src/test/resources/complex_expressions/SuperConstructors.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/SuperConstructors.result rename to core/codegen/javagen/src/test/resources/complex_expressions/SuperConstructors.result diff --git a/core/codegen/src/test/resources/complex_expressions/SuperOpCallOfOverwrittenOp b/core/codegen/javagen/src/test/resources/complex_expressions/SuperOpCallOfOverwrittenOp similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/SuperOpCallOfOverwrittenOp rename to core/codegen/javagen/src/test/resources/complex_expressions/SuperOpCallOfOverwrittenOp diff --git a/core/codegen/src/test/resources/complex_expressions/SuperOpCallOfOverwrittenOp.result b/core/codegen/javagen/src/test/resources/complex_expressions/SuperOpCallOfOverwrittenOp.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/SuperOpCallOfOverwrittenOp.result rename to core/codegen/javagen/src/test/resources/complex_expressions/SuperOpCallOfOverwrittenOp.result diff --git a/core/codegen/src/test/resources/complex_expressions/TokenType b/core/codegen/javagen/src/test/resources/complex_expressions/TokenType similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/TokenType rename to core/codegen/javagen/src/test/resources/complex_expressions/TokenType diff --git a/core/codegen/src/test/resources/complex_expressions/TokenType.result b/core/codegen/javagen/src/test/resources/complex_expressions/TokenType.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/TokenType.result rename to core/codegen/javagen/src/test/resources/complex_expressions/TokenType.result diff --git a/core/codegen/src/test/resources/complex_expressions/UnaryMinusExpArgToFunc b/core/codegen/javagen/src/test/resources/complex_expressions/UnaryMinusExpArgToFunc similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/UnaryMinusExpArgToFunc rename to core/codegen/javagen/src/test/resources/complex_expressions/UnaryMinusExpArgToFunc diff --git a/core/codegen/src/test/resources/complex_expressions/UnaryMinusExpArgToFunc.result b/core/codegen/javagen/src/test/resources/complex_expressions/UnaryMinusExpArgToFunc.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/UnaryMinusExpArgToFunc.result rename to core/codegen/javagen/src/test/resources/complex_expressions/UnaryMinusExpArgToFunc.result diff --git a/core/codegen/src/test/resources/complex_expressions/UnaryPlusExpArgToFunc b/core/codegen/javagen/src/test/resources/complex_expressions/UnaryPlusExpArgToFunc similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/UnaryPlusExpArgToFunc rename to core/codegen/javagen/src/test/resources/complex_expressions/UnaryPlusExpArgToFunc diff --git a/core/codegen/src/test/resources/complex_expressions/UnaryPlusExpArgToFunc.result b/core/codegen/javagen/src/test/resources/complex_expressions/UnaryPlusExpArgToFunc.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/UnaryPlusExpArgToFunc.result rename to core/codegen/javagen/src/test/resources/complex_expressions/UnaryPlusExpArgToFunc.result diff --git a/core/codegen/src/test/resources/complex_expressions/WhileStmForAllExpCond b/core/codegen/javagen/src/test/resources/complex_expressions/WhileStmForAllExpCond similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/WhileStmForAllExpCond rename to core/codegen/javagen/src/test/resources/complex_expressions/WhileStmForAllExpCond diff --git a/core/codegen/src/test/resources/complex_expressions/WhileStmForAllExpCond.result b/core/codegen/javagen/src/test/resources/complex_expressions/WhileStmForAllExpCond.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/WhileStmForAllExpCond.result rename to core/codegen/javagen/src/test/resources/complex_expressions/WhileStmForAllExpCond.result diff --git a/core/codegen/src/test/resources/complex_expressions/WhileStmSetSum b/core/codegen/javagen/src/test/resources/complex_expressions/WhileStmSetSum similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/WhileStmSetSum rename to core/codegen/javagen/src/test/resources/complex_expressions/WhileStmSetSum diff --git a/core/codegen/src/test/resources/complex_expressions/WhileStmSetSum.result b/core/codegen/javagen/src/test/resources/complex_expressions/WhileStmSetSum.result similarity index 100% rename from core/codegen/src/test/resources/complex_expressions/WhileStmSetSum.result rename to core/codegen/javagen/src/test/resources/complex_expressions/WhileStmSetSum.result diff --git a/core/codegen/src/test/resources/concurrency/DoubleOperationMutexSharedCounter b/core/codegen/javagen/src/test/resources/concurrency/DoubleOperationMutexSharedCounter similarity index 100% rename from core/codegen/src/test/resources/concurrency/DoubleOperationMutexSharedCounter rename to core/codegen/javagen/src/test/resources/concurrency/DoubleOperationMutexSharedCounter diff --git a/core/codegen/src/test/resources/concurrency/DoubleOperationMutexSharedCounter.result b/core/codegen/javagen/src/test/resources/concurrency/DoubleOperationMutexSharedCounter.result similarity index 100% rename from core/codegen/src/test/resources/concurrency/DoubleOperationMutexSharedCounter.result rename to core/codegen/javagen/src/test/resources/concurrency/DoubleOperationMutexSharedCounter.result diff --git a/core/codegen/src/test/resources/concurrency/DoublePermissionPredSharedCounter b/core/codegen/javagen/src/test/resources/concurrency/DoublePermissionPredSharedCounter similarity index 100% rename from core/codegen/src/test/resources/concurrency/DoublePermissionPredSharedCounter rename to core/codegen/javagen/src/test/resources/concurrency/DoublePermissionPredSharedCounter diff --git a/core/codegen/src/test/resources/concurrency/DoublePermissionPredSharedCounter.result b/core/codegen/javagen/src/test/resources/concurrency/DoublePermissionPredSharedCounter.result similarity index 100% rename from core/codegen/src/test/resources/concurrency/DoublePermissionPredSharedCounter.result rename to core/codegen/javagen/src/test/resources/concurrency/DoublePermissionPredSharedCounter.result diff --git a/core/codegen/src/test/resources/concurrency/FourOperationMutexSharedcounter b/core/codegen/javagen/src/test/resources/concurrency/FourOperationMutexSharedcounter similarity index 100% rename from core/codegen/src/test/resources/concurrency/FourOperationMutexSharedcounter rename to core/codegen/javagen/src/test/resources/concurrency/FourOperationMutexSharedcounter diff --git a/core/codegen/src/test/resources/concurrency/FourOperationMutexSharedcounter.result b/core/codegen/javagen/src/test/resources/concurrency/FourOperationMutexSharedcounter.result similarity index 100% rename from core/codegen/src/test/resources/concurrency/FourOperationMutexSharedcounter.result rename to core/codegen/javagen/src/test/resources/concurrency/FourOperationMutexSharedcounter.result diff --git a/core/codegen/src/test/resources/concurrency/HistoryCounterActSharedResource b/core/codegen/javagen/src/test/resources/concurrency/HistoryCounterActSharedResource similarity index 100% rename from core/codegen/src/test/resources/concurrency/HistoryCounterActSharedResource rename to core/codegen/javagen/src/test/resources/concurrency/HistoryCounterActSharedResource diff --git a/core/codegen/src/test/resources/concurrency/HistoryCounterActSharedResource.result b/core/codegen/javagen/src/test/resources/concurrency/HistoryCounterActSharedResource.result similarity index 100% rename from core/codegen/src/test/resources/concurrency/HistoryCounterActSharedResource.result rename to core/codegen/javagen/src/test/resources/concurrency/HistoryCounterActSharedResource.result diff --git a/core/codegen/src/test/resources/concurrency/HistoryCounterActiveSharedCounter b/core/codegen/javagen/src/test/resources/concurrency/HistoryCounterActiveSharedCounter similarity index 100% rename from core/codegen/src/test/resources/concurrency/HistoryCounterActiveSharedCounter rename to core/codegen/javagen/src/test/resources/concurrency/HistoryCounterActiveSharedCounter diff --git a/core/codegen/src/test/resources/concurrency/HistoryCounterActiveSharedCounter.result b/core/codegen/javagen/src/test/resources/concurrency/HistoryCounterActiveSharedCounter.result similarity index 100% rename from core/codegen/src/test/resources/concurrency/HistoryCounterActiveSharedCounter.result rename to core/codegen/javagen/src/test/resources/concurrency/HistoryCounterActiveSharedCounter.result diff --git a/core/codegen/src/test/resources/concurrency/HistoryCounterFinSharedResource b/core/codegen/javagen/src/test/resources/concurrency/HistoryCounterFinSharedResource similarity index 100% rename from core/codegen/src/test/resources/concurrency/HistoryCounterFinSharedResource rename to core/codegen/javagen/src/test/resources/concurrency/HistoryCounterFinSharedResource diff --git a/core/codegen/src/test/resources/concurrency/HistoryCounterFinSharedResource.result b/core/codegen/javagen/src/test/resources/concurrency/HistoryCounterFinSharedResource.result similarity index 100% rename from core/codegen/src/test/resources/concurrency/HistoryCounterFinSharedResource.result rename to core/codegen/javagen/src/test/resources/concurrency/HistoryCounterFinSharedResource.result diff --git a/core/codegen/src/test/resources/concurrency/HistoryCounterReqSharedResource b/core/codegen/javagen/src/test/resources/concurrency/HistoryCounterReqSharedResource similarity index 100% rename from core/codegen/src/test/resources/concurrency/HistoryCounterReqSharedResource rename to core/codegen/javagen/src/test/resources/concurrency/HistoryCounterReqSharedResource diff --git a/core/codegen/src/test/resources/concurrency/HistoryCounterReqSharedResource.result b/core/codegen/javagen/src/test/resources/concurrency/HistoryCounterReqSharedResource.result similarity index 100% rename from core/codegen/src/test/resources/concurrency/HistoryCounterReqSharedResource.result rename to core/codegen/javagen/src/test/resources/concurrency/HistoryCounterReqSharedResource.result diff --git a/core/codegen/src/test/resources/concurrency/HistoryCounterWaitingSharedCounter b/core/codegen/javagen/src/test/resources/concurrency/HistoryCounterWaitingSharedCounter similarity index 100% rename from core/codegen/src/test/resources/concurrency/HistoryCounterWaitingSharedCounter rename to core/codegen/javagen/src/test/resources/concurrency/HistoryCounterWaitingSharedCounter diff --git a/core/codegen/src/test/resources/concurrency/HistoryCounterWaitingSharedCounter.result b/core/codegen/javagen/src/test/resources/concurrency/HistoryCounterWaitingSharedCounter.result similarity index 100% rename from core/codegen/src/test/resources/concurrency/HistoryCounterWaitingSharedCounter.result rename to core/codegen/javagen/src/test/resources/concurrency/HistoryCounterWaitingSharedCounter.result diff --git a/core/codegen/src/test/resources/concurrency/HistoryCounterandMutexSharedResource b/core/codegen/javagen/src/test/resources/concurrency/HistoryCounterandMutexSharedResource similarity index 100% rename from core/codegen/src/test/resources/concurrency/HistoryCounterandMutexSharedResource rename to core/codegen/javagen/src/test/resources/concurrency/HistoryCounterandMutexSharedResource diff --git a/core/codegen/src/test/resources/concurrency/HistoryCounterandMutexSharedResource.result b/core/codegen/javagen/src/test/resources/concurrency/HistoryCounterandMutexSharedResource.result similarity index 100% rename from core/codegen/src/test/resources/concurrency/HistoryCounterandMutexSharedResource.result rename to core/codegen/javagen/src/test/resources/concurrency/HistoryCounterandMutexSharedResource.result diff --git a/core/codegen/src/test/resources/concurrency/MutexAllSharedCounter b/core/codegen/javagen/src/test/resources/concurrency/MutexAllSharedCounter similarity index 100% rename from core/codegen/src/test/resources/concurrency/MutexAllSharedCounter rename to core/codegen/javagen/src/test/resources/concurrency/MutexAllSharedCounter diff --git a/core/codegen/src/test/resources/concurrency/MutexAllSharedCounter.result b/core/codegen/javagen/src/test/resources/concurrency/MutexAllSharedCounter.result similarity index 100% rename from core/codegen/src/test/resources/concurrency/MutexAllSharedCounter.result rename to core/codegen/javagen/src/test/resources/concurrency/MutexAllSharedCounter.result diff --git a/core/codegen/src/test/resources/concurrency/OverloadedOperation b/core/codegen/javagen/src/test/resources/concurrency/OverloadedOperation similarity index 100% rename from core/codegen/src/test/resources/concurrency/OverloadedOperation rename to core/codegen/javagen/src/test/resources/concurrency/OverloadedOperation diff --git a/core/codegen/src/test/resources/concurrency/OverloadedOperation.result b/core/codegen/javagen/src/test/resources/concurrency/OverloadedOperation.result similarity index 100% rename from core/codegen/src/test/resources/concurrency/OverloadedOperation.result rename to core/codegen/javagen/src/test/resources/concurrency/OverloadedOperation.result diff --git a/core/codegen/src/test/resources/concurrency/ReaderWriterExample b/core/codegen/javagen/src/test/resources/concurrency/ReaderWriterExample similarity index 100% rename from core/codegen/src/test/resources/concurrency/ReaderWriterExample rename to core/codegen/javagen/src/test/resources/concurrency/ReaderWriterExample diff --git a/core/codegen/src/test/resources/concurrency/ReaderWriterExample.result b/core/codegen/javagen/src/test/resources/concurrency/ReaderWriterExample.result similarity index 100% rename from core/codegen/src/test/resources/concurrency/ReaderWriterExample.result rename to core/codegen/javagen/src/test/resources/concurrency/ReaderWriterExample.result diff --git a/core/codegen/src/test/resources/concurrency/SingleLevelInheritance b/core/codegen/javagen/src/test/resources/concurrency/SingleLevelInheritance similarity index 100% rename from core/codegen/src/test/resources/concurrency/SingleLevelInheritance rename to core/codegen/javagen/src/test/resources/concurrency/SingleLevelInheritance diff --git a/core/codegen/src/test/resources/concurrency/SingleLevelInheritance.result b/core/codegen/javagen/src/test/resources/concurrency/SingleLevelInheritance.result similarity index 100% rename from core/codegen/src/test/resources/concurrency/SingleLevelInheritance.result rename to core/codegen/javagen/src/test/resources/concurrency/SingleLevelInheritance.result diff --git a/core/codegen/src/test/resources/concurrency/SingleOperationMutexSharedCounter b/core/codegen/javagen/src/test/resources/concurrency/SingleOperationMutexSharedCounter similarity index 100% rename from core/codegen/src/test/resources/concurrency/SingleOperationMutexSharedCounter rename to core/codegen/javagen/src/test/resources/concurrency/SingleOperationMutexSharedCounter diff --git a/core/codegen/src/test/resources/concurrency/SingleOperationMutexSharedCounter.result b/core/codegen/javagen/src/test/resources/concurrency/SingleOperationMutexSharedCounter.result similarity index 100% rename from core/codegen/src/test/resources/concurrency/SingleOperationMutexSharedCounter.result rename to core/codegen/javagen/src/test/resources/concurrency/SingleOperationMutexSharedCounter.result diff --git a/core/codegen/src/test/resources/concurrency/StartlistdefinitionMutexSynchronized b/core/codegen/javagen/src/test/resources/concurrency/StartlistdefinitionMutexSynchronized similarity index 100% rename from core/codegen/src/test/resources/concurrency/StartlistdefinitionMutexSynchronized rename to core/codegen/javagen/src/test/resources/concurrency/StartlistdefinitionMutexSynchronized diff --git a/core/codegen/src/test/resources/concurrency/StartlistdefinitionMutexSynchronized.result b/core/codegen/javagen/src/test/resources/concurrency/StartlistdefinitionMutexSynchronized.result similarity index 100% rename from core/codegen/src/test/resources/concurrency/StartlistdefinitionMutexSynchronized.result rename to core/codegen/javagen/src/test/resources/concurrency/StartlistdefinitionMutexSynchronized.result diff --git a/core/codegen/src/test/resources/concurrency/ThreadIdSingleThread b/core/codegen/javagen/src/test/resources/concurrency/ThreadIdSingleThread similarity index 91% rename from core/codegen/src/test/resources/concurrency/ThreadIdSingleThread rename to core/codegen/javagen/src/test/resources/concurrency/ThreadIdSingleThread index f0ff1bc64d..3208752549 100644 --- a/core/codegen/src/test/resources/concurrency/ThreadIdSingleThread +++ b/core/codegen/javagen/src/test/resources/concurrency/ThreadIdSingleThread @@ -1,14 +1,14 @@ -class Entry - -functions - -public f : () -> nat -f () == threadid; - -operations - -public static Run : () ==> ? -Run () == - return is_nat(f()); - +class Entry + +functions + +public f : () -> nat +f () == threadid; + +operations + +public static Run : () ==> ? +Run () == + return is_nat(f()); + end Entry \ No newline at end of file diff --git a/core/codegen/src/test/resources/concurrency/ThreadIdSingleThread.result b/core/codegen/javagen/src/test/resources/concurrency/ThreadIdSingleThread.result similarity index 100% rename from core/codegen/src/test/resources/concurrency/ThreadIdSingleThread.result rename to core/codegen/javagen/src/test/resources/concurrency/ThreadIdSingleThread.result diff --git a/core/codegen/src/test/resources/concurrency/ThreadStart b/core/codegen/javagen/src/test/resources/concurrency/ThreadStart similarity index 100% rename from core/codegen/src/test/resources/concurrency/ThreadStart rename to core/codegen/javagen/src/test/resources/concurrency/ThreadStart diff --git a/core/codegen/src/test/resources/concurrency/ThreadStart.result b/core/codegen/javagen/src/test/resources/concurrency/ThreadStart.result similarity index 100% rename from core/codegen/src/test/resources/concurrency/ThreadStart.result rename to core/codegen/javagen/src/test/resources/concurrency/ThreadStart.result diff --git a/core/codegen/src/test/resources/concurrency_classics_specs/POP3_LogBased_Test1 b/core/codegen/javagen/src/test/resources/concurrency_classics_specs/POP3_LogBased_Test1 similarity index 100% rename from core/codegen/src/test/resources/concurrency_classics_specs/POP3_LogBased_Test1 rename to core/codegen/javagen/src/test/resources/concurrency_classics_specs/POP3_LogBased_Test1 diff --git a/core/codegen/src/test/resources/concurrency_classics_specs/POP3_LogBased_Test1.result b/core/codegen/javagen/src/test/resources/concurrency_classics_specs/POP3_LogBased_Test1.result similarity index 100% rename from core/codegen/src/test/resources/concurrency_classics_specs/POP3_LogBased_Test1.result rename to core/codegen/javagen/src/test/resources/concurrency_classics_specs/POP3_LogBased_Test1.result diff --git a/core/codegen/src/test/resources/expressions/AbsInTuple b/core/codegen/javagen/src/test/resources/expressions/AbsInTuple similarity index 100% rename from core/codegen/src/test/resources/expressions/AbsInTuple rename to core/codegen/javagen/src/test/resources/expressions/AbsInTuple diff --git a/core/codegen/src/test/resources/expressions/AbsInTuple.result b/core/codegen/javagen/src/test/resources/expressions/AbsInTuple.result similarity index 100% rename from core/codegen/src/test/resources/expressions/AbsInTuple.result rename to core/codegen/javagen/src/test/resources/expressions/AbsInTuple.result diff --git a/core/codegen/src/test/resources/expressions/AbsOperator b/core/codegen/javagen/src/test/resources/expressions/AbsOperator similarity index 100% rename from core/codegen/src/test/resources/expressions/AbsOperator rename to core/codegen/javagen/src/test/resources/expressions/AbsOperator diff --git a/core/codegen/src/test/resources/expressions/AbsOperator.result b/core/codegen/javagen/src/test/resources/expressions/AbsOperator.result similarity index 100% rename from core/codegen/src/test/resources/expressions/AbsOperator.result rename to core/codegen/javagen/src/test/resources/expressions/AbsOperator.result diff --git a/core/codegen/src/test/resources/expressions/AndOfEquivalence b/core/codegen/javagen/src/test/resources/expressions/AndOfEquivalence similarity index 100% rename from core/codegen/src/test/resources/expressions/AndOfEquivalence rename to core/codegen/javagen/src/test/resources/expressions/AndOfEquivalence diff --git a/core/codegen/src/test/resources/expressions/AndOfEquivalence.result b/core/codegen/javagen/src/test/resources/expressions/AndOfEquivalence.result similarity index 100% rename from core/codegen/src/test/resources/expressions/AndOfEquivalence.result rename to core/codegen/javagen/src/test/resources/expressions/AndOfEquivalence.result diff --git a/core/codegen/src/test/resources/expressions/AndOperator b/core/codegen/javagen/src/test/resources/expressions/AndOperator similarity index 100% rename from core/codegen/src/test/resources/expressions/AndOperator rename to core/codegen/javagen/src/test/resources/expressions/AndOperator diff --git a/core/codegen/src/test/resources/expressions/AndOperator.result b/core/codegen/javagen/src/test/resources/expressions/AndOperator.result similarity index 100% rename from core/codegen/src/test/resources/expressions/AndOperator.result rename to core/codegen/javagen/src/test/resources/expressions/AndOperator.result diff --git a/core/codegen/src/test/resources/expressions/ApplyExpSeqEnum b/core/codegen/javagen/src/test/resources/expressions/ApplyExpSeqEnum similarity index 100% rename from core/codegen/src/test/resources/expressions/ApplyExpSeqEnum rename to core/codegen/javagen/src/test/resources/expressions/ApplyExpSeqEnum diff --git a/core/codegen/src/test/resources/expressions/ApplyExpSeqEnum.result b/core/codegen/javagen/src/test/resources/expressions/ApplyExpSeqEnum.result similarity index 100% rename from core/codegen/src/test/resources/expressions/ApplyExpSeqEnum.result rename to core/codegen/javagen/src/test/resources/expressions/ApplyExpSeqEnum.result diff --git a/core/codegen/src/test/resources/expressions/ApplyExpString b/core/codegen/javagen/src/test/resources/expressions/ApplyExpString similarity index 100% rename from core/codegen/src/test/resources/expressions/ApplyExpString rename to core/codegen/javagen/src/test/resources/expressions/ApplyExpString diff --git a/core/codegen/src/test/resources/expressions/ApplyExpString.result b/core/codegen/javagen/src/test/resources/expressions/ApplyExpString.result similarity index 100% rename from core/codegen/src/test/resources/expressions/ApplyExpString.result rename to core/codegen/javagen/src/test/resources/expressions/ApplyExpString.result diff --git a/core/codegen/src/test/resources/expressions/BoolLiteralFalse b/core/codegen/javagen/src/test/resources/expressions/BoolLiteralFalse similarity index 100% rename from core/codegen/src/test/resources/expressions/BoolLiteralFalse rename to core/codegen/javagen/src/test/resources/expressions/BoolLiteralFalse diff --git a/core/codegen/src/test/resources/expressions/BoolLiteralFalse.result b/core/codegen/javagen/src/test/resources/expressions/BoolLiteralFalse.result similarity index 100% rename from core/codegen/src/test/resources/expressions/BoolLiteralFalse.result rename to core/codegen/javagen/src/test/resources/expressions/BoolLiteralFalse.result diff --git a/core/codegen/src/test/resources/expressions/BoolLiteralTrue b/core/codegen/javagen/src/test/resources/expressions/BoolLiteralTrue similarity index 100% rename from core/codegen/src/test/resources/expressions/BoolLiteralTrue rename to core/codegen/javagen/src/test/resources/expressions/BoolLiteralTrue diff --git a/core/codegen/src/test/resources/expressions/BoolLiteralTrue.result b/core/codegen/javagen/src/test/resources/expressions/BoolLiteralTrue.result similarity index 100% rename from core/codegen/src/test/resources/expressions/BoolLiteralTrue.result rename to core/codegen/javagen/src/test/resources/expressions/BoolLiteralTrue.result diff --git a/core/codegen/src/test/resources/expressions/CharLitNewLine b/core/codegen/javagen/src/test/resources/expressions/CharLitNewLine similarity index 100% rename from core/codegen/src/test/resources/expressions/CharLitNewLine rename to core/codegen/javagen/src/test/resources/expressions/CharLitNewLine diff --git a/core/codegen/src/test/resources/expressions/CharLitNewLine.result b/core/codegen/javagen/src/test/resources/expressions/CharLitNewLine.result similarity index 100% rename from core/codegen/src/test/resources/expressions/CharLitNewLine.result rename to core/codegen/javagen/src/test/resources/expressions/CharLitNewLine.result diff --git a/core/codegen/src/test/resources/expressions/CharLitSingleQuote b/core/codegen/javagen/src/test/resources/expressions/CharLitSingleQuote similarity index 100% rename from core/codegen/src/test/resources/expressions/CharLitSingleQuote rename to core/codegen/javagen/src/test/resources/expressions/CharLitSingleQuote diff --git a/core/codegen/src/test/resources/expressions/CharLitSingleQuote.result b/core/codegen/javagen/src/test/resources/expressions/CharLitSingleQuote.result similarity index 100% rename from core/codegen/src/test/resources/expressions/CharLitSingleQuote.result rename to core/codegen/javagen/src/test/resources/expressions/CharLitSingleQuote.result diff --git a/core/codegen/src/test/resources/expressions/DivOperator b/core/codegen/javagen/src/test/resources/expressions/DivOperator similarity index 100% rename from core/codegen/src/test/resources/expressions/DivOperator rename to core/codegen/javagen/src/test/resources/expressions/DivOperator diff --git a/core/codegen/src/test/resources/expressions/DivOperator.result b/core/codegen/javagen/src/test/resources/expressions/DivOperator.result similarity index 100% rename from core/codegen/src/test/resources/expressions/DivOperator.result rename to core/codegen/javagen/src/test/resources/expressions/DivOperator.result diff --git a/core/codegen/src/test/resources/expressions/ElemsSeqOfSeqOfNat1 b/core/codegen/javagen/src/test/resources/expressions/ElemsSeqOfSeqOfNat1 similarity index 100% rename from core/codegen/src/test/resources/expressions/ElemsSeqOfSeqOfNat1 rename to core/codegen/javagen/src/test/resources/expressions/ElemsSeqOfSeqOfNat1 diff --git a/core/codegen/src/test/resources/expressions/ElemsSeqOfSeqOfNat1.result b/core/codegen/javagen/src/test/resources/expressions/ElemsSeqOfSeqOfNat1.result similarity index 100% rename from core/codegen/src/test/resources/expressions/ElemsSeqOfSeqOfNat1.result rename to core/codegen/javagen/src/test/resources/expressions/ElemsSeqOfSeqOfNat1.result diff --git a/core/codegen/src/test/resources/expressions/ElemsSeqofNat1 b/core/codegen/javagen/src/test/resources/expressions/ElemsSeqofNat1 similarity index 100% rename from core/codegen/src/test/resources/expressions/ElemsSeqofNat1 rename to core/codegen/javagen/src/test/resources/expressions/ElemsSeqofNat1 diff --git a/core/codegen/src/test/resources/expressions/ElemsSeqofNat1.result b/core/codegen/javagen/src/test/resources/expressions/ElemsSeqofNat1.result similarity index 100% rename from core/codegen/src/test/resources/expressions/ElemsSeqofNat1.result rename to core/codegen/javagen/src/test/resources/expressions/ElemsSeqofNat1.result diff --git a/core/codegen/src/test/resources/expressions/EqualsNumeric b/core/codegen/javagen/src/test/resources/expressions/EqualsNumeric similarity index 100% rename from core/codegen/src/test/resources/expressions/EqualsNumeric rename to core/codegen/javagen/src/test/resources/expressions/EqualsNumeric diff --git a/core/codegen/src/test/resources/expressions/EqualsNumeric.result b/core/codegen/javagen/src/test/resources/expressions/EqualsNumeric.result similarity index 100% rename from core/codegen/src/test/resources/expressions/EqualsNumeric.result rename to core/codegen/javagen/src/test/resources/expressions/EqualsNumeric.result diff --git a/core/codegen/src/test/resources/expressions/EquivalenceOperator b/core/codegen/javagen/src/test/resources/expressions/EquivalenceOperator similarity index 100% rename from core/codegen/src/test/resources/expressions/EquivalenceOperator rename to core/codegen/javagen/src/test/resources/expressions/EquivalenceOperator diff --git a/core/codegen/src/test/resources/expressions/EquivalenceOperator.result b/core/codegen/javagen/src/test/resources/expressions/EquivalenceOperator.result similarity index 100% rename from core/codegen/src/test/resources/expressions/EquivalenceOperator.result rename to core/codegen/javagen/src/test/resources/expressions/EquivalenceOperator.result diff --git a/core/codegen/src/test/resources/expressions/FieldNumberExp b/core/codegen/javagen/src/test/resources/expressions/FieldNumberExp similarity index 100% rename from core/codegen/src/test/resources/expressions/FieldNumberExp rename to core/codegen/javagen/src/test/resources/expressions/FieldNumberExp diff --git a/core/codegen/src/test/resources/expressions/FieldNumberExp.result b/core/codegen/javagen/src/test/resources/expressions/FieldNumberExp.result similarity index 100% rename from core/codegen/src/test/resources/expressions/FieldNumberExp.result rename to core/codegen/javagen/src/test/resources/expressions/FieldNumberExp.result diff --git a/core/codegen/src/test/resources/expressions/FloorExpression b/core/codegen/javagen/src/test/resources/expressions/FloorExpression similarity index 100% rename from core/codegen/src/test/resources/expressions/FloorExpression rename to core/codegen/javagen/src/test/resources/expressions/FloorExpression diff --git a/core/codegen/src/test/resources/expressions/FloorExpression.result b/core/codegen/javagen/src/test/resources/expressions/FloorExpression.result similarity index 100% rename from core/codegen/src/test/resources/expressions/FloorExpression.result rename to core/codegen/javagen/src/test/resources/expressions/FloorExpression.result diff --git a/core/codegen/src/test/resources/expressions/ImplicationOperator b/core/codegen/javagen/src/test/resources/expressions/ImplicationOperator similarity index 100% rename from core/codegen/src/test/resources/expressions/ImplicationOperator rename to core/codegen/javagen/src/test/resources/expressions/ImplicationOperator diff --git a/core/codegen/src/test/resources/expressions/ImplicationOperator.result b/core/codegen/javagen/src/test/resources/expressions/ImplicationOperator.result similarity index 100% rename from core/codegen/src/test/resources/expressions/ImplicationOperator.result rename to core/codegen/javagen/src/test/resources/expressions/ImplicationOperator.result diff --git a/core/codegen/src/test/resources/expressions/InverseOfProduct b/core/codegen/javagen/src/test/resources/expressions/InverseOfProduct similarity index 100% rename from core/codegen/src/test/resources/expressions/InverseOfProduct rename to core/codegen/javagen/src/test/resources/expressions/InverseOfProduct diff --git a/core/codegen/src/test/resources/expressions/InverseOfProduct.result b/core/codegen/javagen/src/test/resources/expressions/InverseOfProduct.result similarity index 100% rename from core/codegen/src/test/resources/expressions/InverseOfProduct.result rename to core/codegen/javagen/src/test/resources/expressions/InverseOfProduct.result diff --git a/core/codegen/src/test/resources/expressions/InverseOfSum b/core/codegen/javagen/src/test/resources/expressions/InverseOfSum similarity index 100% rename from core/codegen/src/test/resources/expressions/InverseOfSum rename to core/codegen/javagen/src/test/resources/expressions/InverseOfSum diff --git a/core/codegen/src/test/resources/expressions/InverseOfSum.result b/core/codegen/javagen/src/test/resources/expressions/InverseOfSum.result similarity index 100% rename from core/codegen/src/test/resources/expressions/InverseOfSum.result rename to core/codegen/javagen/src/test/resources/expressions/InverseOfSum.result diff --git a/core/codegen/src/test/resources/expressions/IsExpBoolFalse b/core/codegen/javagen/src/test/resources/expressions/IsExpBoolFalse similarity index 100% rename from core/codegen/src/test/resources/expressions/IsExpBoolFalse rename to core/codegen/javagen/src/test/resources/expressions/IsExpBoolFalse diff --git a/core/codegen/src/test/resources/expressions/IsExpBoolFalse.result b/core/codegen/javagen/src/test/resources/expressions/IsExpBoolFalse.result similarity index 100% rename from core/codegen/src/test/resources/expressions/IsExpBoolFalse.result rename to core/codegen/javagen/src/test/resources/expressions/IsExpBoolFalse.result diff --git a/core/codegen/src/test/resources/expressions/IsExpBoolTrue b/core/codegen/javagen/src/test/resources/expressions/IsExpBoolTrue similarity index 100% rename from core/codegen/src/test/resources/expressions/IsExpBoolTrue rename to core/codegen/javagen/src/test/resources/expressions/IsExpBoolTrue diff --git a/core/codegen/src/test/resources/expressions/IsExpBoolTrue.result b/core/codegen/javagen/src/test/resources/expressions/IsExpBoolTrue.result similarity index 100% rename from core/codegen/src/test/resources/expressions/IsExpBoolTrue.result rename to core/codegen/javagen/src/test/resources/expressions/IsExpBoolTrue.result diff --git a/core/codegen/src/test/resources/expressions/IsExpCharFalse b/core/codegen/javagen/src/test/resources/expressions/IsExpCharFalse similarity index 100% rename from core/codegen/src/test/resources/expressions/IsExpCharFalse rename to core/codegen/javagen/src/test/resources/expressions/IsExpCharFalse diff --git a/core/codegen/src/test/resources/expressions/IsExpCharFalse.result b/core/codegen/javagen/src/test/resources/expressions/IsExpCharFalse.result similarity index 100% rename from core/codegen/src/test/resources/expressions/IsExpCharFalse.result rename to core/codegen/javagen/src/test/resources/expressions/IsExpCharFalse.result diff --git a/core/codegen/src/test/resources/expressions/IsExpCharTrue b/core/codegen/javagen/src/test/resources/expressions/IsExpCharTrue similarity index 100% rename from core/codegen/src/test/resources/expressions/IsExpCharTrue rename to core/codegen/javagen/src/test/resources/expressions/IsExpCharTrue diff --git a/core/codegen/src/test/resources/expressions/IsExpCharTrue.result b/core/codegen/javagen/src/test/resources/expressions/IsExpCharTrue.result similarity index 100% rename from core/codegen/src/test/resources/expressions/IsExpCharTrue.result rename to core/codegen/javagen/src/test/resources/expressions/IsExpCharTrue.result diff --git a/core/codegen/src/test/resources/expressions/IsExpIntFalse b/core/codegen/javagen/src/test/resources/expressions/IsExpIntFalse similarity index 100% rename from core/codegen/src/test/resources/expressions/IsExpIntFalse rename to core/codegen/javagen/src/test/resources/expressions/IsExpIntFalse diff --git a/core/codegen/src/test/resources/expressions/IsExpIntFalse.result b/core/codegen/javagen/src/test/resources/expressions/IsExpIntFalse.result similarity index 100% rename from core/codegen/src/test/resources/expressions/IsExpIntFalse.result rename to core/codegen/javagen/src/test/resources/expressions/IsExpIntFalse.result diff --git a/core/codegen/src/test/resources/expressions/IsExpIntTrue b/core/codegen/javagen/src/test/resources/expressions/IsExpIntTrue similarity index 100% rename from core/codegen/src/test/resources/expressions/IsExpIntTrue rename to core/codegen/javagen/src/test/resources/expressions/IsExpIntTrue diff --git a/core/codegen/src/test/resources/expressions/IsExpIntTrue.result b/core/codegen/javagen/src/test/resources/expressions/IsExpIntTrue.result similarity index 100% rename from core/codegen/src/test/resources/expressions/IsExpIntTrue.result rename to core/codegen/javagen/src/test/resources/expressions/IsExpIntTrue.result diff --git a/core/codegen/src/test/resources/expressions/IsExpNat1False b/core/codegen/javagen/src/test/resources/expressions/IsExpNat1False similarity index 100% rename from core/codegen/src/test/resources/expressions/IsExpNat1False rename to core/codegen/javagen/src/test/resources/expressions/IsExpNat1False diff --git a/core/codegen/src/test/resources/expressions/IsExpNat1False.result b/core/codegen/javagen/src/test/resources/expressions/IsExpNat1False.result similarity index 100% rename from core/codegen/src/test/resources/expressions/IsExpNat1False.result rename to core/codegen/javagen/src/test/resources/expressions/IsExpNat1False.result diff --git a/core/codegen/src/test/resources/expressions/IsExpNat1True b/core/codegen/javagen/src/test/resources/expressions/IsExpNat1True similarity index 100% rename from core/codegen/src/test/resources/expressions/IsExpNat1True rename to core/codegen/javagen/src/test/resources/expressions/IsExpNat1True diff --git a/core/codegen/src/test/resources/expressions/IsExpNat1True.result b/core/codegen/javagen/src/test/resources/expressions/IsExpNat1True.result similarity index 100% rename from core/codegen/src/test/resources/expressions/IsExpNat1True.result rename to core/codegen/javagen/src/test/resources/expressions/IsExpNat1True.result diff --git a/core/codegen/src/test/resources/expressions/IsExpNatFalse b/core/codegen/javagen/src/test/resources/expressions/IsExpNatFalse similarity index 100% rename from core/codegen/src/test/resources/expressions/IsExpNatFalse rename to core/codegen/javagen/src/test/resources/expressions/IsExpNatFalse diff --git a/core/codegen/src/test/resources/expressions/IsExpNatFalse.result b/core/codegen/javagen/src/test/resources/expressions/IsExpNatFalse.result similarity index 100% rename from core/codegen/src/test/resources/expressions/IsExpNatFalse.result rename to core/codegen/javagen/src/test/resources/expressions/IsExpNatFalse.result diff --git a/core/codegen/src/test/resources/expressions/IsExpNatTrue b/core/codegen/javagen/src/test/resources/expressions/IsExpNatTrue similarity index 100% rename from core/codegen/src/test/resources/expressions/IsExpNatTrue rename to core/codegen/javagen/src/test/resources/expressions/IsExpNatTrue diff --git a/core/codegen/src/test/resources/expressions/IsExpNatTrue.result b/core/codegen/javagen/src/test/resources/expressions/IsExpNatTrue.result similarity index 100% rename from core/codegen/src/test/resources/expressions/IsExpNatTrue.result rename to core/codegen/javagen/src/test/resources/expressions/IsExpNatTrue.result diff --git a/core/codegen/src/test/resources/expressions/IsExpRatFalse b/core/codegen/javagen/src/test/resources/expressions/IsExpRatFalse similarity index 100% rename from core/codegen/src/test/resources/expressions/IsExpRatFalse rename to core/codegen/javagen/src/test/resources/expressions/IsExpRatFalse diff --git a/core/codegen/src/test/resources/expressions/IsExpRatFalse.result b/core/codegen/javagen/src/test/resources/expressions/IsExpRatFalse.result similarity index 100% rename from core/codegen/src/test/resources/expressions/IsExpRatFalse.result rename to core/codegen/javagen/src/test/resources/expressions/IsExpRatFalse.result diff --git a/core/codegen/src/test/resources/expressions/IsExpRatTrue b/core/codegen/javagen/src/test/resources/expressions/IsExpRatTrue similarity index 100% rename from core/codegen/src/test/resources/expressions/IsExpRatTrue rename to core/codegen/javagen/src/test/resources/expressions/IsExpRatTrue diff --git a/core/codegen/src/test/resources/expressions/IsExpRatTrue.result b/core/codegen/javagen/src/test/resources/expressions/IsExpRatTrue.result similarity index 100% rename from core/codegen/src/test/resources/expressions/IsExpRatTrue.result rename to core/codegen/javagen/src/test/resources/expressions/IsExpRatTrue.result diff --git a/core/codegen/src/test/resources/expressions/IsExpTokenFalse b/core/codegen/javagen/src/test/resources/expressions/IsExpTokenFalse similarity index 100% rename from core/codegen/src/test/resources/expressions/IsExpTokenFalse rename to core/codegen/javagen/src/test/resources/expressions/IsExpTokenFalse diff --git a/core/codegen/src/test/resources/expressions/IsExpTokenFalse.result b/core/codegen/javagen/src/test/resources/expressions/IsExpTokenFalse.result similarity index 100% rename from core/codegen/src/test/resources/expressions/IsExpTokenFalse.result rename to core/codegen/javagen/src/test/resources/expressions/IsExpTokenFalse.result diff --git a/core/codegen/src/test/resources/expressions/IsExpTokenTrue b/core/codegen/javagen/src/test/resources/expressions/IsExpTokenTrue similarity index 100% rename from core/codegen/src/test/resources/expressions/IsExpTokenTrue rename to core/codegen/javagen/src/test/resources/expressions/IsExpTokenTrue diff --git a/core/codegen/src/test/resources/expressions/IsExpTokenTrue.result b/core/codegen/javagen/src/test/resources/expressions/IsExpTokenTrue.result similarity index 100% rename from core/codegen/src/test/resources/expressions/IsExpTokenTrue.result rename to core/codegen/javagen/src/test/resources/expressions/IsExpTokenTrue.result diff --git a/core/codegen/src/test/resources/expressions/Maps/MapApplyMapEnumExp b/core/codegen/javagen/src/test/resources/expressions/Maps/MapApplyMapEnumExp similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/MapApplyMapEnumExp rename to core/codegen/javagen/src/test/resources/expressions/Maps/MapApplyMapEnumExp diff --git a/core/codegen/src/test/resources/expressions/Maps/MapApplyMapEnumExp.result b/core/codegen/javagen/src/test/resources/expressions/Maps/MapApplyMapEnumExp.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/MapApplyMapEnumExp.result rename to core/codegen/javagen/src/test/resources/expressions/Maps/MapApplyMapEnumExp.result diff --git a/core/codegen/src/test/resources/expressions/Maps/MapDomEmptyMap b/core/codegen/javagen/src/test/resources/expressions/Maps/MapDomEmptyMap similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/MapDomEmptyMap rename to core/codegen/javagen/src/test/resources/expressions/Maps/MapDomEmptyMap diff --git a/core/codegen/src/test/resources/expressions/Maps/MapDomEmptyMap.result b/core/codegen/javagen/src/test/resources/expressions/Maps/MapDomEmptyMap.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/MapDomEmptyMap.result rename to core/codegen/javagen/src/test/resources/expressions/Maps/MapDomEmptyMap.result diff --git a/core/codegen/src/test/resources/expressions/Maps/MapDomNatToNatMap b/core/codegen/javagen/src/test/resources/expressions/Maps/MapDomNatToNatMap similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/MapDomNatToNatMap rename to core/codegen/javagen/src/test/resources/expressions/Maps/MapDomNatToNatMap diff --git a/core/codegen/src/test/resources/expressions/Maps/MapDomNatToNatMap.result b/core/codegen/javagen/src/test/resources/expressions/Maps/MapDomNatToNatMap.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/MapDomNatToNatMap.result rename to core/codegen/javagen/src/test/resources/expressions/Maps/MapDomNatToNatMap.result diff --git a/core/codegen/src/test/resources/expressions/Maps/MapDomResByEmtptySetAndMap b/core/codegen/javagen/src/test/resources/expressions/Maps/MapDomResByEmtptySetAndMap similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/MapDomResByEmtptySetAndMap rename to core/codegen/javagen/src/test/resources/expressions/Maps/MapDomResByEmtptySetAndMap diff --git a/core/codegen/src/test/resources/expressions/Maps/MapDomResByEmtptySetAndMap.result b/core/codegen/javagen/src/test/resources/expressions/Maps/MapDomResByEmtptySetAndMap.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/MapDomResByEmtptySetAndMap.result rename to core/codegen/javagen/src/test/resources/expressions/Maps/MapDomResByEmtptySetAndMap.result diff --git a/core/codegen/src/test/resources/expressions/Maps/MapDomResByNatToNatMap b/core/codegen/javagen/src/test/resources/expressions/Maps/MapDomResByNatToNatMap similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/MapDomResByNatToNatMap rename to core/codegen/javagen/src/test/resources/expressions/Maps/MapDomResByNatToNatMap diff --git a/core/codegen/src/test/resources/expressions/Maps/MapDomResByNatToNatMap.result b/core/codegen/javagen/src/test/resources/expressions/Maps/MapDomResByNatToNatMap.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/MapDomResByNatToNatMap.result rename to core/codegen/javagen/src/test/resources/expressions/Maps/MapDomResByNatToNatMap.result diff --git a/core/codegen/src/test/resources/expressions/Maps/MapDomResToEmtptySetAndMap b/core/codegen/javagen/src/test/resources/expressions/Maps/MapDomResToEmtptySetAndMap similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/MapDomResToEmtptySetAndMap rename to core/codegen/javagen/src/test/resources/expressions/Maps/MapDomResToEmtptySetAndMap diff --git a/core/codegen/src/test/resources/expressions/Maps/MapDomResToEmtptySetAndMap.result b/core/codegen/javagen/src/test/resources/expressions/Maps/MapDomResToEmtptySetAndMap.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/MapDomResToEmtptySetAndMap.result rename to core/codegen/javagen/src/test/resources/expressions/Maps/MapDomResToEmtptySetAndMap.result diff --git a/core/codegen/src/test/resources/expressions/Maps/MapDomResToNatToNatMap b/core/codegen/javagen/src/test/resources/expressions/Maps/MapDomResToNatToNatMap similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/MapDomResToNatToNatMap rename to core/codegen/javagen/src/test/resources/expressions/Maps/MapDomResToNatToNatMap diff --git a/core/codegen/src/test/resources/expressions/Maps/MapDomResToNatToNatMap.result b/core/codegen/javagen/src/test/resources/expressions/Maps/MapDomResToNatToNatMap.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/MapDomResToNatToNatMap.result rename to core/codegen/javagen/src/test/resources/expressions/Maps/MapDomResToNatToNatMap.result diff --git a/core/codegen/src/test/resources/expressions/Maps/MapEnumExpEmpty b/core/codegen/javagen/src/test/resources/expressions/Maps/MapEnumExpEmpty similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/MapEnumExpEmpty rename to core/codegen/javagen/src/test/resources/expressions/Maps/MapEnumExpEmpty diff --git a/core/codegen/src/test/resources/expressions/Maps/MapEnumExpEmpty.result b/core/codegen/javagen/src/test/resources/expressions/Maps/MapEnumExpEmpty.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/MapEnumExpEmpty.result rename to core/codegen/javagen/src/test/resources/expressions/Maps/MapEnumExpEmpty.result diff --git a/core/codegen/src/test/resources/expressions/Maps/MapEnumExpMixed b/core/codegen/javagen/src/test/resources/expressions/Maps/MapEnumExpMixed similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/MapEnumExpMixed rename to core/codegen/javagen/src/test/resources/expressions/Maps/MapEnumExpMixed diff --git a/core/codegen/src/test/resources/expressions/Maps/MapEnumExpMixed.result b/core/codegen/javagen/src/test/resources/expressions/Maps/MapEnumExpMixed.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/MapEnumExpMixed.result rename to core/codegen/javagen/src/test/resources/expressions/Maps/MapEnumExpMixed.result diff --git a/core/codegen/src/test/resources/expressions/Maps/MapEnumExpNats b/core/codegen/javagen/src/test/resources/expressions/Maps/MapEnumExpNats similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/MapEnumExpNats rename to core/codegen/javagen/src/test/resources/expressions/Maps/MapEnumExpNats diff --git a/core/codegen/src/test/resources/expressions/Maps/MapEnumExpNats.result b/core/codegen/javagen/src/test/resources/expressions/Maps/MapEnumExpNats.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/MapEnumExpNats.result rename to core/codegen/javagen/src/test/resources/expressions/Maps/MapEnumExpNats.result diff --git a/core/codegen/src/test/resources/expressions/Maps/MapInverseNatToNatMap b/core/codegen/javagen/src/test/resources/expressions/Maps/MapInverseNatToNatMap similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/MapInverseNatToNatMap rename to core/codegen/javagen/src/test/resources/expressions/Maps/MapInverseNatToNatMap diff --git a/core/codegen/src/test/resources/expressions/Maps/MapInverseNatToNatMap.result b/core/codegen/javagen/src/test/resources/expressions/Maps/MapInverseNatToNatMap.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/MapInverseNatToNatMap.result rename to core/codegen/javagen/src/test/resources/expressions/Maps/MapInverseNatToNatMap.result diff --git a/core/codegen/src/test/resources/expressions/Maps/MapMergeEmptyMaps b/core/codegen/javagen/src/test/resources/expressions/Maps/MapMergeEmptyMaps similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/MapMergeEmptyMaps rename to core/codegen/javagen/src/test/resources/expressions/Maps/MapMergeEmptyMaps diff --git a/core/codegen/src/test/resources/expressions/Maps/MapMergeEmptyMaps.result b/core/codegen/javagen/src/test/resources/expressions/Maps/MapMergeEmptyMaps.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/MapMergeEmptyMaps.result rename to core/codegen/javagen/src/test/resources/expressions/Maps/MapMergeEmptyMaps.result diff --git a/core/codegen/src/test/resources/expressions/Maps/MapMergeNatToNatMaps b/core/codegen/javagen/src/test/resources/expressions/Maps/MapMergeNatToNatMaps similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/MapMergeNatToNatMaps rename to core/codegen/javagen/src/test/resources/expressions/Maps/MapMergeNatToNatMaps diff --git a/core/codegen/src/test/resources/expressions/Maps/MapMergeNatToNatMaps.result b/core/codegen/javagen/src/test/resources/expressions/Maps/MapMergeNatToNatMaps.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/MapMergeNatToNatMaps.result rename to core/codegen/javagen/src/test/resources/expressions/Maps/MapMergeNatToNatMaps.result diff --git a/core/codegen/src/test/resources/expressions/Maps/MapOverrideEmptyMaps b/core/codegen/javagen/src/test/resources/expressions/Maps/MapOverrideEmptyMaps similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/MapOverrideEmptyMaps rename to core/codegen/javagen/src/test/resources/expressions/Maps/MapOverrideEmptyMaps diff --git a/core/codegen/src/test/resources/expressions/Maps/MapOverrideEmptyMaps.result b/core/codegen/javagen/src/test/resources/expressions/Maps/MapOverrideEmptyMaps.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/MapOverrideEmptyMaps.result rename to core/codegen/javagen/src/test/resources/expressions/Maps/MapOverrideEmptyMaps.result diff --git a/core/codegen/src/test/resources/expressions/Maps/MapOverrideNatToNatMaps b/core/codegen/javagen/src/test/resources/expressions/Maps/MapOverrideNatToNatMaps similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/MapOverrideNatToNatMaps rename to core/codegen/javagen/src/test/resources/expressions/Maps/MapOverrideNatToNatMaps diff --git a/core/codegen/src/test/resources/expressions/Maps/MapOverrideNatToNatMaps.result b/core/codegen/javagen/src/test/resources/expressions/Maps/MapOverrideNatToNatMaps.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/MapOverrideNatToNatMaps.result rename to core/codegen/javagen/src/test/resources/expressions/Maps/MapOverrideNatToNatMaps.result diff --git a/core/codegen/src/test/resources/expressions/Maps/MapRangeEmptyMap b/core/codegen/javagen/src/test/resources/expressions/Maps/MapRangeEmptyMap similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/MapRangeEmptyMap rename to core/codegen/javagen/src/test/resources/expressions/Maps/MapRangeEmptyMap diff --git a/core/codegen/src/test/resources/expressions/Maps/MapRangeEmptyMap.result b/core/codegen/javagen/src/test/resources/expressions/Maps/MapRangeEmptyMap.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/MapRangeEmptyMap.result rename to core/codegen/javagen/src/test/resources/expressions/Maps/MapRangeEmptyMap.result diff --git a/core/codegen/src/test/resources/expressions/Maps/MapRangeNatToNatMap b/core/codegen/javagen/src/test/resources/expressions/Maps/MapRangeNatToNatMap similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/MapRangeNatToNatMap rename to core/codegen/javagen/src/test/resources/expressions/Maps/MapRangeNatToNatMap diff --git a/core/codegen/src/test/resources/expressions/Maps/MapRangeNatToNatMap.result b/core/codegen/javagen/src/test/resources/expressions/Maps/MapRangeNatToNatMap.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/MapRangeNatToNatMap.result rename to core/codegen/javagen/src/test/resources/expressions/Maps/MapRangeNatToNatMap.result diff --git a/core/codegen/src/test/resources/expressions/Maps/MapRangeResByEmtptySetAndMap b/core/codegen/javagen/src/test/resources/expressions/Maps/MapRangeResByEmtptySetAndMap similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/MapRangeResByEmtptySetAndMap rename to core/codegen/javagen/src/test/resources/expressions/Maps/MapRangeResByEmtptySetAndMap diff --git a/core/codegen/src/test/resources/expressions/Maps/MapRangeResByEmtptySetAndMap.result b/core/codegen/javagen/src/test/resources/expressions/Maps/MapRangeResByEmtptySetAndMap.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/MapRangeResByEmtptySetAndMap.result rename to core/codegen/javagen/src/test/resources/expressions/Maps/MapRangeResByEmtptySetAndMap.result diff --git a/core/codegen/src/test/resources/expressions/Maps/MapRangeResByNatToNatMap b/core/codegen/javagen/src/test/resources/expressions/Maps/MapRangeResByNatToNatMap similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/MapRangeResByNatToNatMap rename to core/codegen/javagen/src/test/resources/expressions/Maps/MapRangeResByNatToNatMap diff --git a/core/codegen/src/test/resources/expressions/Maps/MapRangeResByNatToNatMap.result b/core/codegen/javagen/src/test/resources/expressions/Maps/MapRangeResByNatToNatMap.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/MapRangeResByNatToNatMap.result rename to core/codegen/javagen/src/test/resources/expressions/Maps/MapRangeResByNatToNatMap.result diff --git a/core/codegen/src/test/resources/expressions/Maps/MapRangeResToEmtptySetAndMap b/core/codegen/javagen/src/test/resources/expressions/Maps/MapRangeResToEmtptySetAndMap similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/MapRangeResToEmtptySetAndMap rename to core/codegen/javagen/src/test/resources/expressions/Maps/MapRangeResToEmtptySetAndMap diff --git a/core/codegen/src/test/resources/expressions/Maps/MapRangeResToEmtptySetAndMap.result b/core/codegen/javagen/src/test/resources/expressions/Maps/MapRangeResToEmtptySetAndMap.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/MapRangeResToEmtptySetAndMap.result rename to core/codegen/javagen/src/test/resources/expressions/Maps/MapRangeResToEmtptySetAndMap.result diff --git a/core/codegen/src/test/resources/expressions/Maps/MapRangeResToNatToNatMap b/core/codegen/javagen/src/test/resources/expressions/Maps/MapRangeResToNatToNatMap similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/MapRangeResToNatToNatMap rename to core/codegen/javagen/src/test/resources/expressions/Maps/MapRangeResToNatToNatMap diff --git a/core/codegen/src/test/resources/expressions/Maps/MapRangeResToNatToNatMap.result b/core/codegen/javagen/src/test/resources/expressions/Maps/MapRangeResToNatToNatMap.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/MapRangeResToNatToNatMap.result rename to core/codegen/javagen/src/test/resources/expressions/Maps/MapRangeResToNatToNatMap.result diff --git a/core/codegen/src/test/resources/expressions/Maps/MapUnionEmptyMaps b/core/codegen/javagen/src/test/resources/expressions/Maps/MapUnionEmptyMaps similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/MapUnionEmptyMaps rename to core/codegen/javagen/src/test/resources/expressions/Maps/MapUnionEmptyMaps diff --git a/core/codegen/src/test/resources/expressions/Maps/MapUnionEmptyMaps.result b/core/codegen/javagen/src/test/resources/expressions/Maps/MapUnionEmptyMaps.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/MapUnionEmptyMaps.result rename to core/codegen/javagen/src/test/resources/expressions/Maps/MapUnionEmptyMaps.result diff --git a/core/codegen/src/test/resources/expressions/Maps/MapUnionNatToNatMaps b/core/codegen/javagen/src/test/resources/expressions/Maps/MapUnionNatToNatMaps similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/MapUnionNatToNatMaps rename to core/codegen/javagen/src/test/resources/expressions/Maps/MapUnionNatToNatMaps diff --git a/core/codegen/src/test/resources/expressions/Maps/MapUnionNatToNatMaps.result b/core/codegen/javagen/src/test/resources/expressions/Maps/MapUnionNatToNatMaps.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/MapUnionNatToNatMaps.result rename to core/codegen/javagen/src/test/resources/expressions/Maps/MapUnionNatToNatMaps.result diff --git a/core/codegen/src/test/resources/expressions/Maps/SetEqual b/core/codegen/javagen/src/test/resources/expressions/Maps/SetEqual similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/SetEqual rename to core/codegen/javagen/src/test/resources/expressions/Maps/SetEqual diff --git a/core/codegen/src/test/resources/expressions/Maps/SetEqual.result b/core/codegen/javagen/src/test/resources/expressions/Maps/SetEqual.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/SetEqual.result rename to core/codegen/javagen/src/test/resources/expressions/Maps/SetEqual.result diff --git a/core/codegen/src/test/resources/expressions/Maps/SetEqualEmpty b/core/codegen/javagen/src/test/resources/expressions/Maps/SetEqualEmpty similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/SetEqualEmpty rename to core/codegen/javagen/src/test/resources/expressions/Maps/SetEqualEmpty diff --git a/core/codegen/src/test/resources/expressions/Maps/SetEqualEmpty.result b/core/codegen/javagen/src/test/resources/expressions/Maps/SetEqualEmpty.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/SetEqualEmpty.result rename to core/codegen/javagen/src/test/resources/expressions/Maps/SetEqualEmpty.result diff --git a/core/codegen/src/test/resources/expressions/Maps/SetNotEqual b/core/codegen/javagen/src/test/resources/expressions/Maps/SetNotEqual similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/SetNotEqual rename to core/codegen/javagen/src/test/resources/expressions/Maps/SetNotEqual diff --git a/core/codegen/src/test/resources/expressions/Maps/SetNotEqual.result b/core/codegen/javagen/src/test/resources/expressions/Maps/SetNotEqual.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/SetNotEqual.result rename to core/codegen/javagen/src/test/resources/expressions/Maps/SetNotEqual.result diff --git a/core/codegen/src/test/resources/expressions/Maps/SetNotEqualEmpty b/core/codegen/javagen/src/test/resources/expressions/Maps/SetNotEqualEmpty similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/SetNotEqualEmpty rename to core/codegen/javagen/src/test/resources/expressions/Maps/SetNotEqualEmpty diff --git a/core/codegen/src/test/resources/expressions/Maps/SetNotEqualEmpty.result b/core/codegen/javagen/src/test/resources/expressions/Maps/SetNotEqualEmpty.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Maps/SetNotEqualEmpty.result rename to core/codegen/javagen/src/test/resources/expressions/Maps/SetNotEqualEmpty.result diff --git a/core/codegen/src/test/resources/expressions/MkBasicExpEqualsFalse b/core/codegen/javagen/src/test/resources/expressions/MkBasicExpEqualsFalse similarity index 100% rename from core/codegen/src/test/resources/expressions/MkBasicExpEqualsFalse rename to core/codegen/javagen/src/test/resources/expressions/MkBasicExpEqualsFalse diff --git a/core/codegen/src/test/resources/expressions/MkBasicExpEqualsFalse.result b/core/codegen/javagen/src/test/resources/expressions/MkBasicExpEqualsFalse.result similarity index 100% rename from core/codegen/src/test/resources/expressions/MkBasicExpEqualsFalse.result rename to core/codegen/javagen/src/test/resources/expressions/MkBasicExpEqualsFalse.result diff --git a/core/codegen/src/test/resources/expressions/MkBasicExpEqualsTrue b/core/codegen/javagen/src/test/resources/expressions/MkBasicExpEqualsTrue similarity index 100% rename from core/codegen/src/test/resources/expressions/MkBasicExpEqualsTrue rename to core/codegen/javagen/src/test/resources/expressions/MkBasicExpEqualsTrue diff --git a/core/codegen/src/test/resources/expressions/MkBasicExpEqualsTrue.result b/core/codegen/javagen/src/test/resources/expressions/MkBasicExpEqualsTrue.result similarity index 100% rename from core/codegen/src/test/resources/expressions/MkBasicExpEqualsTrue.result rename to core/codegen/javagen/src/test/resources/expressions/MkBasicExpEqualsTrue.result diff --git a/core/codegen/src/test/resources/expressions/MkBasicExpNotEqualsFalse b/core/codegen/javagen/src/test/resources/expressions/MkBasicExpNotEqualsFalse similarity index 100% rename from core/codegen/src/test/resources/expressions/MkBasicExpNotEqualsFalse rename to core/codegen/javagen/src/test/resources/expressions/MkBasicExpNotEqualsFalse diff --git a/core/codegen/src/test/resources/expressions/MkBasicExpNotEqualsFalse.result b/core/codegen/javagen/src/test/resources/expressions/MkBasicExpNotEqualsFalse.result similarity index 100% rename from core/codegen/src/test/resources/expressions/MkBasicExpNotEqualsFalse.result rename to core/codegen/javagen/src/test/resources/expressions/MkBasicExpNotEqualsFalse.result diff --git a/core/codegen/src/test/resources/expressions/MkBasicExpNotEqualsTrue b/core/codegen/javagen/src/test/resources/expressions/MkBasicExpNotEqualsTrue similarity index 100% rename from core/codegen/src/test/resources/expressions/MkBasicExpNotEqualsTrue rename to core/codegen/javagen/src/test/resources/expressions/MkBasicExpNotEqualsTrue diff --git a/core/codegen/src/test/resources/expressions/MkBasicExpNotEqualsTrue.result b/core/codegen/javagen/src/test/resources/expressions/MkBasicExpNotEqualsTrue.result similarity index 100% rename from core/codegen/src/test/resources/expressions/MkBasicExpNotEqualsTrue.result rename to core/codegen/javagen/src/test/resources/expressions/MkBasicExpNotEqualsTrue.result diff --git a/core/codegen/src/test/resources/expressions/ModOperator b/core/codegen/javagen/src/test/resources/expressions/ModOperator similarity index 100% rename from core/codegen/src/test/resources/expressions/ModOperator rename to core/codegen/javagen/src/test/resources/expressions/ModOperator diff --git a/core/codegen/src/test/resources/expressions/ModOperator.result b/core/codegen/javagen/src/test/resources/expressions/ModOperator.result similarity index 100% rename from core/codegen/src/test/resources/expressions/ModOperator.result rename to core/codegen/javagen/src/test/resources/expressions/ModOperator.result diff --git a/core/codegen/src/test/resources/expressions/NotEqualsNumeric b/core/codegen/javagen/src/test/resources/expressions/NotEqualsNumeric similarity index 100% rename from core/codegen/src/test/resources/expressions/NotEqualsNumeric rename to core/codegen/javagen/src/test/resources/expressions/NotEqualsNumeric diff --git a/core/codegen/src/test/resources/expressions/NotEqualsNumeric.result b/core/codegen/javagen/src/test/resources/expressions/NotEqualsNumeric.result similarity index 100% rename from core/codegen/src/test/resources/expressions/NotEqualsNumeric.result rename to core/codegen/javagen/src/test/resources/expressions/NotEqualsNumeric.result diff --git a/core/codegen/src/test/resources/expressions/NotOfImplication b/core/codegen/javagen/src/test/resources/expressions/NotOfImplication similarity index 100% rename from core/codegen/src/test/resources/expressions/NotOfImplication rename to core/codegen/javagen/src/test/resources/expressions/NotOfImplication diff --git a/core/codegen/src/test/resources/expressions/NotOfImplication.result b/core/codegen/javagen/src/test/resources/expressions/NotOfImplication.result similarity index 100% rename from core/codegen/src/test/resources/expressions/NotOfImplication.result rename to core/codegen/javagen/src/test/resources/expressions/NotOfImplication.result diff --git a/core/codegen/src/test/resources/expressions/NotOfOr b/core/codegen/javagen/src/test/resources/expressions/NotOfOr similarity index 100% rename from core/codegen/src/test/resources/expressions/NotOfOr rename to core/codegen/javagen/src/test/resources/expressions/NotOfOr diff --git a/core/codegen/src/test/resources/expressions/NotOfOr.result b/core/codegen/javagen/src/test/resources/expressions/NotOfOr.result similarity index 100% rename from core/codegen/src/test/resources/expressions/NotOfOr.result rename to core/codegen/javagen/src/test/resources/expressions/NotOfOr.result diff --git a/core/codegen/src/test/resources/expressions/NotOperator b/core/codegen/javagen/src/test/resources/expressions/NotOperator similarity index 100% rename from core/codegen/src/test/resources/expressions/NotOperator rename to core/codegen/javagen/src/test/resources/expressions/NotOperator diff --git a/core/codegen/src/test/resources/expressions/NotOperator.result b/core/codegen/javagen/src/test/resources/expressions/NotOperator.result similarity index 100% rename from core/codegen/src/test/resources/expressions/NotOperator.result rename to core/codegen/javagen/src/test/resources/expressions/NotOperator.result diff --git a/core/codegen/src/test/resources/expressions/Null b/core/codegen/javagen/src/test/resources/expressions/Null similarity index 100% rename from core/codegen/src/test/resources/expressions/Null rename to core/codegen/javagen/src/test/resources/expressions/Null diff --git a/core/codegen/src/test/resources/expressions/Null.result b/core/codegen/javagen/src/test/resources/expressions/Null.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Null.result rename to core/codegen/javagen/src/test/resources/expressions/Null.result diff --git a/core/codegen/src/test/resources/expressions/NumericExp b/core/codegen/javagen/src/test/resources/expressions/NumericExp similarity index 100% rename from core/codegen/src/test/resources/expressions/NumericExp rename to core/codegen/javagen/src/test/resources/expressions/NumericExp diff --git a/core/codegen/src/test/resources/expressions/NumericExp.result b/core/codegen/javagen/src/test/resources/expressions/NumericExp.result similarity index 100% rename from core/codegen/src/test/resources/expressions/NumericExp.result rename to core/codegen/javagen/src/test/resources/expressions/NumericExp.result diff --git a/core/codegen/src/test/resources/expressions/NumericExpOperatorPrecedence b/core/codegen/javagen/src/test/resources/expressions/NumericExpOperatorPrecedence similarity index 100% rename from core/codegen/src/test/resources/expressions/NumericExpOperatorPrecedence rename to core/codegen/javagen/src/test/resources/expressions/NumericExpOperatorPrecedence diff --git a/core/codegen/src/test/resources/expressions/NumericExpOperatorPrecedence.result b/core/codegen/javagen/src/test/resources/expressions/NumericExpOperatorPrecedence.result similarity index 100% rename from core/codegen/src/test/resources/expressions/NumericExpOperatorPrecedence.result rename to core/codegen/javagen/src/test/resources/expressions/NumericExpOperatorPrecedence.result diff --git a/core/codegen/src/test/resources/expressions/OrOperator b/core/codegen/javagen/src/test/resources/expressions/OrOperator similarity index 100% rename from core/codegen/src/test/resources/expressions/OrOperator rename to core/codegen/javagen/src/test/resources/expressions/OrOperator diff --git a/core/codegen/src/test/resources/expressions/OrOperator.result b/core/codegen/javagen/src/test/resources/expressions/OrOperator.result similarity index 100% rename from core/codegen/src/test/resources/expressions/OrOperator.result rename to core/codegen/javagen/src/test/resources/expressions/OrOperator.result diff --git a/core/codegen/src/test/resources/expressions/Power b/core/codegen/javagen/src/test/resources/expressions/Power similarity index 100% rename from core/codegen/src/test/resources/expressions/Power rename to core/codegen/javagen/src/test/resources/expressions/Power diff --git a/core/codegen/src/test/resources/expressions/Power.result b/core/codegen/javagen/src/test/resources/expressions/Power.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Power.result rename to core/codegen/javagen/src/test/resources/expressions/Power.result diff --git a/core/codegen/src/test/resources/expressions/RealDivideIntegerOperands b/core/codegen/javagen/src/test/resources/expressions/RealDivideIntegerOperands similarity index 100% rename from core/codegen/src/test/resources/expressions/RealDivideIntegerOperands rename to core/codegen/javagen/src/test/resources/expressions/RealDivideIntegerOperands diff --git a/core/codegen/src/test/resources/expressions/RealDivideIntegerOperands.result b/core/codegen/javagen/src/test/resources/expressions/RealDivideIntegerOperands.result similarity index 100% rename from core/codegen/src/test/resources/expressions/RealDivideIntegerOperands.result rename to core/codegen/javagen/src/test/resources/expressions/RealDivideIntegerOperands.result diff --git a/core/codegen/src/test/resources/expressions/RealDivideRealOperand b/core/codegen/javagen/src/test/resources/expressions/RealDivideRealOperand similarity index 100% rename from core/codegen/src/test/resources/expressions/RealDivideRealOperand rename to core/codegen/javagen/src/test/resources/expressions/RealDivideRealOperand diff --git a/core/codegen/src/test/resources/expressions/RealDivideRealOperand.result b/core/codegen/javagen/src/test/resources/expressions/RealDivideRealOperand.result similarity index 100% rename from core/codegen/src/test/resources/expressions/RealDivideRealOperand.result rename to core/codegen/javagen/src/test/resources/expressions/RealDivideRealOperand.result diff --git a/core/codegen/src/test/resources/expressions/RemOperator b/core/codegen/javagen/src/test/resources/expressions/RemOperator similarity index 100% rename from core/codegen/src/test/resources/expressions/RemOperator rename to core/codegen/javagen/src/test/resources/expressions/RemOperator diff --git a/core/codegen/src/test/resources/expressions/RemOperator.result b/core/codegen/javagen/src/test/resources/expressions/RemOperator.result similarity index 100% rename from core/codegen/src/test/resources/expressions/RemOperator.result rename to core/codegen/javagen/src/test/resources/expressions/RemOperator.result diff --git a/core/codegen/src/test/resources/expressions/RemOperatorIsolation b/core/codegen/javagen/src/test/resources/expressions/RemOperatorIsolation similarity index 100% rename from core/codegen/src/test/resources/expressions/RemOperatorIsolation rename to core/codegen/javagen/src/test/resources/expressions/RemOperatorIsolation diff --git a/core/codegen/src/test/resources/expressions/RemOperatorIsolation.result b/core/codegen/javagen/src/test/resources/expressions/RemOperatorIsolation.result similarity index 100% rename from core/codegen/src/test/resources/expressions/RemOperatorIsolation.result rename to core/codegen/javagen/src/test/resources/expressions/RemOperatorIsolation.result diff --git a/core/codegen/src/test/resources/expressions/Sequences/SeqConcatExpStrings b/core/codegen/javagen/src/test/resources/expressions/Sequences/SeqConcatExpStrings similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/SeqConcatExpStrings rename to core/codegen/javagen/src/test/resources/expressions/Sequences/SeqConcatExpStrings diff --git a/core/codegen/src/test/resources/expressions/Sequences/SeqConcatExpStrings.result b/core/codegen/javagen/src/test/resources/expressions/Sequences/SeqConcatExpStrings.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/SeqConcatExpStrings.result rename to core/codegen/javagen/src/test/resources/expressions/Sequences/SeqConcatExpStrings.result diff --git a/core/codegen/src/test/resources/expressions/Sequences/SeqConcatenationExp b/core/codegen/javagen/src/test/resources/expressions/Sequences/SeqConcatenationExp similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/SeqConcatenationExp rename to core/codegen/javagen/src/test/resources/expressions/Sequences/SeqConcatenationExp diff --git a/core/codegen/src/test/resources/expressions/Sequences/SeqConcatenationExp.result b/core/codegen/javagen/src/test/resources/expressions/Sequences/SeqConcatenationExp.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/SeqConcatenationExp.result rename to core/codegen/javagen/src/test/resources/expressions/Sequences/SeqConcatenationExp.result diff --git a/core/codegen/src/test/resources/expressions/Sequences/SeqDistConcExpEmptySeq b/core/codegen/javagen/src/test/resources/expressions/Sequences/SeqDistConcExpEmptySeq similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/SeqDistConcExpEmptySeq rename to core/codegen/javagen/src/test/resources/expressions/Sequences/SeqDistConcExpEmptySeq diff --git a/core/codegen/src/test/resources/expressions/Sequences/SeqDistConcExpEmptySeq.result b/core/codegen/javagen/src/test/resources/expressions/Sequences/SeqDistConcExpEmptySeq.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/SeqDistConcExpEmptySeq.result rename to core/codegen/javagen/src/test/resources/expressions/Sequences/SeqDistConcExpEmptySeq.result diff --git a/core/codegen/src/test/resources/expressions/Sequences/SeqDistConcExpEmptySeqs b/core/codegen/javagen/src/test/resources/expressions/Sequences/SeqDistConcExpEmptySeqs similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/SeqDistConcExpEmptySeqs rename to core/codegen/javagen/src/test/resources/expressions/Sequences/SeqDistConcExpEmptySeqs diff --git a/core/codegen/src/test/resources/expressions/Sequences/SeqDistConcExpEmptySeqs.result b/core/codegen/javagen/src/test/resources/expressions/Sequences/SeqDistConcExpEmptySeqs.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/SeqDistConcExpEmptySeqs.result rename to core/codegen/javagen/src/test/resources/expressions/Sequences/SeqDistConcExpEmptySeqs.result diff --git a/core/codegen/src/test/resources/expressions/Sequences/SeqDistConcExpNoArgs b/core/codegen/javagen/src/test/resources/expressions/Sequences/SeqDistConcExpNoArgs similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/SeqDistConcExpNoArgs rename to core/codegen/javagen/src/test/resources/expressions/Sequences/SeqDistConcExpNoArgs diff --git a/core/codegen/src/test/resources/expressions/Sequences/SeqDistConcExpNoArgs.result b/core/codegen/javagen/src/test/resources/expressions/Sequences/SeqDistConcExpNoArgs.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/SeqDistConcExpNoArgs.result rename to core/codegen/javagen/src/test/resources/expressions/Sequences/SeqDistConcExpNoArgs.result diff --git a/core/codegen/src/test/resources/expressions/Sequences/SeqDistConcExpOneSeqs b/core/codegen/javagen/src/test/resources/expressions/Sequences/SeqDistConcExpOneSeqs similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/SeqDistConcExpOneSeqs rename to core/codegen/javagen/src/test/resources/expressions/Sequences/SeqDistConcExpOneSeqs diff --git a/core/codegen/src/test/resources/expressions/Sequences/SeqDistConcExpOneSeqs.result b/core/codegen/javagen/src/test/resources/expressions/Sequences/SeqDistConcExpOneSeqs.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/SeqDistConcExpOneSeqs.result rename to core/codegen/javagen/src/test/resources/expressions/Sequences/SeqDistConcExpOneSeqs.result diff --git a/core/codegen/src/test/resources/expressions/Sequences/SeqDistConcExpThreeSeqs b/core/codegen/javagen/src/test/resources/expressions/Sequences/SeqDistConcExpThreeSeqs similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/SeqDistConcExpThreeSeqs rename to core/codegen/javagen/src/test/resources/expressions/Sequences/SeqDistConcExpThreeSeqs diff --git a/core/codegen/src/test/resources/expressions/Sequences/SeqDistConcExpThreeSeqs.result b/core/codegen/javagen/src/test/resources/expressions/Sequences/SeqDistConcExpThreeSeqs.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/SeqDistConcExpThreeSeqs.result rename to core/codegen/javagen/src/test/resources/expressions/Sequences/SeqDistConcExpThreeSeqs.result diff --git a/core/codegen/src/test/resources/expressions/Sequences/SeqDistConcStrings b/core/codegen/javagen/src/test/resources/expressions/Sequences/SeqDistConcStrings similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/SeqDistConcStrings rename to core/codegen/javagen/src/test/resources/expressions/Sequences/SeqDistConcStrings diff --git a/core/codegen/src/test/resources/expressions/Sequences/SeqDistConcStrings.result b/core/codegen/javagen/src/test/resources/expressions/Sequences/SeqDistConcStrings.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/SeqDistConcStrings.result rename to core/codegen/javagen/src/test/resources/expressions/Sequences/SeqDistConcStrings.result diff --git a/core/codegen/src/test/resources/expressions/Sequences/SeqDistConcTuples b/core/codegen/javagen/src/test/resources/expressions/Sequences/SeqDistConcTuples similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/SeqDistConcTuples rename to core/codegen/javagen/src/test/resources/expressions/Sequences/SeqDistConcTuples diff --git a/core/codegen/src/test/resources/expressions/Sequences/SeqDistConcTuples.result b/core/codegen/javagen/src/test/resources/expressions/Sequences/SeqDistConcTuples.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/SeqDistConcTuples.result rename to core/codegen/javagen/src/test/resources/expressions/Sequences/SeqDistConcTuples.result diff --git a/core/codegen/src/test/resources/expressions/Sequences/SeqElemsExp b/core/codegen/javagen/src/test/resources/expressions/Sequences/SeqElemsExp similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/SeqElemsExp rename to core/codegen/javagen/src/test/resources/expressions/Sequences/SeqElemsExp diff --git a/core/codegen/src/test/resources/expressions/Sequences/SeqElemsExp.result b/core/codegen/javagen/src/test/resources/expressions/Sequences/SeqElemsExp.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/SeqElemsExp.result rename to core/codegen/javagen/src/test/resources/expressions/Sequences/SeqElemsExp.result diff --git a/core/codegen/src/test/resources/expressions/Sequences/SeqEqualsExp b/core/codegen/javagen/src/test/resources/expressions/Sequences/SeqEqualsExp similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/SeqEqualsExp rename to core/codegen/javagen/src/test/resources/expressions/Sequences/SeqEqualsExp diff --git a/core/codegen/src/test/resources/expressions/Sequences/SeqEqualsExp.result b/core/codegen/javagen/src/test/resources/expressions/Sequences/SeqEqualsExp.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/SeqEqualsExp.result rename to core/codegen/javagen/src/test/resources/expressions/Sequences/SeqEqualsExp.result diff --git a/core/codegen/src/test/resources/expressions/Sequences/SeqHdExp b/core/codegen/javagen/src/test/resources/expressions/Sequences/SeqHdExp similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/SeqHdExp rename to core/codegen/javagen/src/test/resources/expressions/Sequences/SeqHdExp diff --git a/core/codegen/src/test/resources/expressions/Sequences/SeqHdExp.result b/core/codegen/javagen/src/test/resources/expressions/Sequences/SeqHdExp.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/SeqHdExp.result rename to core/codegen/javagen/src/test/resources/expressions/Sequences/SeqHdExp.result diff --git a/core/codegen/src/test/resources/expressions/Sequences/SeqHdValueType b/core/codegen/javagen/src/test/resources/expressions/Sequences/SeqHdValueType similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/SeqHdValueType rename to core/codegen/javagen/src/test/resources/expressions/Sequences/SeqHdValueType diff --git a/core/codegen/src/test/resources/expressions/Sequences/SeqHdValueType.result b/core/codegen/javagen/src/test/resources/expressions/Sequences/SeqHdValueType.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/SeqHdValueType.result rename to core/codegen/javagen/src/test/resources/expressions/Sequences/SeqHdValueType.result diff --git a/core/codegen/src/test/resources/expressions/Sequences/SeqIndexExp b/core/codegen/javagen/src/test/resources/expressions/Sequences/SeqIndexExp similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/SeqIndexExp rename to core/codegen/javagen/src/test/resources/expressions/Sequences/SeqIndexExp diff --git a/core/codegen/src/test/resources/expressions/Sequences/SeqIndexExp.result b/core/codegen/javagen/src/test/resources/expressions/Sequences/SeqIndexExp.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/SeqIndexExp.result rename to core/codegen/javagen/src/test/resources/expressions/Sequences/SeqIndexExp.result diff --git a/core/codegen/src/test/resources/expressions/Sequences/SeqIndexValueTypeExp b/core/codegen/javagen/src/test/resources/expressions/Sequences/SeqIndexValueTypeExp similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/SeqIndexValueTypeExp rename to core/codegen/javagen/src/test/resources/expressions/Sequences/SeqIndexValueTypeExp diff --git a/core/codegen/src/test/resources/expressions/Sequences/SeqIndexValueTypeExp.result b/core/codegen/javagen/src/test/resources/expressions/Sequences/SeqIndexValueTypeExp.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/SeqIndexValueTypeExp.result rename to core/codegen/javagen/src/test/resources/expressions/Sequences/SeqIndexValueTypeExp.result diff --git a/core/codegen/src/test/resources/expressions/Sequences/SeqIndsExp b/core/codegen/javagen/src/test/resources/expressions/Sequences/SeqIndsExp similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/SeqIndsExp rename to core/codegen/javagen/src/test/resources/expressions/Sequences/SeqIndsExp diff --git a/core/codegen/src/test/resources/expressions/Sequences/SeqIndsExp.result b/core/codegen/javagen/src/test/resources/expressions/Sequences/SeqIndsExp.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/SeqIndsExp.result rename to core/codegen/javagen/src/test/resources/expressions/Sequences/SeqIndsExp.result diff --git a/core/codegen/src/test/resources/expressions/Sequences/SeqLenExp b/core/codegen/javagen/src/test/resources/expressions/Sequences/SeqLenExp similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/SeqLenExp rename to core/codegen/javagen/src/test/resources/expressions/Sequences/SeqLenExp diff --git a/core/codegen/src/test/resources/expressions/Sequences/SeqLenExp.result b/core/codegen/javagen/src/test/resources/expressions/Sequences/SeqLenExp.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/SeqLenExp.result rename to core/codegen/javagen/src/test/resources/expressions/Sequences/SeqLenExp.result diff --git a/core/codegen/src/test/resources/expressions/Sequences/SeqModExp b/core/codegen/javagen/src/test/resources/expressions/Sequences/SeqModExp similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/SeqModExp rename to core/codegen/javagen/src/test/resources/expressions/Sequences/SeqModExp diff --git a/core/codegen/src/test/resources/expressions/Sequences/SeqModExp.result b/core/codegen/javagen/src/test/resources/expressions/Sequences/SeqModExp.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/SeqModExp.result rename to core/codegen/javagen/src/test/resources/expressions/Sequences/SeqModExp.result diff --git a/core/codegen/src/test/resources/expressions/Sequences/SeqModExpEmptySeq b/core/codegen/javagen/src/test/resources/expressions/Sequences/SeqModExpEmptySeq similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/SeqModExpEmptySeq rename to core/codegen/javagen/src/test/resources/expressions/Sequences/SeqModExpEmptySeq diff --git a/core/codegen/src/test/resources/expressions/Sequences/SeqModExpEmptySeq.result b/core/codegen/javagen/src/test/resources/expressions/Sequences/SeqModExpEmptySeq.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/SeqModExpEmptySeq.result rename to core/codegen/javagen/src/test/resources/expressions/Sequences/SeqModExpEmptySeq.result diff --git a/core/codegen/src/test/resources/expressions/Sequences/SeqNotEqualsExp b/core/codegen/javagen/src/test/resources/expressions/Sequences/SeqNotEqualsExp similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/SeqNotEqualsExp rename to core/codegen/javagen/src/test/resources/expressions/Sequences/SeqNotEqualsExp diff --git a/core/codegen/src/test/resources/expressions/Sequences/SeqNotEqualsExp.result b/core/codegen/javagen/src/test/resources/expressions/Sequences/SeqNotEqualsExp.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/SeqNotEqualsExp.result rename to core/codegen/javagen/src/test/resources/expressions/Sequences/SeqNotEqualsExp.result diff --git a/core/codegen/src/test/resources/expressions/Sequences/SeqReverseExp b/core/codegen/javagen/src/test/resources/expressions/Sequences/SeqReverseExp similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/SeqReverseExp rename to core/codegen/javagen/src/test/resources/expressions/Sequences/SeqReverseExp diff --git a/core/codegen/src/test/resources/expressions/Sequences/SeqReverseExp.result b/core/codegen/javagen/src/test/resources/expressions/Sequences/SeqReverseExp.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/SeqReverseExp.result rename to core/codegen/javagen/src/test/resources/expressions/Sequences/SeqReverseExp.result diff --git a/core/codegen/src/test/resources/expressions/Sequences/SeqTlExp b/core/codegen/javagen/src/test/resources/expressions/Sequences/SeqTlExp similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/SeqTlExp rename to core/codegen/javagen/src/test/resources/expressions/Sequences/SeqTlExp diff --git a/core/codegen/src/test/resources/expressions/Sequences/SeqTlExp.result b/core/codegen/javagen/src/test/resources/expressions/Sequences/SeqTlExp.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/SeqTlExp.result rename to core/codegen/javagen/src/test/resources/expressions/Sequences/SeqTlExp.result diff --git a/core/codegen/src/test/resources/expressions/Sequences/StringEqual b/core/codegen/javagen/src/test/resources/expressions/Sequences/StringEqual similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/StringEqual rename to core/codegen/javagen/src/test/resources/expressions/Sequences/StringEqual diff --git a/core/codegen/src/test/resources/expressions/Sequences/StringEqual.result b/core/codegen/javagen/src/test/resources/expressions/Sequences/StringEqual.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/StringEqual.result rename to core/codegen/javagen/src/test/resources/expressions/Sequences/StringEqual.result diff --git a/core/codegen/src/test/resources/expressions/Sequences/StringNotEqual b/core/codegen/javagen/src/test/resources/expressions/Sequences/StringNotEqual similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/StringNotEqual rename to core/codegen/javagen/src/test/resources/expressions/Sequences/StringNotEqual diff --git a/core/codegen/src/test/resources/expressions/Sequences/StringNotEqual.result b/core/codegen/javagen/src/test/resources/expressions/Sequences/StringNotEqual.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Sequences/StringNotEqual.result rename to core/codegen/javagen/src/test/resources/expressions/Sequences/StringNotEqual.result diff --git a/core/codegen/src/test/resources/expressions/SetProperSubsetNatSets b/core/codegen/javagen/src/test/resources/expressions/SetProperSubsetNatSets similarity index 100% rename from core/codegen/src/test/resources/expressions/SetProperSubsetNatSets rename to core/codegen/javagen/src/test/resources/expressions/SetProperSubsetNatSets diff --git a/core/codegen/src/test/resources/expressions/SetProperSubsetNatSets.result b/core/codegen/javagen/src/test/resources/expressions/SetProperSubsetNatSets.result similarity index 100% rename from core/codegen/src/test/resources/expressions/SetProperSubsetNatSets.result rename to core/codegen/javagen/src/test/resources/expressions/SetProperSubsetNatSets.result diff --git a/core/codegen/src/test/resources/expressions/SetRangeEmptySet b/core/codegen/javagen/src/test/resources/expressions/SetRangeEmptySet similarity index 100% rename from core/codegen/src/test/resources/expressions/SetRangeEmptySet rename to core/codegen/javagen/src/test/resources/expressions/SetRangeEmptySet diff --git a/core/codegen/src/test/resources/expressions/SetRangeEmptySet.result b/core/codegen/javagen/src/test/resources/expressions/SetRangeEmptySet.result similarity index 100% rename from core/codegen/src/test/resources/expressions/SetRangeEmptySet.result rename to core/codegen/javagen/src/test/resources/expressions/SetRangeEmptySet.result diff --git a/core/codegen/src/test/resources/expressions/SetRangeEqualBounds b/core/codegen/javagen/src/test/resources/expressions/SetRangeEqualBounds similarity index 100% rename from core/codegen/src/test/resources/expressions/SetRangeEqualBounds rename to core/codegen/javagen/src/test/resources/expressions/SetRangeEqualBounds diff --git a/core/codegen/src/test/resources/expressions/SetRangeEqualBounds.result b/core/codegen/javagen/src/test/resources/expressions/SetRangeEqualBounds.result similarity index 100% rename from core/codegen/src/test/resources/expressions/SetRangeEqualBounds.result rename to core/codegen/javagen/src/test/resources/expressions/SetRangeEqualBounds.result diff --git a/core/codegen/src/test/resources/expressions/SetRangeOneToTen b/core/codegen/javagen/src/test/resources/expressions/SetRangeOneToTen similarity index 100% rename from core/codegen/src/test/resources/expressions/SetRangeOneToTen rename to core/codegen/javagen/src/test/resources/expressions/SetRangeOneToTen diff --git a/core/codegen/src/test/resources/expressions/SetRangeOneToTen.result b/core/codegen/javagen/src/test/resources/expressions/SetRangeOneToTen.result similarity index 100% rename from core/codegen/src/test/resources/expressions/SetRangeOneToTen.result rename to core/codegen/javagen/src/test/resources/expressions/SetRangeOneToTen.result diff --git a/core/codegen/src/test/resources/expressions/SetRangeRealBounds b/core/codegen/javagen/src/test/resources/expressions/SetRangeRealBounds similarity index 100% rename from core/codegen/src/test/resources/expressions/SetRangeRealBounds rename to core/codegen/javagen/src/test/resources/expressions/SetRangeRealBounds diff --git a/core/codegen/src/test/resources/expressions/SetRangeRealBounds.result b/core/codegen/javagen/src/test/resources/expressions/SetRangeRealBounds.result similarity index 100% rename from core/codegen/src/test/resources/expressions/SetRangeRealBounds.result rename to core/codegen/javagen/src/test/resources/expressions/SetRangeRealBounds.result diff --git a/core/codegen/src/test/resources/expressions/Sets/SetCardExpEmpty b/core/codegen/javagen/src/test/resources/expressions/Sets/SetCardExpEmpty similarity index 100% rename from core/codegen/src/test/resources/expressions/Sets/SetCardExpEmpty rename to core/codegen/javagen/src/test/resources/expressions/Sets/SetCardExpEmpty diff --git a/core/codegen/src/test/resources/expressions/Sets/SetCardExpEmpty.result b/core/codegen/javagen/src/test/resources/expressions/Sets/SetCardExpEmpty.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Sets/SetCardExpEmpty.result rename to core/codegen/javagen/src/test/resources/expressions/Sets/SetCardExpEmpty.result diff --git a/core/codegen/src/test/resources/expressions/Sets/SetCardNatSet b/core/codegen/javagen/src/test/resources/expressions/Sets/SetCardNatSet similarity index 100% rename from core/codegen/src/test/resources/expressions/Sets/SetCardNatSet rename to core/codegen/javagen/src/test/resources/expressions/Sets/SetCardNatSet diff --git a/core/codegen/src/test/resources/expressions/Sets/SetCardNatSet.result b/core/codegen/javagen/src/test/resources/expressions/Sets/SetCardNatSet.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Sets/SetCardNatSet.result rename to core/codegen/javagen/src/test/resources/expressions/Sets/SetCardNatSet.result diff --git a/core/codegen/src/test/resources/expressions/Sets/SetDifferenceNatSets b/core/codegen/javagen/src/test/resources/expressions/Sets/SetDifferenceNatSets similarity index 100% rename from core/codegen/src/test/resources/expressions/Sets/SetDifferenceNatSets rename to core/codegen/javagen/src/test/resources/expressions/Sets/SetDifferenceNatSets diff --git a/core/codegen/src/test/resources/expressions/Sets/SetDifferenceNatSets.result b/core/codegen/javagen/src/test/resources/expressions/Sets/SetDifferenceNatSets.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Sets/SetDifferenceNatSets.result rename to core/codegen/javagen/src/test/resources/expressions/Sets/SetDifferenceNatSets.result diff --git a/core/codegen/src/test/resources/expressions/Sets/SetDistInterNatSets b/core/codegen/javagen/src/test/resources/expressions/Sets/SetDistInterNatSets similarity index 100% rename from core/codegen/src/test/resources/expressions/Sets/SetDistInterNatSets rename to core/codegen/javagen/src/test/resources/expressions/Sets/SetDistInterNatSets diff --git a/core/codegen/src/test/resources/expressions/Sets/SetDistInterNatSets.result b/core/codegen/javagen/src/test/resources/expressions/Sets/SetDistInterNatSets.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Sets/SetDistInterNatSets.result rename to core/codegen/javagen/src/test/resources/expressions/Sets/SetDistInterNatSets.result diff --git a/core/codegen/src/test/resources/expressions/Sets/SetDistUnionNatSets b/core/codegen/javagen/src/test/resources/expressions/Sets/SetDistUnionNatSets similarity index 100% rename from core/codegen/src/test/resources/expressions/Sets/SetDistUnionNatSets rename to core/codegen/javagen/src/test/resources/expressions/Sets/SetDistUnionNatSets diff --git a/core/codegen/src/test/resources/expressions/Sets/SetDistUnionNatSets.result b/core/codegen/javagen/src/test/resources/expressions/Sets/SetDistUnionNatSets.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Sets/SetDistUnionNatSets.result rename to core/codegen/javagen/src/test/resources/expressions/Sets/SetDistUnionNatSets.result diff --git a/core/codegen/src/test/resources/expressions/Sets/SetEnumExpEmpty b/core/codegen/javagen/src/test/resources/expressions/Sets/SetEnumExpEmpty similarity index 100% rename from core/codegen/src/test/resources/expressions/Sets/SetEnumExpEmpty rename to core/codegen/javagen/src/test/resources/expressions/Sets/SetEnumExpEmpty diff --git a/core/codegen/src/test/resources/expressions/Sets/SetEnumExpEmpty.result b/core/codegen/javagen/src/test/resources/expressions/Sets/SetEnumExpEmpty.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Sets/SetEnumExpEmpty.result rename to core/codegen/javagen/src/test/resources/expressions/Sets/SetEnumExpEmpty.result diff --git a/core/codegen/src/test/resources/expressions/Sets/SetEnumExpNatSet b/core/codegen/javagen/src/test/resources/expressions/Sets/SetEnumExpNatSet similarity index 100% rename from core/codegen/src/test/resources/expressions/Sets/SetEnumExpNatSet rename to core/codegen/javagen/src/test/resources/expressions/Sets/SetEnumExpNatSet diff --git a/core/codegen/src/test/resources/expressions/Sets/SetEnumExpNatSet.result b/core/codegen/javagen/src/test/resources/expressions/Sets/SetEnumExpNatSet.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Sets/SetEnumExpNatSet.result rename to core/codegen/javagen/src/test/resources/expressions/Sets/SetEnumExpNatSet.result diff --git a/core/codegen/src/test/resources/expressions/Sets/SetEqual b/core/codegen/javagen/src/test/resources/expressions/Sets/SetEqual similarity index 100% rename from core/codegen/src/test/resources/expressions/Sets/SetEqual rename to core/codegen/javagen/src/test/resources/expressions/Sets/SetEqual diff --git a/core/codegen/src/test/resources/expressions/Sets/SetEqual.result b/core/codegen/javagen/src/test/resources/expressions/Sets/SetEqual.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Sets/SetEqual.result rename to core/codegen/javagen/src/test/resources/expressions/Sets/SetEqual.result diff --git a/core/codegen/src/test/resources/expressions/Sets/SetEqualEmpty b/core/codegen/javagen/src/test/resources/expressions/Sets/SetEqualEmpty similarity index 100% rename from core/codegen/src/test/resources/expressions/Sets/SetEqualEmpty rename to core/codegen/javagen/src/test/resources/expressions/Sets/SetEqualEmpty diff --git a/core/codegen/src/test/resources/expressions/Sets/SetEqualEmpty.result b/core/codegen/javagen/src/test/resources/expressions/Sets/SetEqualEmpty.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Sets/SetEqualEmpty.result rename to core/codegen/javagen/src/test/resources/expressions/Sets/SetEqualEmpty.result diff --git a/core/codegen/src/test/resources/expressions/Sets/SetInSet b/core/codegen/javagen/src/test/resources/expressions/Sets/SetInSet similarity index 100% rename from core/codegen/src/test/resources/expressions/Sets/SetInSet rename to core/codegen/javagen/src/test/resources/expressions/Sets/SetInSet diff --git a/core/codegen/src/test/resources/expressions/Sets/SetInSet.result b/core/codegen/javagen/src/test/resources/expressions/Sets/SetInSet.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Sets/SetInSet.result rename to core/codegen/javagen/src/test/resources/expressions/Sets/SetInSet.result diff --git a/core/codegen/src/test/resources/expressions/Sets/SetIntersectNatSets b/core/codegen/javagen/src/test/resources/expressions/Sets/SetIntersectNatSets similarity index 100% rename from core/codegen/src/test/resources/expressions/Sets/SetIntersectNatSets rename to core/codegen/javagen/src/test/resources/expressions/Sets/SetIntersectNatSets diff --git a/core/codegen/src/test/resources/expressions/Sets/SetIntersectNatSets.result b/core/codegen/javagen/src/test/resources/expressions/Sets/SetIntersectNatSets.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Sets/SetIntersectNatSets.result rename to core/codegen/javagen/src/test/resources/expressions/Sets/SetIntersectNatSets.result diff --git a/core/codegen/src/test/resources/expressions/Sets/SetNotEqual b/core/codegen/javagen/src/test/resources/expressions/Sets/SetNotEqual similarity index 100% rename from core/codegen/src/test/resources/expressions/Sets/SetNotEqual rename to core/codegen/javagen/src/test/resources/expressions/Sets/SetNotEqual diff --git a/core/codegen/src/test/resources/expressions/Sets/SetNotEqual.result b/core/codegen/javagen/src/test/resources/expressions/Sets/SetNotEqual.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Sets/SetNotEqual.result rename to core/codegen/javagen/src/test/resources/expressions/Sets/SetNotEqual.result diff --git a/core/codegen/src/test/resources/expressions/Sets/SetNotEqualEmpty b/core/codegen/javagen/src/test/resources/expressions/Sets/SetNotEqualEmpty similarity index 100% rename from core/codegen/src/test/resources/expressions/Sets/SetNotEqualEmpty rename to core/codegen/javagen/src/test/resources/expressions/Sets/SetNotEqualEmpty diff --git a/core/codegen/src/test/resources/expressions/Sets/SetNotEqualEmpty.result b/core/codegen/javagen/src/test/resources/expressions/Sets/SetNotEqualEmpty.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Sets/SetNotEqualEmpty.result rename to core/codegen/javagen/src/test/resources/expressions/Sets/SetNotEqualEmpty.result diff --git a/core/codegen/src/test/resources/expressions/Sets/SetNotInSet b/core/codegen/javagen/src/test/resources/expressions/Sets/SetNotInSet similarity index 100% rename from core/codegen/src/test/resources/expressions/Sets/SetNotInSet rename to core/codegen/javagen/src/test/resources/expressions/Sets/SetNotInSet diff --git a/core/codegen/src/test/resources/expressions/Sets/SetNotInSet.result b/core/codegen/javagen/src/test/resources/expressions/Sets/SetNotInSet.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Sets/SetNotInSet.result rename to core/codegen/javagen/src/test/resources/expressions/Sets/SetNotInSet.result diff --git a/core/codegen/src/test/resources/expressions/Sets/SetPowerSetEmptySet b/core/codegen/javagen/src/test/resources/expressions/Sets/SetPowerSetEmptySet similarity index 100% rename from core/codegen/src/test/resources/expressions/Sets/SetPowerSetEmptySet rename to core/codegen/javagen/src/test/resources/expressions/Sets/SetPowerSetEmptySet diff --git a/core/codegen/src/test/resources/expressions/Sets/SetPowerSetEmptySet.result b/core/codegen/javagen/src/test/resources/expressions/Sets/SetPowerSetEmptySet.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Sets/SetPowerSetEmptySet.result rename to core/codegen/javagen/src/test/resources/expressions/Sets/SetPowerSetEmptySet.result diff --git a/core/codegen/src/test/resources/expressions/Sets/SetPowerSetNatSet b/core/codegen/javagen/src/test/resources/expressions/Sets/SetPowerSetNatSet similarity index 100% rename from core/codegen/src/test/resources/expressions/Sets/SetPowerSetNatSet rename to core/codegen/javagen/src/test/resources/expressions/Sets/SetPowerSetNatSet diff --git a/core/codegen/src/test/resources/expressions/Sets/SetPowerSetNatSet.result b/core/codegen/javagen/src/test/resources/expressions/Sets/SetPowerSetNatSet.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Sets/SetPowerSetNatSet.result rename to core/codegen/javagen/src/test/resources/expressions/Sets/SetPowerSetNatSet.result diff --git a/core/codegen/src/test/resources/expressions/Sets/SetSubsetNatSet b/core/codegen/javagen/src/test/resources/expressions/Sets/SetSubsetNatSet similarity index 100% rename from core/codegen/src/test/resources/expressions/Sets/SetSubsetNatSet rename to core/codegen/javagen/src/test/resources/expressions/Sets/SetSubsetNatSet diff --git a/core/codegen/src/test/resources/expressions/Sets/SetSubsetNatSet.result b/core/codegen/javagen/src/test/resources/expressions/Sets/SetSubsetNatSet.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Sets/SetSubsetNatSet.result rename to core/codegen/javagen/src/test/resources/expressions/Sets/SetSubsetNatSet.result diff --git a/core/codegen/src/test/resources/expressions/Sets/SetUnionNatSets b/core/codegen/javagen/src/test/resources/expressions/Sets/SetUnionNatSets similarity index 100% rename from core/codegen/src/test/resources/expressions/Sets/SetUnionNatSets rename to core/codegen/javagen/src/test/resources/expressions/Sets/SetUnionNatSets diff --git a/core/codegen/src/test/resources/expressions/Sets/SetUnionNatSets.result b/core/codegen/javagen/src/test/resources/expressions/Sets/SetUnionNatSets.result similarity index 100% rename from core/codegen/src/test/resources/expressions/Sets/SetUnionNatSets.result rename to core/codegen/javagen/src/test/resources/expressions/Sets/SetUnionNatSets.result diff --git a/core/codegen/src/test/resources/expressions/StringEscape b/core/codegen/javagen/src/test/resources/expressions/StringEscape similarity index 100% rename from core/codegen/src/test/resources/expressions/StringEscape rename to core/codegen/javagen/src/test/resources/expressions/StringEscape diff --git a/core/codegen/src/test/resources/expressions/StringEscape.result b/core/codegen/javagen/src/test/resources/expressions/StringEscape.result similarity index 100% rename from core/codegen/src/test/resources/expressions/StringEscape.result rename to core/codegen/javagen/src/test/resources/expressions/StringEscape.result diff --git a/core/codegen/src/test/resources/expressions/SubSeq1 b/core/codegen/javagen/src/test/resources/expressions/SubSeq1 similarity index 100% rename from core/codegen/src/test/resources/expressions/SubSeq1 rename to core/codegen/javagen/src/test/resources/expressions/SubSeq1 diff --git a/core/codegen/src/test/resources/expressions/SubSeq1.result b/core/codegen/javagen/src/test/resources/expressions/SubSeq1.result similarity index 100% rename from core/codegen/src/test/resources/expressions/SubSeq1.result rename to core/codegen/javagen/src/test/resources/expressions/SubSeq1.result diff --git a/core/codegen/src/test/resources/expressions/SubSeq2 b/core/codegen/javagen/src/test/resources/expressions/SubSeq2 similarity index 100% rename from core/codegen/src/test/resources/expressions/SubSeq2 rename to core/codegen/javagen/src/test/resources/expressions/SubSeq2 diff --git a/core/codegen/src/test/resources/expressions/SubSeq2.result b/core/codegen/javagen/src/test/resources/expressions/SubSeq2.result similarity index 100% rename from core/codegen/src/test/resources/expressions/SubSeq2.result rename to core/codegen/javagen/src/test/resources/expressions/SubSeq2.result diff --git a/core/codegen/src/test/resources/expressions/SubSeq3 b/core/codegen/javagen/src/test/resources/expressions/SubSeq3 similarity index 100% rename from core/codegen/src/test/resources/expressions/SubSeq3 rename to core/codegen/javagen/src/test/resources/expressions/SubSeq3 diff --git a/core/codegen/src/test/resources/expressions/SubSeq3.result b/core/codegen/javagen/src/test/resources/expressions/SubSeq3.result similarity index 100% rename from core/codegen/src/test/resources/expressions/SubSeq3.result rename to core/codegen/javagen/src/test/resources/expressions/SubSeq3.result diff --git a/core/codegen/src/test/resources/expressions/SubSeq4 b/core/codegen/javagen/src/test/resources/expressions/SubSeq4 similarity index 100% rename from core/codegen/src/test/resources/expressions/SubSeq4 rename to core/codegen/javagen/src/test/resources/expressions/SubSeq4 diff --git a/core/codegen/src/test/resources/expressions/SubSeq4.result b/core/codegen/javagen/src/test/resources/expressions/SubSeq4.result similarity index 100% rename from core/codegen/src/test/resources/expressions/SubSeq4.result rename to core/codegen/javagen/src/test/resources/expressions/SubSeq4.result diff --git a/core/codegen/src/test/resources/expressions/SubSeq5 b/core/codegen/javagen/src/test/resources/expressions/SubSeq5 similarity index 100% rename from core/codegen/src/test/resources/expressions/SubSeq5 rename to core/codegen/javagen/src/test/resources/expressions/SubSeq5 diff --git a/core/codegen/src/test/resources/expressions/SubSeq5.result b/core/codegen/javagen/src/test/resources/expressions/SubSeq5.result similarity index 100% rename from core/codegen/src/test/resources/expressions/SubSeq5.result rename to core/codegen/javagen/src/test/resources/expressions/SubSeq5.result diff --git a/core/codegen/src/test/resources/expressions/SubSeq6 b/core/codegen/javagen/src/test/resources/expressions/SubSeq6 similarity index 100% rename from core/codegen/src/test/resources/expressions/SubSeq6 rename to core/codegen/javagen/src/test/resources/expressions/SubSeq6 diff --git a/core/codegen/src/test/resources/expressions/SubSeq6.result b/core/codegen/javagen/src/test/resources/expressions/SubSeq6.result similarity index 100% rename from core/codegen/src/test/resources/expressions/SubSeq6.result rename to core/codegen/javagen/src/test/resources/expressions/SubSeq6.result diff --git a/core/codegen/src/test/resources/expressions/SubtractNumericBinary b/core/codegen/javagen/src/test/resources/expressions/SubtractNumericBinary similarity index 100% rename from core/codegen/src/test/resources/expressions/SubtractNumericBinary rename to core/codegen/javagen/src/test/resources/expressions/SubtractNumericBinary diff --git a/core/codegen/src/test/resources/expressions/SubtractNumericBinary.result b/core/codegen/javagen/src/test/resources/expressions/SubtractNumericBinary.result similarity index 100% rename from core/codegen/src/test/resources/expressions/SubtractNumericBinary.result rename to core/codegen/javagen/src/test/resources/expressions/SubtractNumericBinary.result diff --git a/core/codegen/src/test/resources/expressions/TupleEquals b/core/codegen/javagen/src/test/resources/expressions/TupleEquals similarity index 100% rename from core/codegen/src/test/resources/expressions/TupleEquals rename to core/codegen/javagen/src/test/resources/expressions/TupleEquals diff --git a/core/codegen/src/test/resources/expressions/TupleEquals.result b/core/codegen/javagen/src/test/resources/expressions/TupleEquals.result similarity index 100% rename from core/codegen/src/test/resources/expressions/TupleEquals.result rename to core/codegen/javagen/src/test/resources/expressions/TupleEquals.result diff --git a/core/codegen/src/test/resources/expressions/TupleNotEquals b/core/codegen/javagen/src/test/resources/expressions/TupleNotEquals similarity index 100% rename from core/codegen/src/test/resources/expressions/TupleNotEquals rename to core/codegen/javagen/src/test/resources/expressions/TupleNotEquals diff --git a/core/codegen/src/test/resources/expressions/TupleNotEquals.result b/core/codegen/javagen/src/test/resources/expressions/TupleNotEquals.result similarity index 100% rename from core/codegen/src/test/resources/expressions/TupleNotEquals.result rename to core/codegen/javagen/src/test/resources/expressions/TupleNotEquals.result diff --git a/core/codegen/src/test/resources/expressions/UnaryMinusBinaryExp b/core/codegen/javagen/src/test/resources/expressions/UnaryMinusBinaryExp similarity index 100% rename from core/codegen/src/test/resources/expressions/UnaryMinusBinaryExp rename to core/codegen/javagen/src/test/resources/expressions/UnaryMinusBinaryExp diff --git a/core/codegen/src/test/resources/expressions/UnaryMinusBinaryExp.result b/core/codegen/javagen/src/test/resources/expressions/UnaryMinusBinaryExp.result similarity index 100% rename from core/codegen/src/test/resources/expressions/UnaryMinusBinaryExp.result rename to core/codegen/javagen/src/test/resources/expressions/UnaryMinusBinaryExp.result diff --git a/core/codegen/src/test/resources/expressions/UnaryMinusOfBinExp b/core/codegen/javagen/src/test/resources/expressions/UnaryMinusOfBinExp similarity index 100% rename from core/codegen/src/test/resources/expressions/UnaryMinusOfBinExp rename to core/codegen/javagen/src/test/resources/expressions/UnaryMinusOfBinExp diff --git a/core/codegen/src/test/resources/expressions/UnaryMinusOfBinExp.result b/core/codegen/javagen/src/test/resources/expressions/UnaryMinusOfBinExp.result similarity index 100% rename from core/codegen/src/test/resources/expressions/UnaryMinusOfBinExp.result rename to core/codegen/javagen/src/test/resources/expressions/UnaryMinusOfBinExp.result diff --git a/core/codegen/src/test/resources/expressions/UnaryPlusOfBinaryExp b/core/codegen/javagen/src/test/resources/expressions/UnaryPlusOfBinaryExp similarity index 100% rename from core/codegen/src/test/resources/expressions/UnaryPlusOfBinaryExp rename to core/codegen/javagen/src/test/resources/expressions/UnaryPlusOfBinaryExp diff --git a/core/codegen/src/test/resources/expressions/UnaryPlusOfBinaryExp.result b/core/codegen/javagen/src/test/resources/expressions/UnaryPlusOfBinaryExp.result similarity index 100% rename from core/codegen/src/test/resources/expressions/UnaryPlusOfBinaryExp.result rename to core/codegen/javagen/src/test/resources/expressions/UnaryPlusOfBinaryExp.result diff --git a/core/codegen/src/test/resources/function_value_specs/CurriedAdd1 b/core/codegen/javagen/src/test/resources/function_value_specs/CurriedAdd1 similarity index 100% rename from core/codegen/src/test/resources/function_value_specs/CurriedAdd1 rename to core/codegen/javagen/src/test/resources/function_value_specs/CurriedAdd1 diff --git a/core/codegen/src/test/resources/function_value_specs/CurriedAdd1.result b/core/codegen/javagen/src/test/resources/function_value_specs/CurriedAdd1.result similarity index 100% rename from core/codegen/src/test/resources/function_value_specs/CurriedAdd1.result rename to core/codegen/javagen/src/test/resources/function_value_specs/CurriedAdd1.result diff --git a/core/codegen/src/test/resources/function_value_specs/CurriedAdd2 b/core/codegen/javagen/src/test/resources/function_value_specs/CurriedAdd2 similarity index 100% rename from core/codegen/src/test/resources/function_value_specs/CurriedAdd2 rename to core/codegen/javagen/src/test/resources/function_value_specs/CurriedAdd2 diff --git a/core/codegen/src/test/resources/function_value_specs/CurriedAdd2.result b/core/codegen/javagen/src/test/resources/function_value_specs/CurriedAdd2.result similarity index 100% rename from core/codegen/src/test/resources/function_value_specs/CurriedAdd2.result rename to core/codegen/javagen/src/test/resources/function_value_specs/CurriedAdd2.result diff --git a/core/codegen/src/test/resources/function_value_specs/CurriedDifferentParameterTypes b/core/codegen/javagen/src/test/resources/function_value_specs/CurriedDifferentParameterTypes similarity index 100% rename from core/codegen/src/test/resources/function_value_specs/CurriedDifferentParameterTypes rename to core/codegen/javagen/src/test/resources/function_value_specs/CurriedDifferentParameterTypes diff --git a/core/codegen/src/test/resources/function_value_specs/CurriedDifferentParameterTypes.result b/core/codegen/javagen/src/test/resources/function_value_specs/CurriedDifferentParameterTypes.result similarity index 100% rename from core/codegen/src/test/resources/function_value_specs/CurriedDifferentParameterTypes.result rename to core/codegen/javagen/src/test/resources/function_value_specs/CurriedDifferentParameterTypes.result diff --git a/core/codegen/src/test/resources/function_value_specs/FunctionComposeCurried1 b/core/codegen/javagen/src/test/resources/function_value_specs/FunctionComposeCurried1 similarity index 100% rename from core/codegen/src/test/resources/function_value_specs/FunctionComposeCurried1 rename to core/codegen/javagen/src/test/resources/function_value_specs/FunctionComposeCurried1 diff --git a/core/codegen/src/test/resources/function_value_specs/FunctionComposeCurried1.result b/core/codegen/javagen/src/test/resources/function_value_specs/FunctionComposeCurried1.result similarity index 100% rename from core/codegen/src/test/resources/function_value_specs/FunctionComposeCurried1.result rename to core/codegen/javagen/src/test/resources/function_value_specs/FunctionComposeCurried1.result diff --git a/core/codegen/src/test/resources/function_value_specs/FunctionComposeCurried2 b/core/codegen/javagen/src/test/resources/function_value_specs/FunctionComposeCurried2 similarity index 100% rename from core/codegen/src/test/resources/function_value_specs/FunctionComposeCurried2 rename to core/codegen/javagen/src/test/resources/function_value_specs/FunctionComposeCurried2 diff --git a/core/codegen/src/test/resources/function_value_specs/FunctionComposeCurried2.result b/core/codegen/javagen/src/test/resources/function_value_specs/FunctionComposeCurried2.result similarity index 100% rename from core/codegen/src/test/resources/function_value_specs/FunctionComposeCurried2.result rename to core/codegen/javagen/src/test/resources/function_value_specs/FunctionComposeCurried2.result diff --git a/core/codegen/src/test/resources/function_value_specs/FunctionComposeUncurried b/core/codegen/javagen/src/test/resources/function_value_specs/FunctionComposeUncurried similarity index 100% rename from core/codegen/src/test/resources/function_value_specs/FunctionComposeUncurried rename to core/codegen/javagen/src/test/resources/function_value_specs/FunctionComposeUncurried diff --git a/core/codegen/src/test/resources/function_value_specs/FunctionComposeUncurried.result b/core/codegen/javagen/src/test/resources/function_value_specs/FunctionComposeUncurried.result similarity index 100% rename from core/codegen/src/test/resources/function_value_specs/FunctionComposeUncurried.result rename to core/codegen/javagen/src/test/resources/function_value_specs/FunctionComposeUncurried.result diff --git a/core/codegen/src/test/resources/function_value_specs/FunctionReturningFunction b/core/codegen/javagen/src/test/resources/function_value_specs/FunctionReturningFunction similarity index 100% rename from core/codegen/src/test/resources/function_value_specs/FunctionReturningFunction rename to core/codegen/javagen/src/test/resources/function_value_specs/FunctionReturningFunction diff --git a/core/codegen/src/test/resources/function_value_specs/FunctionReturningFunction.result b/core/codegen/javagen/src/test/resources/function_value_specs/FunctionReturningFunction.result similarity index 100% rename from core/codegen/src/test/resources/function_value_specs/FunctionReturningFunction.result rename to core/codegen/javagen/src/test/resources/function_value_specs/FunctionReturningFunction.result diff --git a/core/codegen/src/test/resources/function_value_specs/LambdaCurryAdd b/core/codegen/javagen/src/test/resources/function_value_specs/LambdaCurryAdd similarity index 100% rename from core/codegen/src/test/resources/function_value_specs/LambdaCurryAdd rename to core/codegen/javagen/src/test/resources/function_value_specs/LambdaCurryAdd diff --git a/core/codegen/src/test/resources/function_value_specs/LambdaCurryAdd.result b/core/codegen/javagen/src/test/resources/function_value_specs/LambdaCurryAdd.result similarity index 100% rename from core/codegen/src/test/resources/function_value_specs/LambdaCurryAdd.result rename to core/codegen/javagen/src/test/resources/function_value_specs/LambdaCurryAdd.result diff --git a/core/codegen/src/test/resources/function_value_specs/LambdaInLet b/core/codegen/javagen/src/test/resources/function_value_specs/LambdaInLet similarity index 100% rename from core/codegen/src/test/resources/function_value_specs/LambdaInLet rename to core/codegen/javagen/src/test/resources/function_value_specs/LambdaInLet diff --git a/core/codegen/src/test/resources/function_value_specs/LambdaInLet.result b/core/codegen/javagen/src/test/resources/function_value_specs/LambdaInLet.result similarity index 100% rename from core/codegen/src/test/resources/function_value_specs/LambdaInLet.result rename to core/codegen/javagen/src/test/resources/function_value_specs/LambdaInLet.result diff --git a/core/codegen/src/test/resources/function_value_specs/LambdaReturningSetComp b/core/codegen/javagen/src/test/resources/function_value_specs/LambdaReturningSetComp similarity index 100% rename from core/codegen/src/test/resources/function_value_specs/LambdaReturningSetComp rename to core/codegen/javagen/src/test/resources/function_value_specs/LambdaReturningSetComp diff --git a/core/codegen/src/test/resources/function_value_specs/LambdaReturningSetComp.result b/core/codegen/javagen/src/test/resources/function_value_specs/LambdaReturningSetComp.result similarity index 100% rename from core/codegen/src/test/resources/function_value_specs/LambdaReturningSetComp.result rename to core/codegen/javagen/src/test/resources/function_value_specs/LambdaReturningSetComp.result diff --git a/core/codegen/src/test/resources/function_value_specs/LambdaWithLet b/core/codegen/javagen/src/test/resources/function_value_specs/LambdaWithLet similarity index 100% rename from core/codegen/src/test/resources/function_value_specs/LambdaWithLet rename to core/codegen/javagen/src/test/resources/function_value_specs/LambdaWithLet diff --git a/core/codegen/src/test/resources/function_value_specs/LambdaWithLet.result b/core/codegen/javagen/src/test/resources/function_value_specs/LambdaWithLet.result similarity index 100% rename from core/codegen/src/test/resources/function_value_specs/LambdaWithLet.result rename to core/codegen/javagen/src/test/resources/function_value_specs/LambdaWithLet.result diff --git a/core/codegen/src/test/resources/function_value_specs/MapBoolToNatCurried b/core/codegen/javagen/src/test/resources/function_value_specs/MapBoolToNatCurried similarity index 100% rename from core/codegen/src/test/resources/function_value_specs/MapBoolToNatCurried rename to core/codegen/javagen/src/test/resources/function_value_specs/MapBoolToNatCurried diff --git a/core/codegen/src/test/resources/function_value_specs/MapBoolToNatCurried.result b/core/codegen/javagen/src/test/resources/function_value_specs/MapBoolToNatCurried.result similarity index 100% rename from core/codegen/src/test/resources/function_value_specs/MapBoolToNatCurried.result rename to core/codegen/javagen/src/test/resources/function_value_specs/MapBoolToNatCurried.result diff --git a/core/codegen/src/test/resources/function_value_specs/MapNatCurried b/core/codegen/javagen/src/test/resources/function_value_specs/MapNatCurried similarity index 100% rename from core/codegen/src/test/resources/function_value_specs/MapNatCurried rename to core/codegen/javagen/src/test/resources/function_value_specs/MapNatCurried diff --git a/core/codegen/src/test/resources/function_value_specs/MapNatCurried.result b/core/codegen/javagen/src/test/resources/function_value_specs/MapNatCurried.result similarity index 100% rename from core/codegen/src/test/resources/function_value_specs/MapNatCurried.result rename to core/codegen/javagen/src/test/resources/function_value_specs/MapNatCurried.result diff --git a/core/codegen/src/test/resources/function_value_specs/MapNatToBoolCurried b/core/codegen/javagen/src/test/resources/function_value_specs/MapNatToBoolCurried similarity index 93% rename from core/codegen/src/test/resources/function_value_specs/MapNatToBoolCurried rename to core/codegen/javagen/src/test/resources/function_value_specs/MapNatToBoolCurried index 1f61178ceb..c4821740ab 100644 --- a/core/codegen/src/test/resources/function_value_specs/MapNatToBoolCurried +++ b/core/codegen/javagen/src/test/resources/function_value_specs/MapNatToBoolCurried @@ -1,23 +1,23 @@ -class Entry - -functions - -functions - -public static nat_map : seq of nat -> (nat -> bool) -> seq of bool -nat_map(s) (f) == -if s = [] then - [] -else - [f(hd s)] ^ nat_map(tl s)(f); - -operations - -public static Run : () ==> ? -Run () == -let f = (lambda x : int & x mod 2 = 0), - xs = [1,2,3,4,5,6,7,8,9,10] -in - return nat_map(xs)(f); - +class Entry + +functions + +functions + +public static nat_map : seq of nat -> (nat -> bool) -> seq of bool +nat_map(s) (f) == +if s = [] then + [] +else + [f(hd s)] ^ nat_map(tl s)(f); + +operations + +public static Run : () ==> ? +Run () == +let f = (lambda x : int & x mod 2 = 0), + xs = [1,2,3,4,5,6,7,8,9,10] +in + return nat_map(xs)(f); + end Entry \ No newline at end of file diff --git a/core/codegen/src/test/resources/function_value_specs/MapNatToBoolCurried.result b/core/codegen/javagen/src/test/resources/function_value_specs/MapNatToBoolCurried.result similarity index 100% rename from core/codegen/src/test/resources/function_value_specs/MapNatToBoolCurried.result rename to core/codegen/javagen/src/test/resources/function_value_specs/MapNatToBoolCurried.result diff --git a/core/codegen/src/test/resources/function_value_specs/MapNatToChar b/core/codegen/javagen/src/test/resources/function_value_specs/MapNatToChar similarity index 100% rename from core/codegen/src/test/resources/function_value_specs/MapNatToChar rename to core/codegen/javagen/src/test/resources/function_value_specs/MapNatToChar diff --git a/core/codegen/src/test/resources/function_value_specs/MapNatToChar.result b/core/codegen/javagen/src/test/resources/function_value_specs/MapNatToChar.result similarity index 100% rename from core/codegen/src/test/resources/function_value_specs/MapNatToChar.result rename to core/codegen/javagen/src/test/resources/function_value_specs/MapNatToChar.result diff --git a/core/codegen/src/test/resources/function_value_specs/MapUncurried b/core/codegen/javagen/src/test/resources/function_value_specs/MapUncurried similarity index 100% rename from core/codegen/src/test/resources/function_value_specs/MapUncurried rename to core/codegen/javagen/src/test/resources/function_value_specs/MapUncurried diff --git a/core/codegen/src/test/resources/function_value_specs/MapUncurried.result b/core/codegen/javagen/src/test/resources/function_value_specs/MapUncurried.result similarity index 100% rename from core/codegen/src/test/resources/function_value_specs/MapUncurried.result rename to core/codegen/javagen/src/test/resources/function_value_specs/MapUncurried.result diff --git a/core/codegen/src/test/resources/lib/CSV.vdmpp b/core/codegen/javagen/src/test/resources/lib/CSV.vdmpp similarity index 100% rename from core/codegen/src/test/resources/lib/CSV.vdmpp rename to core/codegen/javagen/src/test/resources/lib/CSV.vdmpp diff --git a/core/codegen/src/test/resources/lib/IO.vdmpp b/core/codegen/javagen/src/test/resources/lib/IO.vdmpp similarity index 100% rename from core/codegen/src/test/resources/lib/IO.vdmpp rename to core/codegen/javagen/src/test/resources/lib/IO.vdmpp diff --git a/core/codegen/src/test/resources/lib/MATH.vdmpp b/core/codegen/javagen/src/test/resources/lib/MATH.vdmpp similarity index 100% rename from core/codegen/src/test/resources/lib/MATH.vdmpp rename to core/codegen/javagen/src/test/resources/lib/MATH.vdmpp diff --git a/core/codegen/src/test/resources/lib/VDMUnit.vdmpp b/core/codegen/javagen/src/test/resources/lib/VDMUnit.vdmpp similarity index 100% rename from core/codegen/src/test/resources/lib/VDMUnit.vdmpp rename to core/codegen/javagen/src/test/resources/lib/VDMUnit.vdmpp diff --git a/core/codegen/src/test/resources/lib/VDMUtil.vdmpp b/core/codegen/javagen/src/test/resources/lib/VDMUtil.vdmpp similarity index 100% rename from core/codegen/src/test/resources/lib/VDMUtil.vdmpp rename to core/codegen/javagen/src/test/resources/lib/VDMUtil.vdmpp diff --git a/core/codegen/src/test/resources/package_specs/OneClassUsesQuotes b/core/codegen/javagen/src/test/resources/package_specs/OneClassUsesQuotes similarity index 100% rename from core/codegen/src/test/resources/package_specs/OneClassUsesQuotes rename to core/codegen/javagen/src/test/resources/package_specs/OneClassUsesQuotes diff --git a/core/codegen/src/test/resources/package_specs/OneClassUsesQuotes.result b/core/codegen/javagen/src/test/resources/package_specs/OneClassUsesQuotes.result similarity index 100% rename from core/codegen/src/test/resources/package_specs/OneClassUsesQuotes.result rename to core/codegen/javagen/src/test/resources/package_specs/OneClassUsesQuotes.result diff --git a/core/codegen/src/test/resources/package_specs/RecordUsageAcrossClassSimple b/core/codegen/javagen/src/test/resources/package_specs/RecordUsageAcrossClassSimple similarity index 100% rename from core/codegen/src/test/resources/package_specs/RecordUsageAcrossClassSimple rename to core/codegen/javagen/src/test/resources/package_specs/RecordUsageAcrossClassSimple diff --git a/core/codegen/src/test/resources/package_specs/RecordUsageAcrossClassSimple.result b/core/codegen/javagen/src/test/resources/package_specs/RecordUsageAcrossClassSimple.result similarity index 100% rename from core/codegen/src/test/resources/package_specs/RecordUsageAcrossClassSimple.result rename to core/codegen/javagen/src/test/resources/package_specs/RecordUsageAcrossClassSimple.result diff --git a/core/codegen/src/test/resources/package_specs/TwoClasses b/core/codegen/javagen/src/test/resources/package_specs/TwoClasses similarity index 100% rename from core/codegen/src/test/resources/package_specs/TwoClasses rename to core/codegen/javagen/src/test/resources/package_specs/TwoClasses diff --git a/core/codegen/src/test/resources/package_specs/TwoClasses.result b/core/codegen/javagen/src/test/resources/package_specs/TwoClasses.result similarity index 100% rename from core/codegen/src/test/resources/package_specs/TwoClasses.result rename to core/codegen/javagen/src/test/resources/package_specs/TwoClasses.result diff --git a/core/codegen/src/test/resources/package_specs/UsesRuntimeLib b/core/codegen/javagen/src/test/resources/package_specs/UsesRuntimeLib similarity index 100% rename from core/codegen/src/test/resources/package_specs/UsesRuntimeLib rename to core/codegen/javagen/src/test/resources/package_specs/UsesRuntimeLib diff --git a/core/codegen/src/test/resources/package_specs/UsesRuntimeLib.result b/core/codegen/javagen/src/test/resources/package_specs/UsesRuntimeLib.result similarity index 100% rename from core/codegen/src/test/resources/package_specs/UsesRuntimeLib.result rename to core/codegen/javagen/src/test/resources/package_specs/UsesRuntimeLib.result diff --git a/core/codegen/src/test/resources/pattern_specs/BlockWithInterdependentPatterns b/core/codegen/javagen/src/test/resources/pattern_specs/BlockWithInterdependentPatterns similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/BlockWithInterdependentPatterns rename to core/codegen/javagen/src/test/resources/pattern_specs/BlockWithInterdependentPatterns diff --git a/core/codegen/src/test/resources/pattern_specs/BlockWithInterdependentPatterns.result b/core/codegen/javagen/src/test/resources/pattern_specs/BlockWithInterdependentPatterns.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/BlockWithInterdependentPatterns.result rename to core/codegen/javagen/src/test/resources/pattern_specs/BlockWithInterdependentPatterns.result diff --git a/core/codegen/src/test/resources/pattern_specs/Bool b/core/codegen/javagen/src/test/resources/pattern_specs/Bool similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/Bool rename to core/codegen/javagen/src/test/resources/pattern_specs/Bool diff --git a/core/codegen/src/test/resources/pattern_specs/Bool.result b/core/codegen/javagen/src/test/resources/pattern_specs/Bool.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/Bool.result rename to core/codegen/javagen/src/test/resources/pattern_specs/Bool.result diff --git a/core/codegen/src/test/resources/pattern_specs/CasesExpNamedInvariantTypedExp b/core/codegen/javagen/src/test/resources/pattern_specs/CasesExpNamedInvariantTypedExp similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/CasesExpNamedInvariantTypedExp rename to core/codegen/javagen/src/test/resources/pattern_specs/CasesExpNamedInvariantTypedExp diff --git a/core/codegen/src/test/resources/pattern_specs/CasesExpNamedInvariantTypedExp.result b/core/codegen/javagen/src/test/resources/pattern_specs/CasesExpNamedInvariantTypedExp.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/CasesExpNamedInvariantTypedExp.result rename to core/codegen/javagen/src/test/resources/pattern_specs/CasesExpNamedInvariantTypedExp.result diff --git a/core/codegen/src/test/resources/pattern_specs/CasesExpNestingLetExp b/core/codegen/javagen/src/test/resources/pattern_specs/CasesExpNestingLetExp similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/CasesExpNestingLetExp rename to core/codegen/javagen/src/test/resources/pattern_specs/CasesExpNestingLetExp diff --git a/core/codegen/src/test/resources/pattern_specs/CasesExpNestingLetExp.result b/core/codegen/javagen/src/test/resources/pattern_specs/CasesExpNestingLetExp.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/CasesExpNestingLetExp.result rename to core/codegen/javagen/src/test/resources/pattern_specs/CasesExpNestingLetExp.result diff --git a/core/codegen/src/test/resources/pattern_specs/CasesExpOneCaseNoOthers b/core/codegen/javagen/src/test/resources/pattern_specs/CasesExpOneCaseNoOthers similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/CasesExpOneCaseNoOthers rename to core/codegen/javagen/src/test/resources/pattern_specs/CasesExpOneCaseNoOthers diff --git a/core/codegen/src/test/resources/pattern_specs/CasesExpOneCaseNoOthers.result b/core/codegen/javagen/src/test/resources/pattern_specs/CasesExpOneCaseNoOthers.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/CasesExpOneCaseNoOthers.result rename to core/codegen/javagen/src/test/resources/pattern_specs/CasesExpOneCaseNoOthers.result diff --git a/core/codegen/src/test/resources/pattern_specs/CasesExpRec b/core/codegen/javagen/src/test/resources/pattern_specs/CasesExpRec similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/CasesExpRec rename to core/codegen/javagen/src/test/resources/pattern_specs/CasesExpRec diff --git a/core/codegen/src/test/resources/pattern_specs/CasesExpRec.result b/core/codegen/javagen/src/test/resources/pattern_specs/CasesExpRec.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/CasesExpRec.result rename to core/codegen/javagen/src/test/resources/pattern_specs/CasesExpRec.result diff --git a/core/codegen/src/test/resources/pattern_specs/CasesExpRecordPatternNamedInvariantUnionTypedExp b/core/codegen/javagen/src/test/resources/pattern_specs/CasesExpRecordPatternNamedInvariantUnionTypedExp similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/CasesExpRecordPatternNamedInvariantUnionTypedExp rename to core/codegen/javagen/src/test/resources/pattern_specs/CasesExpRecordPatternNamedInvariantUnionTypedExp diff --git a/core/codegen/src/test/resources/pattern_specs/CasesExpRecordPatternNamedInvariantUnionTypedExp.result b/core/codegen/javagen/src/test/resources/pattern_specs/CasesExpRecordPatternNamedInvariantUnionTypedExp.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/CasesExpRecordPatternNamedInvariantUnionTypedExp.result rename to core/codegen/javagen/src/test/resources/pattern_specs/CasesExpRecordPatternNamedInvariantUnionTypedExp.result diff --git a/core/codegen/src/test/resources/pattern_specs/CasesExpTuple b/core/codegen/javagen/src/test/resources/pattern_specs/CasesExpTuple similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/CasesExpTuple rename to core/codegen/javagen/src/test/resources/pattern_specs/CasesExpTuple diff --git a/core/codegen/src/test/resources/pattern_specs/CasesExpTuple.result b/core/codegen/javagen/src/test/resources/pattern_specs/CasesExpTuple.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/CasesExpTuple.result rename to core/codegen/javagen/src/test/resources/pattern_specs/CasesExpTuple.result diff --git a/core/codegen/src/test/resources/pattern_specs/CasesExpUnionTypedConWithSimpleTypes b/core/codegen/javagen/src/test/resources/pattern_specs/CasesExpUnionTypedConWithSimpleTypes similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/CasesExpUnionTypedConWithSimpleTypes rename to core/codegen/javagen/src/test/resources/pattern_specs/CasesExpUnionTypedConWithSimpleTypes diff --git a/core/codegen/src/test/resources/pattern_specs/CasesExpUnionTypedConWithSimpleTypes.result b/core/codegen/javagen/src/test/resources/pattern_specs/CasesExpUnionTypedConWithSimpleTypes.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/CasesExpUnionTypedConWithSimpleTypes.result rename to core/codegen/javagen/src/test/resources/pattern_specs/CasesExpUnionTypedConWithSimpleTypes.result diff --git a/core/codegen/src/test/resources/pattern_specs/CasesExpUnionTypedCondWithTuples b/core/codegen/javagen/src/test/resources/pattern_specs/CasesExpUnionTypedCondWithTuples similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/CasesExpUnionTypedCondWithTuples rename to core/codegen/javagen/src/test/resources/pattern_specs/CasesExpUnionTypedCondWithTuples diff --git a/core/codegen/src/test/resources/pattern_specs/CasesExpUnionTypedCondWithTuples.result b/core/codegen/javagen/src/test/resources/pattern_specs/CasesExpUnionTypedCondWithTuples.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/CasesExpUnionTypedCondWithTuples.result rename to core/codegen/javagen/src/test/resources/pattern_specs/CasesExpUnionTypedCondWithTuples.result diff --git a/core/codegen/src/test/resources/pattern_specs/CasesStmBool b/core/codegen/javagen/src/test/resources/pattern_specs/CasesStmBool similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/CasesStmBool rename to core/codegen/javagen/src/test/resources/pattern_specs/CasesStmBool diff --git a/core/codegen/src/test/resources/pattern_specs/CasesStmBool.result b/core/codegen/javagen/src/test/resources/pattern_specs/CasesStmBool.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/CasesStmBool.result rename to core/codegen/javagen/src/test/resources/pattern_specs/CasesStmBool.result diff --git a/core/codegen/src/test/resources/pattern_specs/CasesStmChar b/core/codegen/javagen/src/test/resources/pattern_specs/CasesStmChar similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/CasesStmChar rename to core/codegen/javagen/src/test/resources/pattern_specs/CasesStmChar diff --git a/core/codegen/src/test/resources/pattern_specs/CasesStmChar.result b/core/codegen/javagen/src/test/resources/pattern_specs/CasesStmChar.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/CasesStmChar.result rename to core/codegen/javagen/src/test/resources/pattern_specs/CasesStmChar.result diff --git a/core/codegen/src/test/resources/pattern_specs/CasesStmIdentifier b/core/codegen/javagen/src/test/resources/pattern_specs/CasesStmIdentifier similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/CasesStmIdentifier rename to core/codegen/javagen/src/test/resources/pattern_specs/CasesStmIdentifier diff --git a/core/codegen/src/test/resources/pattern_specs/CasesStmIdentifier.result b/core/codegen/javagen/src/test/resources/pattern_specs/CasesStmIdentifier.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/CasesStmIdentifier.result rename to core/codegen/javagen/src/test/resources/pattern_specs/CasesStmIdentifier.result diff --git a/core/codegen/src/test/resources/pattern_specs/CasesStmIgnore b/core/codegen/javagen/src/test/resources/pattern_specs/CasesStmIgnore similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/CasesStmIgnore rename to core/codegen/javagen/src/test/resources/pattern_specs/CasesStmIgnore diff --git a/core/codegen/src/test/resources/pattern_specs/CasesStmIgnore.result b/core/codegen/javagen/src/test/resources/pattern_specs/CasesStmIgnore.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/CasesStmIgnore.result rename to core/codegen/javagen/src/test/resources/pattern_specs/CasesStmIgnore.result diff --git a/core/codegen/src/test/resources/pattern_specs/CasesStmInt b/core/codegen/javagen/src/test/resources/pattern_specs/CasesStmInt similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/CasesStmInt rename to core/codegen/javagen/src/test/resources/pattern_specs/CasesStmInt diff --git a/core/codegen/src/test/resources/pattern_specs/CasesStmInt.result b/core/codegen/javagen/src/test/resources/pattern_specs/CasesStmInt.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/CasesStmInt.result rename to core/codegen/javagen/src/test/resources/pattern_specs/CasesStmInt.result diff --git a/core/codegen/src/test/resources/pattern_specs/CasesStmMultiplePatternsPerAlt b/core/codegen/javagen/src/test/resources/pattern_specs/CasesStmMultiplePatternsPerAlt similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/CasesStmMultiplePatternsPerAlt rename to core/codegen/javagen/src/test/resources/pattern_specs/CasesStmMultiplePatternsPerAlt diff --git a/core/codegen/src/test/resources/pattern_specs/CasesStmMultiplePatternsPerAlt.result b/core/codegen/javagen/src/test/resources/pattern_specs/CasesStmMultiplePatternsPerAlt.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/CasesStmMultiplePatternsPerAlt.result rename to core/codegen/javagen/src/test/resources/pattern_specs/CasesStmMultiplePatternsPerAlt.result diff --git a/core/codegen/src/test/resources/pattern_specs/CasesStmNamedInvariantTypedExp b/core/codegen/javagen/src/test/resources/pattern_specs/CasesStmNamedInvariantTypedExp similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/CasesStmNamedInvariantTypedExp rename to core/codegen/javagen/src/test/resources/pattern_specs/CasesStmNamedInvariantTypedExp diff --git a/core/codegen/src/test/resources/pattern_specs/CasesStmNamedInvariantTypedExp.result b/core/codegen/javagen/src/test/resources/pattern_specs/CasesStmNamedInvariantTypedExp.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/CasesStmNamedInvariantTypedExp.result rename to core/codegen/javagen/src/test/resources/pattern_specs/CasesStmNamedInvariantTypedExp.result diff --git a/core/codegen/src/test/resources/pattern_specs/CasesStmNil b/core/codegen/javagen/src/test/resources/pattern_specs/CasesStmNil similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/CasesStmNil rename to core/codegen/javagen/src/test/resources/pattern_specs/CasesStmNil diff --git a/core/codegen/src/test/resources/pattern_specs/CasesStmNil.result b/core/codegen/javagen/src/test/resources/pattern_specs/CasesStmNil.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/CasesStmNil.result rename to core/codegen/javagen/src/test/resources/pattern_specs/CasesStmNil.result diff --git a/core/codegen/src/test/resources/pattern_specs/CasesStmOpCallExp b/core/codegen/javagen/src/test/resources/pattern_specs/CasesStmOpCallExp similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/CasesStmOpCallExp rename to core/codegen/javagen/src/test/resources/pattern_specs/CasesStmOpCallExp diff --git a/core/codegen/src/test/resources/pattern_specs/CasesStmOpCallExp.result b/core/codegen/javagen/src/test/resources/pattern_specs/CasesStmOpCallExp.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/CasesStmOpCallExp.result rename to core/codegen/javagen/src/test/resources/pattern_specs/CasesStmOpCallExp.result diff --git a/core/codegen/src/test/resources/pattern_specs/CasesStmQuote b/core/codegen/javagen/src/test/resources/pattern_specs/CasesStmQuote similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/CasesStmQuote rename to core/codegen/javagen/src/test/resources/pattern_specs/CasesStmQuote diff --git a/core/codegen/src/test/resources/pattern_specs/CasesStmQuote.result b/core/codegen/javagen/src/test/resources/pattern_specs/CasesStmQuote.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/CasesStmQuote.result rename to core/codegen/javagen/src/test/resources/pattern_specs/CasesStmQuote.result diff --git a/core/codegen/src/test/resources/pattern_specs/CasesStmReal b/core/codegen/javagen/src/test/resources/pattern_specs/CasesStmReal similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/CasesStmReal rename to core/codegen/javagen/src/test/resources/pattern_specs/CasesStmReal diff --git a/core/codegen/src/test/resources/pattern_specs/CasesStmReal.result b/core/codegen/javagen/src/test/resources/pattern_specs/CasesStmReal.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/CasesStmReal.result rename to core/codegen/javagen/src/test/resources/pattern_specs/CasesStmReal.result diff --git a/core/codegen/src/test/resources/pattern_specs/CasesStmRec b/core/codegen/javagen/src/test/resources/pattern_specs/CasesStmRec similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/CasesStmRec rename to core/codegen/javagen/src/test/resources/pattern_specs/CasesStmRec diff --git a/core/codegen/src/test/resources/pattern_specs/CasesStmRec.result b/core/codegen/javagen/src/test/resources/pattern_specs/CasesStmRec.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/CasesStmRec.result rename to core/codegen/javagen/src/test/resources/pattern_specs/CasesStmRec.result diff --git a/core/codegen/src/test/resources/pattern_specs/CasesStmRecordPatternNamedInvariantUnionTypedExp b/core/codegen/javagen/src/test/resources/pattern_specs/CasesStmRecordPatternNamedInvariantUnionTypedExp similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/CasesStmRecordPatternNamedInvariantUnionTypedExp rename to core/codegen/javagen/src/test/resources/pattern_specs/CasesStmRecordPatternNamedInvariantUnionTypedExp diff --git a/core/codegen/src/test/resources/pattern_specs/CasesStmRecordPatternNamedInvariantUnionTypedExp.result b/core/codegen/javagen/src/test/resources/pattern_specs/CasesStmRecordPatternNamedInvariantUnionTypedExp.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/CasesStmRecordPatternNamedInvariantUnionTypedExp.result rename to core/codegen/javagen/src/test/resources/pattern_specs/CasesStmRecordPatternNamedInvariantUnionTypedExp.result diff --git a/core/codegen/src/test/resources/pattern_specs/CasesStmString b/core/codegen/javagen/src/test/resources/pattern_specs/CasesStmString similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/CasesStmString rename to core/codegen/javagen/src/test/resources/pattern_specs/CasesStmString diff --git a/core/codegen/src/test/resources/pattern_specs/CasesStmString.result b/core/codegen/javagen/src/test/resources/pattern_specs/CasesStmString.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/CasesStmString.result rename to core/codegen/javagen/src/test/resources/pattern_specs/CasesStmString.result diff --git a/core/codegen/src/test/resources/pattern_specs/CasesStmTuple b/core/codegen/javagen/src/test/resources/pattern_specs/CasesStmTuple similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/CasesStmTuple rename to core/codegen/javagen/src/test/resources/pattern_specs/CasesStmTuple diff --git a/core/codegen/src/test/resources/pattern_specs/CasesStmTuple.result b/core/codegen/javagen/src/test/resources/pattern_specs/CasesStmTuple.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/CasesStmTuple.result rename to core/codegen/javagen/src/test/resources/pattern_specs/CasesStmTuple.result diff --git a/core/codegen/src/test/resources/pattern_specs/Char b/core/codegen/javagen/src/test/resources/pattern_specs/Char similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/Char rename to core/codegen/javagen/src/test/resources/pattern_specs/Char diff --git a/core/codegen/src/test/resources/pattern_specs/Char.result b/core/codegen/javagen/src/test/resources/pattern_specs/Char.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/Char.result rename to core/codegen/javagen/src/test/resources/pattern_specs/Char.result diff --git a/core/codegen/src/test/resources/pattern_specs/ForAllStmIdentifierPattern b/core/codegen/javagen/src/test/resources/pattern_specs/ForAllStmIdentifierPattern similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/ForAllStmIdentifierPattern rename to core/codegen/javagen/src/test/resources/pattern_specs/ForAllStmIdentifierPattern diff --git a/core/codegen/src/test/resources/pattern_specs/ForAllStmIdentifierPattern.result b/core/codegen/javagen/src/test/resources/pattern_specs/ForAllStmIdentifierPattern.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/ForAllStmIdentifierPattern.result rename to core/codegen/javagen/src/test/resources/pattern_specs/ForAllStmIdentifierPattern.result diff --git a/core/codegen/src/test/resources/pattern_specs/ForAllStmIgnorePattern b/core/codegen/javagen/src/test/resources/pattern_specs/ForAllStmIgnorePattern similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/ForAllStmIgnorePattern rename to core/codegen/javagen/src/test/resources/pattern_specs/ForAllStmIgnorePattern diff --git a/core/codegen/src/test/resources/pattern_specs/ForAllStmIgnorePattern.result b/core/codegen/javagen/src/test/resources/pattern_specs/ForAllStmIgnorePattern.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/ForAllStmIgnorePattern.result rename to core/codegen/javagen/src/test/resources/pattern_specs/ForAllStmIgnorePattern.result diff --git a/core/codegen/src/test/resources/pattern_specs/ForAllStmIntPattern b/core/codegen/javagen/src/test/resources/pattern_specs/ForAllStmIntPattern similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/ForAllStmIntPattern rename to core/codegen/javagen/src/test/resources/pattern_specs/ForAllStmIntPattern diff --git a/core/codegen/src/test/resources/pattern_specs/ForAllStmIntPattern.result b/core/codegen/javagen/src/test/resources/pattern_specs/ForAllStmIntPattern.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/ForAllStmIntPattern.result rename to core/codegen/javagen/src/test/resources/pattern_specs/ForAllStmIntPattern.result diff --git a/core/codegen/src/test/resources/pattern_specs/ForAllStmTuplePatternWithIdentifiers b/core/codegen/javagen/src/test/resources/pattern_specs/ForAllStmTuplePatternWithIdentifiers similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/ForAllStmTuplePatternWithIdentifiers rename to core/codegen/javagen/src/test/resources/pattern_specs/ForAllStmTuplePatternWithIdentifiers diff --git a/core/codegen/src/test/resources/pattern_specs/ForAllStmTuplePatternWithIdentifiers.result b/core/codegen/javagen/src/test/resources/pattern_specs/ForAllStmTuplePatternWithIdentifiers.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/ForAllStmTuplePatternWithIdentifiers.result rename to core/codegen/javagen/src/test/resources/pattern_specs/ForAllStmTuplePatternWithIdentifiers.result diff --git a/core/codegen/src/test/resources/pattern_specs/ForAllStmTuplePatternWithIgnorePattern b/core/codegen/javagen/src/test/resources/pattern_specs/ForAllStmTuplePatternWithIgnorePattern similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/ForAllStmTuplePatternWithIgnorePattern rename to core/codegen/javagen/src/test/resources/pattern_specs/ForAllStmTuplePatternWithIgnorePattern diff --git a/core/codegen/src/test/resources/pattern_specs/ForAllStmTuplePatternWithIgnorePattern.result b/core/codegen/javagen/src/test/resources/pattern_specs/ForAllStmTuplePatternWithIgnorePattern.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/ForAllStmTuplePatternWithIgnorePattern.result rename to core/codegen/javagen/src/test/resources/pattern_specs/ForAllStmTuplePatternWithIgnorePattern.result diff --git a/core/codegen/src/test/resources/pattern_specs/ForPatternBindIdentifierPattern b/core/codegen/javagen/src/test/resources/pattern_specs/ForPatternBindIdentifierPattern similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/ForPatternBindIdentifierPattern rename to core/codegen/javagen/src/test/resources/pattern_specs/ForPatternBindIdentifierPattern diff --git a/core/codegen/src/test/resources/pattern_specs/ForPatternBindIdentifierPattern.result b/core/codegen/javagen/src/test/resources/pattern_specs/ForPatternBindIdentifierPattern.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/ForPatternBindIdentifierPattern.result rename to core/codegen/javagen/src/test/resources/pattern_specs/ForPatternBindIdentifierPattern.result diff --git a/core/codegen/src/test/resources/pattern_specs/ForPatternBindIgnorePattern b/core/codegen/javagen/src/test/resources/pattern_specs/ForPatternBindIgnorePattern similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/ForPatternBindIgnorePattern rename to core/codegen/javagen/src/test/resources/pattern_specs/ForPatternBindIgnorePattern diff --git a/core/codegen/src/test/resources/pattern_specs/ForPatternBindIgnorePattern.result b/core/codegen/javagen/src/test/resources/pattern_specs/ForPatternBindIgnorePattern.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/ForPatternBindIgnorePattern.result rename to core/codegen/javagen/src/test/resources/pattern_specs/ForPatternBindIgnorePattern.result diff --git a/core/codegen/src/test/resources/pattern_specs/ForPatternBindIntPattern b/core/codegen/javagen/src/test/resources/pattern_specs/ForPatternBindIntPattern similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/ForPatternBindIntPattern rename to core/codegen/javagen/src/test/resources/pattern_specs/ForPatternBindIntPattern diff --git a/core/codegen/src/test/resources/pattern_specs/ForPatternBindIntPattern.result b/core/codegen/javagen/src/test/resources/pattern_specs/ForPatternBindIntPattern.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/ForPatternBindIntPattern.result rename to core/codegen/javagen/src/test/resources/pattern_specs/ForPatternBindIntPattern.result diff --git a/core/codegen/src/test/resources/pattern_specs/ForPatternBindTuplePatternWithIdentifiers b/core/codegen/javagen/src/test/resources/pattern_specs/ForPatternBindTuplePatternWithIdentifiers similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/ForPatternBindTuplePatternWithIdentifiers rename to core/codegen/javagen/src/test/resources/pattern_specs/ForPatternBindTuplePatternWithIdentifiers diff --git a/core/codegen/src/test/resources/pattern_specs/ForPatternBindTuplePatternWithIdentifiers.result b/core/codegen/javagen/src/test/resources/pattern_specs/ForPatternBindTuplePatternWithIdentifiers.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/ForPatternBindTuplePatternWithIdentifiers.result rename to core/codegen/javagen/src/test/resources/pattern_specs/ForPatternBindTuplePatternWithIdentifiers.result diff --git a/core/codegen/src/test/resources/pattern_specs/ForPatternBindTuplePatternWithIgnorePattern b/core/codegen/javagen/src/test/resources/pattern_specs/ForPatternBindTuplePatternWithIgnorePattern similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/ForPatternBindTuplePatternWithIgnorePattern rename to core/codegen/javagen/src/test/resources/pattern_specs/ForPatternBindTuplePatternWithIgnorePattern diff --git a/core/codegen/src/test/resources/pattern_specs/ForPatternBindTuplePatternWithIgnorePattern.result b/core/codegen/javagen/src/test/resources/pattern_specs/ForPatternBindTuplePatternWithIgnorePattern.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/ForPatternBindTuplePatternWithIgnorePattern.result rename to core/codegen/javagen/src/test/resources/pattern_specs/ForPatternBindTuplePatternWithIgnorePattern.result diff --git a/core/codegen/src/test/resources/pattern_specs/IgnorePattern b/core/codegen/javagen/src/test/resources/pattern_specs/IgnorePattern similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/IgnorePattern rename to core/codegen/javagen/src/test/resources/pattern_specs/IgnorePattern diff --git a/core/codegen/src/test/resources/pattern_specs/IgnorePattern.result b/core/codegen/javagen/src/test/resources/pattern_specs/IgnorePattern.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/IgnorePattern.result rename to core/codegen/javagen/src/test/resources/pattern_specs/IgnorePattern.result diff --git a/core/codegen/src/test/resources/pattern_specs/IgnorePatternLastInTuplePattern b/core/codegen/javagen/src/test/resources/pattern_specs/IgnorePatternLastInTuplePattern similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/IgnorePatternLastInTuplePattern rename to core/codegen/javagen/src/test/resources/pattern_specs/IgnorePatternLastInTuplePattern diff --git a/core/codegen/src/test/resources/pattern_specs/IgnorePatternLastInTuplePattern.result b/core/codegen/javagen/src/test/resources/pattern_specs/IgnorePatternLastInTuplePattern.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/IgnorePatternLastInTuplePattern.result rename to core/codegen/javagen/src/test/resources/pattern_specs/IgnorePatternLastInTuplePattern.result diff --git a/core/codegen/src/test/resources/pattern_specs/Int b/core/codegen/javagen/src/test/resources/pattern_specs/Int similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/Int rename to core/codegen/javagen/src/test/resources/pattern_specs/Int diff --git a/core/codegen/src/test/resources/pattern_specs/Int.result b/core/codegen/javagen/src/test/resources/pattern_specs/Int.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/Int.result rename to core/codegen/javagen/src/test/resources/pattern_specs/Int.result diff --git a/core/codegen/src/test/resources/pattern_specs/LetBeStRecPattern b/core/codegen/javagen/src/test/resources/pattern_specs/LetBeStRecPattern similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/LetBeStRecPattern rename to core/codegen/javagen/src/test/resources/pattern_specs/LetBeStRecPattern diff --git a/core/codegen/src/test/resources/pattern_specs/LetBeStRecPattern.result b/core/codegen/javagen/src/test/resources/pattern_specs/LetBeStRecPattern.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/LetBeStRecPattern.result rename to core/codegen/javagen/src/test/resources/pattern_specs/LetBeStRecPattern.result diff --git a/core/codegen/src/test/resources/pattern_specs/LetBeStTuplePattern1 b/core/codegen/javagen/src/test/resources/pattern_specs/LetBeStTuplePattern1 similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/LetBeStTuplePattern1 rename to core/codegen/javagen/src/test/resources/pattern_specs/LetBeStTuplePattern1 diff --git a/core/codegen/src/test/resources/pattern_specs/LetBeStTuplePattern1.result b/core/codegen/javagen/src/test/resources/pattern_specs/LetBeStTuplePattern1.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/LetBeStTuplePattern1.result rename to core/codegen/javagen/src/test/resources/pattern_specs/LetBeStTuplePattern1.result diff --git a/core/codegen/src/test/resources/pattern_specs/LetBeStTuplePattern2 b/core/codegen/javagen/src/test/resources/pattern_specs/LetBeStTuplePattern2 similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/LetBeStTuplePattern2 rename to core/codegen/javagen/src/test/resources/pattern_specs/LetBeStTuplePattern2 diff --git a/core/codegen/src/test/resources/pattern_specs/LetBeStTuplePattern2.result b/core/codegen/javagen/src/test/resources/pattern_specs/LetBeStTuplePattern2.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/LetBeStTuplePattern2.result rename to core/codegen/javagen/src/test/resources/pattern_specs/LetBeStTuplePattern2.result diff --git a/core/codegen/src/test/resources/pattern_specs/Nil b/core/codegen/javagen/src/test/resources/pattern_specs/Nil similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/Nil rename to core/codegen/javagen/src/test/resources/pattern_specs/Nil diff --git a/core/codegen/src/test/resources/pattern_specs/Nil.result b/core/codegen/javagen/src/test/resources/pattern_specs/Nil.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/Nil.result rename to core/codegen/javagen/src/test/resources/pattern_specs/Nil.result diff --git a/core/codegen/src/test/resources/pattern_specs/Quote b/core/codegen/javagen/src/test/resources/pattern_specs/Quote similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/Quote rename to core/codegen/javagen/src/test/resources/pattern_specs/Quote diff --git a/core/codegen/src/test/resources/pattern_specs/Quote.result b/core/codegen/javagen/src/test/resources/pattern_specs/Quote.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/Quote.result rename to core/codegen/javagen/src/test/resources/pattern_specs/Quote.result diff --git a/core/codegen/src/test/resources/pattern_specs/Real b/core/codegen/javagen/src/test/resources/pattern_specs/Real similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/Real rename to core/codegen/javagen/src/test/resources/pattern_specs/Real diff --git a/core/codegen/src/test/resources/pattern_specs/Real.result b/core/codegen/javagen/src/test/resources/pattern_specs/Real.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/Real.result rename to core/codegen/javagen/src/test/resources/pattern_specs/Real.result diff --git a/core/codegen/src/test/resources/pattern_specs/RecordLastFieldInt b/core/codegen/javagen/src/test/resources/pattern_specs/RecordLastFieldInt similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/RecordLastFieldInt rename to core/codegen/javagen/src/test/resources/pattern_specs/RecordLastFieldInt diff --git a/core/codegen/src/test/resources/pattern_specs/RecordLastFieldInt.result b/core/codegen/javagen/src/test/resources/pattern_specs/RecordLastFieldInt.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/RecordLastFieldInt.result rename to core/codegen/javagen/src/test/resources/pattern_specs/RecordLastFieldInt.result diff --git a/core/codegen/src/test/resources/pattern_specs/RecordNoFields b/core/codegen/javagen/src/test/resources/pattern_specs/RecordNoFields similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/RecordNoFields rename to core/codegen/javagen/src/test/resources/pattern_specs/RecordNoFields diff --git a/core/codegen/src/test/resources/pattern_specs/RecordNoFields.result b/core/codegen/javagen/src/test/resources/pattern_specs/RecordNoFields.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/RecordNoFields.result rename to core/codegen/javagen/src/test/resources/pattern_specs/RecordNoFields.result diff --git a/core/codegen/src/test/resources/pattern_specs/RecordPatternIdentifierPatterns b/core/codegen/javagen/src/test/resources/pattern_specs/RecordPatternIdentifierPatterns similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/RecordPatternIdentifierPatterns rename to core/codegen/javagen/src/test/resources/pattern_specs/RecordPatternIdentifierPatterns diff --git a/core/codegen/src/test/resources/pattern_specs/RecordPatternIdentifierPatterns.result b/core/codegen/javagen/src/test/resources/pattern_specs/RecordPatternIdentifierPatterns.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/RecordPatternIdentifierPatterns.result rename to core/codegen/javagen/src/test/resources/pattern_specs/RecordPatternIdentifierPatterns.result diff --git a/core/codegen/src/test/resources/pattern_specs/RecordPatternWithSimplePatterns b/core/codegen/javagen/src/test/resources/pattern_specs/RecordPatternWithSimplePatterns similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/RecordPatternWithSimplePatterns rename to core/codegen/javagen/src/test/resources/pattern_specs/RecordPatternWithSimplePatterns diff --git a/core/codegen/src/test/resources/pattern_specs/RecordPatternWithSimplePatterns.result b/core/codegen/javagen/src/test/resources/pattern_specs/RecordPatternWithSimplePatterns.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/RecordPatternWithSimplePatterns.result rename to core/codegen/javagen/src/test/resources/pattern_specs/RecordPatternWithSimplePatterns.result diff --git a/core/codegen/src/test/resources/pattern_specs/RecordWithIgnorePattern b/core/codegen/javagen/src/test/resources/pattern_specs/RecordWithIgnorePattern similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/RecordWithIgnorePattern rename to core/codegen/javagen/src/test/resources/pattern_specs/RecordWithIgnorePattern diff --git a/core/codegen/src/test/resources/pattern_specs/RecordWithIgnorePattern.result b/core/codegen/javagen/src/test/resources/pattern_specs/RecordWithIgnorePattern.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/RecordWithIgnorePattern.result rename to core/codegen/javagen/src/test/resources/pattern_specs/RecordWithIgnorePattern.result diff --git a/core/codegen/src/test/resources/pattern_specs/RecordWithTuple b/core/codegen/javagen/src/test/resources/pattern_specs/RecordWithTuple similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/RecordWithTuple rename to core/codegen/javagen/src/test/resources/pattern_specs/RecordWithTuple diff --git a/core/codegen/src/test/resources/pattern_specs/RecordWithTuple.result b/core/codegen/javagen/src/test/resources/pattern_specs/RecordWithTuple.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/RecordWithTuple.result rename to core/codegen/javagen/src/test/resources/pattern_specs/RecordWithTuple.result diff --git a/core/codegen/src/test/resources/pattern_specs/String b/core/codegen/javagen/src/test/resources/pattern_specs/String similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/String rename to core/codegen/javagen/src/test/resources/pattern_specs/String diff --git a/core/codegen/src/test/resources/pattern_specs/String.result b/core/codegen/javagen/src/test/resources/pattern_specs/String.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/String.result rename to core/codegen/javagen/src/test/resources/pattern_specs/String.result diff --git a/core/codegen/src/test/resources/pattern_specs/TupleLastFieldIntPattern b/core/codegen/javagen/src/test/resources/pattern_specs/TupleLastFieldIntPattern similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/TupleLastFieldIntPattern rename to core/codegen/javagen/src/test/resources/pattern_specs/TupleLastFieldIntPattern diff --git a/core/codegen/src/test/resources/pattern_specs/TupleLastFieldIntPattern.result b/core/codegen/javagen/src/test/resources/pattern_specs/TupleLastFieldIntPattern.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/TupleLastFieldIntPattern.result rename to core/codegen/javagen/src/test/resources/pattern_specs/TupleLastFieldIntPattern.result diff --git a/core/codegen/src/test/resources/pattern_specs/TupleNestingTuples b/core/codegen/javagen/src/test/resources/pattern_specs/TupleNestingTuples similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/TupleNestingTuples rename to core/codegen/javagen/src/test/resources/pattern_specs/TupleNestingTuples diff --git a/core/codegen/src/test/resources/pattern_specs/TupleNestingTuples.result b/core/codegen/javagen/src/test/resources/pattern_specs/TupleNestingTuples.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/TupleNestingTuples.result rename to core/codegen/javagen/src/test/resources/pattern_specs/TupleNestingTuples.result diff --git a/core/codegen/src/test/resources/pattern_specs/TuplePatternIdentifierPatterns b/core/codegen/javagen/src/test/resources/pattern_specs/TuplePatternIdentifierPatterns similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/TuplePatternIdentifierPatterns rename to core/codegen/javagen/src/test/resources/pattern_specs/TuplePatternIdentifierPatterns diff --git a/core/codegen/src/test/resources/pattern_specs/TuplePatternIdentifierPatterns.result b/core/codegen/javagen/src/test/resources/pattern_specs/TuplePatternIdentifierPatterns.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/TuplePatternIdentifierPatterns.result rename to core/codegen/javagen/src/test/resources/pattern_specs/TuplePatternIdentifierPatterns.result diff --git a/core/codegen/src/test/resources/pattern_specs/TuplePatternNestedInBlocks1 b/core/codegen/javagen/src/test/resources/pattern_specs/TuplePatternNestedInBlocks1 similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/TuplePatternNestedInBlocks1 rename to core/codegen/javagen/src/test/resources/pattern_specs/TuplePatternNestedInBlocks1 diff --git a/core/codegen/src/test/resources/pattern_specs/TuplePatternNestedInBlocks1.result b/core/codegen/javagen/src/test/resources/pattern_specs/TuplePatternNestedInBlocks1.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/TuplePatternNestedInBlocks1.result rename to core/codegen/javagen/src/test/resources/pattern_specs/TuplePatternNestedInBlocks1.result diff --git a/core/codegen/src/test/resources/pattern_specs/TuplePatternNestedInBlocks2 b/core/codegen/javagen/src/test/resources/pattern_specs/TuplePatternNestedInBlocks2 similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/TuplePatternNestedInBlocks2 rename to core/codegen/javagen/src/test/resources/pattern_specs/TuplePatternNestedInBlocks2 diff --git a/core/codegen/src/test/resources/pattern_specs/TuplePatternNestedInBlocks2.result b/core/codegen/javagen/src/test/resources/pattern_specs/TuplePatternNestedInBlocks2.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/TuplePatternNestedInBlocks2.result rename to core/codegen/javagen/src/test/resources/pattern_specs/TuplePatternNestedInBlocks2.result diff --git a/core/codegen/src/test/resources/pattern_specs/TupleWithBoolPattern b/core/codegen/javagen/src/test/resources/pattern_specs/TupleWithBoolPattern similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/TupleWithBoolPattern rename to core/codegen/javagen/src/test/resources/pattern_specs/TupleWithBoolPattern diff --git a/core/codegen/src/test/resources/pattern_specs/TupleWithBoolPattern.result b/core/codegen/javagen/src/test/resources/pattern_specs/TupleWithBoolPattern.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/TupleWithBoolPattern.result rename to core/codegen/javagen/src/test/resources/pattern_specs/TupleWithBoolPattern.result diff --git a/core/codegen/src/test/resources/pattern_specs/TupleWithIgnorePattern b/core/codegen/javagen/src/test/resources/pattern_specs/TupleWithIgnorePattern similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/TupleWithIgnorePattern rename to core/codegen/javagen/src/test/resources/pattern_specs/TupleWithIgnorePattern diff --git a/core/codegen/src/test/resources/pattern_specs/TupleWithIgnorePattern.result b/core/codegen/javagen/src/test/resources/pattern_specs/TupleWithIgnorePattern.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/TupleWithIgnorePattern.result rename to core/codegen/javagen/src/test/resources/pattern_specs/TupleWithIgnorePattern.result diff --git a/core/codegen/src/test/resources/pattern_specs/TupleWithRecord b/core/codegen/javagen/src/test/resources/pattern_specs/TupleWithRecord similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/TupleWithRecord rename to core/codegen/javagen/src/test/resources/pattern_specs/TupleWithRecord diff --git a/core/codegen/src/test/resources/pattern_specs/TupleWithRecord.result b/core/codegen/javagen/src/test/resources/pattern_specs/TupleWithRecord.result similarity index 100% rename from core/codegen/src/test/resources/pattern_specs/TupleWithRecord.result rename to core/codegen/javagen/src/test/resources/pattern_specs/TupleWithRecord.result diff --git a/core/codegen/src/test/resources/pre_post_specs/ImplicitFunc b/core/codegen/javagen/src/test/resources/pre_post_specs/ImplicitFunc similarity index 100% rename from core/codegen/src/test/resources/pre_post_specs/ImplicitFunc rename to core/codegen/javagen/src/test/resources/pre_post_specs/ImplicitFunc diff --git a/core/codegen/src/test/resources/pre_post_specs/ImplicitFunc.result b/core/codegen/javagen/src/test/resources/pre_post_specs/ImplicitFunc.result similarity index 100% rename from core/codegen/src/test/resources/pre_post_specs/ImplicitFunc.result rename to core/codegen/javagen/src/test/resources/pre_post_specs/ImplicitFunc.result diff --git a/core/codegen/src/test/resources/pre_post_specs/ImplicitOp b/core/codegen/javagen/src/test/resources/pre_post_specs/ImplicitOp similarity index 100% rename from core/codegen/src/test/resources/pre_post_specs/ImplicitOp rename to core/codegen/javagen/src/test/resources/pre_post_specs/ImplicitOp diff --git a/core/codegen/src/test/resources/pre_post_specs/ImplicitOp.result b/core/codegen/javagen/src/test/resources/pre_post_specs/ImplicitOp.result similarity index 100% rename from core/codegen/src/test/resources/pre_post_specs/ImplicitOp.result rename to core/codegen/javagen/src/test/resources/pre_post_specs/ImplicitOp.result diff --git a/core/codegen/src/test/resources/pre_post_specs/PostFailureFuncTuplePattern b/core/codegen/javagen/src/test/resources/pre_post_specs/PostFailureFuncTuplePattern similarity index 100% rename from core/codegen/src/test/resources/pre_post_specs/PostFailureFuncTuplePattern rename to core/codegen/javagen/src/test/resources/pre_post_specs/PostFailureFuncTuplePattern diff --git a/core/codegen/src/test/resources/pre_post_specs/PostFailureFuncTuplePattern.result b/core/codegen/javagen/src/test/resources/pre_post_specs/PostFailureFuncTuplePattern.result similarity index 100% rename from core/codegen/src/test/resources/pre_post_specs/PostFailureFuncTuplePattern.result rename to core/codegen/javagen/src/test/resources/pre_post_specs/PostFailureFuncTuplePattern.result diff --git a/core/codegen/src/test/resources/pre_post_specs/PostPassFuncTuplePattern b/core/codegen/javagen/src/test/resources/pre_post_specs/PostPassFuncTuplePattern similarity index 100% rename from core/codegen/src/test/resources/pre_post_specs/PostPassFuncTuplePattern rename to core/codegen/javagen/src/test/resources/pre_post_specs/PostPassFuncTuplePattern diff --git a/core/codegen/src/test/resources/pre_post_specs/PostPassFuncTuplePattern.result b/core/codegen/javagen/src/test/resources/pre_post_specs/PostPassFuncTuplePattern.result similarity index 100% rename from core/codegen/src/test/resources/pre_post_specs/PostPassFuncTuplePattern.result rename to core/codegen/javagen/src/test/resources/pre_post_specs/PostPassFuncTuplePattern.result diff --git a/core/codegen/src/test/resources/pre_post_specs/PostPassNonStaticOp b/core/codegen/javagen/src/test/resources/pre_post_specs/PostPassNonStaticOp similarity index 100% rename from core/codegen/src/test/resources/pre_post_specs/PostPassNonStaticOp rename to core/codegen/javagen/src/test/resources/pre_post_specs/PostPassNonStaticOp diff --git a/core/codegen/src/test/resources/pre_post_specs/PostPassNonStaticOp.result b/core/codegen/javagen/src/test/resources/pre_post_specs/PostPassNonStaticOp.result similarity index 100% rename from core/codegen/src/test/resources/pre_post_specs/PostPassNonStaticOp.result rename to core/codegen/javagen/src/test/resources/pre_post_specs/PostPassNonStaticOp.result diff --git a/core/codegen/src/test/resources/pre_post_specs/PreFailureFuncSimple1 b/core/codegen/javagen/src/test/resources/pre_post_specs/PreFailureFuncSimple1 similarity index 100% rename from core/codegen/src/test/resources/pre_post_specs/PreFailureFuncSimple1 rename to core/codegen/javagen/src/test/resources/pre_post_specs/PreFailureFuncSimple1 diff --git a/core/codegen/src/test/resources/pre_post_specs/PreFailureFuncSimple1.result b/core/codegen/javagen/src/test/resources/pre_post_specs/PreFailureFuncSimple1.result similarity index 100% rename from core/codegen/src/test/resources/pre_post_specs/PreFailureFuncSimple1.result rename to core/codegen/javagen/src/test/resources/pre_post_specs/PreFailureFuncSimple1.result diff --git a/core/codegen/src/test/resources/pre_post_specs/PreFailureOpTuplePattern b/core/codegen/javagen/src/test/resources/pre_post_specs/PreFailureOpTuplePattern similarity index 100% rename from core/codegen/src/test/resources/pre_post_specs/PreFailureOpTuplePattern rename to core/codegen/javagen/src/test/resources/pre_post_specs/PreFailureOpTuplePattern diff --git a/core/codegen/src/test/resources/pre_post_specs/PreFailureOpTuplePattern.result b/core/codegen/javagen/src/test/resources/pre_post_specs/PreFailureOpTuplePattern.result similarity index 100% rename from core/codegen/src/test/resources/pre_post_specs/PreFailureOpTuplePattern.result rename to core/codegen/javagen/src/test/resources/pre_post_specs/PreFailureOpTuplePattern.result diff --git a/core/codegen/src/test/resources/pre_post_specs/PrePassFuncSimple1 b/core/codegen/javagen/src/test/resources/pre_post_specs/PrePassFuncSimple1 similarity index 100% rename from core/codegen/src/test/resources/pre_post_specs/PrePassFuncSimple1 rename to core/codegen/javagen/src/test/resources/pre_post_specs/PrePassFuncSimple1 diff --git a/core/codegen/src/test/resources/pre_post_specs/PrePassFuncSimple1.result b/core/codegen/javagen/src/test/resources/pre_post_specs/PrePassFuncSimple1.result similarity index 100% rename from core/codegen/src/test/resources/pre_post_specs/PrePassFuncSimple1.result rename to core/codegen/javagen/src/test/resources/pre_post_specs/PrePassFuncSimple1.result diff --git a/core/codegen/src/test/resources/pre_post_specs/PrePassNonStaticOp b/core/codegen/javagen/src/test/resources/pre_post_specs/PrePassNonStaticOp similarity index 100% rename from core/codegen/src/test/resources/pre_post_specs/PrePassNonStaticOp rename to core/codegen/javagen/src/test/resources/pre_post_specs/PrePassNonStaticOp diff --git a/core/codegen/src/test/resources/pre_post_specs/PrePassNonStaticOp.result b/core/codegen/javagen/src/test/resources/pre_post_specs/PrePassNonStaticOp.result similarity index 100% rename from core/codegen/src/test/resources/pre_post_specs/PrePassNonStaticOp.result rename to core/codegen/javagen/src/test/resources/pre_post_specs/PrePassNonStaticOp.result diff --git a/core/codegen/src/test/resources/pre_post_specs/PrePassOpTuplePattern b/core/codegen/javagen/src/test/resources/pre_post_specs/PrePassOpTuplePattern similarity index 100% rename from core/codegen/src/test/resources/pre_post_specs/PrePassOpTuplePattern rename to core/codegen/javagen/src/test/resources/pre_post_specs/PrePassOpTuplePattern diff --git a/core/codegen/src/test/resources/pre_post_specs/PrePassOpTuplePattern.result b/core/codegen/javagen/src/test/resources/pre_post_specs/PrePassOpTuplePattern.result similarity index 100% rename from core/codegen/src/test/resources/pre_post_specs/PrePassOpTuplePattern.result rename to core/codegen/javagen/src/test/resources/pre_post_specs/PrePassOpTuplePattern.result diff --git a/core/codegen/src/test/resources/renaming_specs/AssignmentDef b/core/codegen/javagen/src/test/resources/renaming_specs/AssignmentDef similarity index 100% rename from core/codegen/src/test/resources/renaming_specs/AssignmentDef rename to core/codegen/javagen/src/test/resources/renaming_specs/AssignmentDef diff --git a/core/codegen/src/test/resources/renaming_specs/AssignmentDef.result b/core/codegen/javagen/src/test/resources/renaming_specs/AssignmentDef.result similarity index 100% rename from core/codegen/src/test/resources/renaming_specs/AssignmentDef.result rename to core/codegen/javagen/src/test/resources/renaming_specs/AssignmentDef.result diff --git a/core/codegen/src/test/resources/renaming_specs/ClassName b/core/codegen/javagen/src/test/resources/renaming_specs/ClassName similarity index 100% rename from core/codegen/src/test/resources/renaming_specs/ClassName rename to core/codegen/javagen/src/test/resources/renaming_specs/ClassName diff --git a/core/codegen/src/test/resources/renaming_specs/ClassName.result b/core/codegen/javagen/src/test/resources/renaming_specs/ClassName.result similarity index 100% rename from core/codegen/src/test/resources/renaming_specs/ClassName.result rename to core/codegen/javagen/src/test/resources/renaming_specs/ClassName.result diff --git a/core/codegen/src/test/resources/renaming_specs/FuncName b/core/codegen/javagen/src/test/resources/renaming_specs/FuncName similarity index 100% rename from core/codegen/src/test/resources/renaming_specs/FuncName rename to core/codegen/javagen/src/test/resources/renaming_specs/FuncName diff --git a/core/codegen/src/test/resources/renaming_specs/FuncName.result b/core/codegen/javagen/src/test/resources/renaming_specs/FuncName.result similarity index 100% rename from core/codegen/src/test/resources/renaming_specs/FuncName.result rename to core/codegen/javagen/src/test/resources/renaming_specs/FuncName.result diff --git a/core/codegen/src/test/resources/renaming_specs/InstanceVar b/core/codegen/javagen/src/test/resources/renaming_specs/InstanceVar similarity index 100% rename from core/codegen/src/test/resources/renaming_specs/InstanceVar rename to core/codegen/javagen/src/test/resources/renaming_specs/InstanceVar diff --git a/core/codegen/src/test/resources/renaming_specs/InstanceVar.result b/core/codegen/javagen/src/test/resources/renaming_specs/InstanceVar.result similarity index 100% rename from core/codegen/src/test/resources/renaming_specs/InstanceVar.result rename to core/codegen/javagen/src/test/resources/renaming_specs/InstanceVar.result diff --git a/core/codegen/src/test/resources/renaming_specs/LetExp b/core/codegen/javagen/src/test/resources/renaming_specs/LetExp similarity index 100% rename from core/codegen/src/test/resources/renaming_specs/LetExp rename to core/codegen/javagen/src/test/resources/renaming_specs/LetExp diff --git a/core/codegen/src/test/resources/renaming_specs/LetExp.result b/core/codegen/javagen/src/test/resources/renaming_specs/LetExp.result similarity index 100% rename from core/codegen/src/test/resources/renaming_specs/LetExp.result rename to core/codegen/javagen/src/test/resources/renaming_specs/LetExp.result diff --git a/core/codegen/src/test/resources/renaming_specs/LetStm b/core/codegen/javagen/src/test/resources/renaming_specs/LetStm similarity index 100% rename from core/codegen/src/test/resources/renaming_specs/LetStm rename to core/codegen/javagen/src/test/resources/renaming_specs/LetStm diff --git a/core/codegen/src/test/resources/renaming_specs/LetStm.result b/core/codegen/javagen/src/test/resources/renaming_specs/LetStm.result similarity index 100% rename from core/codegen/src/test/resources/renaming_specs/LetStm.result rename to core/codegen/javagen/src/test/resources/renaming_specs/LetStm.result diff --git a/core/codegen/src/test/resources/renaming_specs/OpName b/core/codegen/javagen/src/test/resources/renaming_specs/OpName similarity index 100% rename from core/codegen/src/test/resources/renaming_specs/OpName rename to core/codegen/javagen/src/test/resources/renaming_specs/OpName diff --git a/core/codegen/src/test/resources/renaming_specs/OpName.result b/core/codegen/javagen/src/test/resources/renaming_specs/OpName.result similarity index 100% rename from core/codegen/src/test/resources/renaming_specs/OpName.result rename to core/codegen/javagen/src/test/resources/renaming_specs/OpName.result diff --git a/core/codegen/src/test/resources/renaming_specs/SameNameInDifferentOps b/core/codegen/javagen/src/test/resources/renaming_specs/SameNameInDifferentOps similarity index 100% rename from core/codegen/src/test/resources/renaming_specs/SameNameInDifferentOps rename to core/codegen/javagen/src/test/resources/renaming_specs/SameNameInDifferentOps diff --git a/core/codegen/src/test/resources/renaming_specs/SameNameInDifferentOps.result b/core/codegen/javagen/src/test/resources/renaming_specs/SameNameInDifferentOps.result similarity index 100% rename from core/codegen/src/test/resources/renaming_specs/SameNameInDifferentOps.result rename to core/codegen/javagen/src/test/resources/renaming_specs/SameNameInDifferentOps.result diff --git a/core/codegen/src/test/resources/renaming_specs/SamePatchTwoClass b/core/codegen/javagen/src/test/resources/renaming_specs/SamePatchTwoClass similarity index 100% rename from core/codegen/src/test/resources/renaming_specs/SamePatchTwoClass rename to core/codegen/javagen/src/test/resources/renaming_specs/SamePatchTwoClass diff --git a/core/codegen/src/test/resources/renaming_specs/SamePatchTwoClass.result b/core/codegen/javagen/src/test/resources/renaming_specs/SamePatchTwoClass.result similarity index 100% rename from core/codegen/src/test/resources/renaming_specs/SamePatchTwoClass.result rename to core/codegen/javagen/src/test/resources/renaming_specs/SamePatchTwoClass.result diff --git a/core/codegen/src/test/resources/renaming_specs/ValueDef b/core/codegen/javagen/src/test/resources/renaming_specs/ValueDef similarity index 100% rename from core/codegen/src/test/resources/renaming_specs/ValueDef rename to core/codegen/javagen/src/test/resources/renaming_specs/ValueDef diff --git a/core/codegen/src/test/resources/renaming_specs/ValueDef.result b/core/codegen/javagen/src/test/resources/renaming_specs/ValueDef.result similarity index 100% rename from core/codegen/src/test/resources/renaming_specs/ValueDef.result rename to core/codegen/javagen/src/test/resources/renaming_specs/ValueDef.result diff --git a/core/codegen/src/test/resources/rt/AsyncCounterInc b/core/codegen/javagen/src/test/resources/rt/AsyncCounterInc similarity index 100% rename from core/codegen/src/test/resources/rt/AsyncCounterInc rename to core/codegen/javagen/src/test/resources/rt/AsyncCounterInc diff --git a/core/codegen/src/test/resources/rt/AsyncCounterInc.result b/core/codegen/javagen/src/test/resources/rt/AsyncCounterInc.result similarity index 100% rename from core/codegen/src/test/resources/rt/AsyncCounterInc.result rename to core/codegen/javagen/src/test/resources/rt/AsyncCounterInc.result diff --git a/core/codegen/src/test/resources/specifications/ApplyExp b/core/codegen/javagen/src/test/resources/specifications/ApplyExp similarity index 100% rename from core/codegen/src/test/resources/specifications/ApplyExp rename to core/codegen/javagen/src/test/resources/specifications/ApplyExp diff --git a/core/codegen/src/test/resources/specifications/ApplyExp.result b/core/codegen/javagen/src/test/resources/specifications/ApplyExp.result similarity index 100% rename from core/codegen/src/test/resources/specifications/ApplyExp.result rename to core/codegen/javagen/src/test/resources/specifications/ApplyExp.result diff --git a/core/codegen/src/test/resources/specifications/ApplyExpReturnedString b/core/codegen/javagen/src/test/resources/specifications/ApplyExpReturnedString similarity index 100% rename from core/codegen/src/test/resources/specifications/ApplyExpReturnedString rename to core/codegen/javagen/src/test/resources/specifications/ApplyExpReturnedString diff --git a/core/codegen/src/test/resources/specifications/ApplyExpReturnedString.result b/core/codegen/javagen/src/test/resources/specifications/ApplyExpReturnedString.result similarity index 100% rename from core/codegen/src/test/resources/specifications/ApplyExpReturnedString.result rename to core/codegen/javagen/src/test/resources/specifications/ApplyExpReturnedString.result diff --git a/core/codegen/src/test/resources/specifications/AssignmentDefinitionReturn b/core/codegen/javagen/src/test/resources/specifications/AssignmentDefinitionReturn similarity index 100% rename from core/codegen/src/test/resources/specifications/AssignmentDefinitionReturn rename to core/codegen/javagen/src/test/resources/specifications/AssignmentDefinitionReturn diff --git a/core/codegen/src/test/resources/specifications/AssignmentDefinitionReturn.result b/core/codegen/javagen/src/test/resources/specifications/AssignmentDefinitionReturn.result similarity index 100% rename from core/codegen/src/test/resources/specifications/AssignmentDefinitionReturn.result rename to core/codegen/javagen/src/test/resources/specifications/AssignmentDefinitionReturn.result diff --git a/core/codegen/src/test/resources/specifications/BlockStmInitialized b/core/codegen/javagen/src/test/resources/specifications/BlockStmInitialized similarity index 100% rename from core/codegen/src/test/resources/specifications/BlockStmInitialized rename to core/codegen/javagen/src/test/resources/specifications/BlockStmInitialized diff --git a/core/codegen/src/test/resources/specifications/BlockStmInitialized.result b/core/codegen/javagen/src/test/resources/specifications/BlockStmInitialized.result similarity index 100% rename from core/codegen/src/test/resources/specifications/BlockStmInitialized.result rename to core/codegen/javagen/src/test/resources/specifications/BlockStmInitialized.result diff --git a/core/codegen/src/test/resources/specifications/BlockStmUninitialized b/core/codegen/javagen/src/test/resources/specifications/BlockStmUninitialized similarity index 100% rename from core/codegen/src/test/resources/specifications/BlockStmUninitialized rename to core/codegen/javagen/src/test/resources/specifications/BlockStmUninitialized diff --git a/core/codegen/src/test/resources/specifications/BlockStmUninitialized.result b/core/codegen/javagen/src/test/resources/specifications/BlockStmUninitialized.result similarity index 100% rename from core/codegen/src/test/resources/specifications/BlockStmUninitialized.result rename to core/codegen/javagen/src/test/resources/specifications/BlockStmUninitialized.result diff --git a/core/codegen/src/test/resources/specifications/CallObjectStmReturn b/core/codegen/javagen/src/test/resources/specifications/CallObjectStmReturn similarity index 100% rename from core/codegen/src/test/resources/specifications/CallObjectStmReturn rename to core/codegen/javagen/src/test/resources/specifications/CallObjectStmReturn diff --git a/core/codegen/src/test/resources/specifications/CallObjectStmReturn.result b/core/codegen/javagen/src/test/resources/specifications/CallObjectStmReturn.result similarity index 100% rename from core/codegen/src/test/resources/specifications/CallObjectStmReturn.result rename to core/codegen/javagen/src/test/resources/specifications/CallObjectStmReturn.result diff --git a/core/codegen/src/test/resources/specifications/CallStm b/core/codegen/javagen/src/test/resources/specifications/CallStm similarity index 100% rename from core/codegen/src/test/resources/specifications/CallStm rename to core/codegen/javagen/src/test/resources/specifications/CallStm diff --git a/core/codegen/src/test/resources/specifications/CallStm.result b/core/codegen/javagen/src/test/resources/specifications/CallStm.result similarity index 100% rename from core/codegen/src/test/resources/specifications/CallStm.result rename to core/codegen/javagen/src/test/resources/specifications/CallStm.result diff --git a/core/codegen/src/test/resources/specifications/CallStms b/core/codegen/javagen/src/test/resources/specifications/CallStms similarity index 100% rename from core/codegen/src/test/resources/specifications/CallStms rename to core/codegen/javagen/src/test/resources/specifications/CallStms diff --git a/core/codegen/src/test/resources/specifications/CallStms.result b/core/codegen/javagen/src/test/resources/specifications/CallStms.result similarity index 100% rename from core/codegen/src/test/resources/specifications/CallStms.result rename to core/codegen/javagen/src/test/resources/specifications/CallStms.result diff --git a/core/codegen/src/test/resources/specifications/CallStmsDeadCode b/core/codegen/javagen/src/test/resources/specifications/CallStmsDeadCode similarity index 100% rename from core/codegen/src/test/resources/specifications/CallStmsDeadCode rename to core/codegen/javagen/src/test/resources/specifications/CallStmsDeadCode diff --git a/core/codegen/src/test/resources/specifications/CallStmsDeadCode.result b/core/codegen/javagen/src/test/resources/specifications/CallStmsDeadCode.result similarity index 100% rename from core/codegen/src/test/resources/specifications/CallStmsDeadCode.result rename to core/codegen/javagen/src/test/resources/specifications/CallStmsDeadCode.result diff --git a/core/codegen/src/test/resources/specifications/ClassComparison b/core/codegen/javagen/src/test/resources/specifications/ClassComparison similarity index 100% rename from core/codegen/src/test/resources/specifications/ClassComparison rename to core/codegen/javagen/src/test/resources/specifications/ClassComparison diff --git a/core/codegen/src/test/resources/specifications/ClassComparison.result b/core/codegen/javagen/src/test/resources/specifications/ClassComparison.result similarity index 100% rename from core/codegen/src/test/resources/specifications/ClassComparison.result rename to core/codegen/javagen/src/test/resources/specifications/ClassComparison.result diff --git a/core/codegen/src/test/resources/specifications/ConcMechanismsDoNotGenerate b/core/codegen/javagen/src/test/resources/specifications/ConcMechanismsDoNotGenerate similarity index 100% rename from core/codegen/src/test/resources/specifications/ConcMechanismsDoNotGenerate rename to core/codegen/javagen/src/test/resources/specifications/ConcMechanismsDoNotGenerate diff --git a/core/codegen/src/test/resources/specifications/ConcMechanismsDoNotGenerate.result b/core/codegen/javagen/src/test/resources/specifications/ConcMechanismsDoNotGenerate.result similarity index 100% rename from core/codegen/src/test/resources/specifications/ConcMechanismsDoNotGenerate.result rename to core/codegen/javagen/src/test/resources/specifications/ConcMechanismsDoNotGenerate.result diff --git a/core/codegen/src/test/resources/specifications/ConstructorDefault b/core/codegen/javagen/src/test/resources/specifications/ConstructorDefault similarity index 100% rename from core/codegen/src/test/resources/specifications/ConstructorDefault rename to core/codegen/javagen/src/test/resources/specifications/ConstructorDefault diff --git a/core/codegen/src/test/resources/specifications/ConstructorDefault.result b/core/codegen/javagen/src/test/resources/specifications/ConstructorDefault.result similarity index 100% rename from core/codegen/src/test/resources/specifications/ConstructorDefault.result rename to core/codegen/javagen/src/test/resources/specifications/ConstructorDefault.result diff --git a/core/codegen/src/test/resources/specifications/ElemsTypeInference b/core/codegen/javagen/src/test/resources/specifications/ElemsTypeInference similarity index 100% rename from core/codegen/src/test/resources/specifications/ElemsTypeInference rename to core/codegen/javagen/src/test/resources/specifications/ElemsTypeInference diff --git a/core/codegen/src/test/resources/specifications/ElemsTypeInference.result b/core/codegen/javagen/src/test/resources/specifications/ElemsTypeInference.result similarity index 100% rename from core/codegen/src/test/resources/specifications/ElemsTypeInference.result rename to core/codegen/javagen/src/test/resources/specifications/ElemsTypeInference.result diff --git a/core/codegen/src/test/resources/specifications/Employee b/core/codegen/javagen/src/test/resources/specifications/Employee similarity index 100% rename from core/codegen/src/test/resources/specifications/Employee rename to core/codegen/javagen/src/test/resources/specifications/Employee diff --git a/core/codegen/src/test/resources/specifications/Employee.result b/core/codegen/javagen/src/test/resources/specifications/Employee.result similarity index 100% rename from core/codegen/src/test/resources/specifications/Employee.result rename to core/codegen/javagen/src/test/resources/specifications/Employee.result diff --git a/core/codegen/src/test/resources/specifications/ErrorStm b/core/codegen/javagen/src/test/resources/specifications/ErrorStm similarity index 100% rename from core/codegen/src/test/resources/specifications/ErrorStm rename to core/codegen/javagen/src/test/resources/specifications/ErrorStm diff --git a/core/codegen/src/test/resources/specifications/ErrorStm.result b/core/codegen/javagen/src/test/resources/specifications/ErrorStm.result similarity index 100% rename from core/codegen/src/test/resources/specifications/ErrorStm.result rename to core/codegen/javagen/src/test/resources/specifications/ErrorStm.result diff --git a/core/codegen/src/test/resources/specifications/FloorAssignment b/core/codegen/javagen/src/test/resources/specifications/FloorAssignment similarity index 100% rename from core/codegen/src/test/resources/specifications/FloorAssignment rename to core/codegen/javagen/src/test/resources/specifications/FloorAssignment diff --git a/core/codegen/src/test/resources/specifications/FloorAssignment.result b/core/codegen/javagen/src/test/resources/specifications/FloorAssignment.result similarity index 100% rename from core/codegen/src/test/resources/specifications/FloorAssignment.result rename to core/codegen/javagen/src/test/resources/specifications/FloorAssignment.result diff --git a/core/codegen/src/test/resources/specifications/ForAllSeqLoop b/core/codegen/javagen/src/test/resources/specifications/ForAllSeqLoop similarity index 100% rename from core/codegen/src/test/resources/specifications/ForAllSeqLoop rename to core/codegen/javagen/src/test/resources/specifications/ForAllSeqLoop diff --git a/core/codegen/src/test/resources/specifications/ForAllSeqLoop.result b/core/codegen/javagen/src/test/resources/specifications/ForAllSeqLoop.result similarity index 100% rename from core/codegen/src/test/resources/specifications/ForAllSeqLoop.result rename to core/codegen/javagen/src/test/resources/specifications/ForAllSeqLoop.result diff --git a/core/codegen/src/test/resources/specifications/ForAllSetLoop b/core/codegen/javagen/src/test/resources/specifications/ForAllSetLoop similarity index 100% rename from core/codegen/src/test/resources/specifications/ForAllSetLoop rename to core/codegen/javagen/src/test/resources/specifications/ForAllSetLoop diff --git a/core/codegen/src/test/resources/specifications/ForAllSetLoop.result b/core/codegen/javagen/src/test/resources/specifications/ForAllSetLoop.result similarity index 100% rename from core/codegen/src/test/resources/specifications/ForAllSetLoop.result rename to core/codegen/javagen/src/test/resources/specifications/ForAllSetLoop.result diff --git a/core/codegen/src/test/resources/specifications/ForIndexCorner b/core/codegen/javagen/src/test/resources/specifications/ForIndexCorner similarity index 100% rename from core/codegen/src/test/resources/specifications/ForIndexCorner rename to core/codegen/javagen/src/test/resources/specifications/ForIndexCorner diff --git a/core/codegen/src/test/resources/specifications/ForIndexCorner.result b/core/codegen/javagen/src/test/resources/specifications/ForIndexCorner.result similarity index 100% rename from core/codegen/src/test/resources/specifications/ForIndexCorner.result rename to core/codegen/javagen/src/test/resources/specifications/ForIndexCorner.result diff --git a/core/codegen/src/test/resources/specifications/ForIndexStm b/core/codegen/javagen/src/test/resources/specifications/ForIndexStm similarity index 100% rename from core/codegen/src/test/resources/specifications/ForIndexStm rename to core/codegen/javagen/src/test/resources/specifications/ForIndexStm diff --git a/core/codegen/src/test/resources/specifications/ForIndexStm.result b/core/codegen/javagen/src/test/resources/specifications/ForIndexStm.result similarity index 100% rename from core/codegen/src/test/resources/specifications/ForIndexStm.result rename to core/codegen/javagen/src/test/resources/specifications/ForIndexStm.result diff --git a/core/codegen/src/test/resources/specifications/ForIndexStmSimple b/core/codegen/javagen/src/test/resources/specifications/ForIndexStmSimple similarity index 100% rename from core/codegen/src/test/resources/specifications/ForIndexStmSimple rename to core/codegen/javagen/src/test/resources/specifications/ForIndexStmSimple diff --git a/core/codegen/src/test/resources/specifications/ForIndexStmSimple.result b/core/codegen/javagen/src/test/resources/specifications/ForIndexStmSimple.result similarity index 100% rename from core/codegen/src/test/resources/specifications/ForIndexStmSimple.result rename to core/codegen/javagen/src/test/resources/specifications/ForIndexStmSimple.result diff --git a/core/codegen/src/test/resources/specifications/Functions b/core/codegen/javagen/src/test/resources/specifications/Functions similarity index 100% rename from core/codegen/src/test/resources/specifications/Functions rename to core/codegen/javagen/src/test/resources/specifications/Functions diff --git a/core/codegen/src/test/resources/specifications/Functions.result b/core/codegen/javagen/src/test/resources/specifications/Functions.result similarity index 100% rename from core/codegen/src/test/resources/specifications/Functions.result rename to core/codegen/javagen/src/test/resources/specifications/Functions.result diff --git a/core/codegen/src/test/resources/specifications/IfExp b/core/codegen/javagen/src/test/resources/specifications/IfExp similarity index 100% rename from core/codegen/src/test/resources/specifications/IfExp rename to core/codegen/javagen/src/test/resources/specifications/IfExp diff --git a/core/codegen/src/test/resources/specifications/IfExp.result b/core/codegen/javagen/src/test/resources/specifications/IfExp.result similarity index 100% rename from core/codegen/src/test/resources/specifications/IfExp.result rename to core/codegen/javagen/src/test/resources/specifications/IfExp.result diff --git a/core/codegen/src/test/resources/specifications/InstanceOf b/core/codegen/javagen/src/test/resources/specifications/InstanceOf similarity index 100% rename from core/codegen/src/test/resources/specifications/InstanceOf rename to core/codegen/javagen/src/test/resources/specifications/InstanceOf diff --git a/core/codegen/src/test/resources/specifications/InstanceOf.result b/core/codegen/javagen/src/test/resources/specifications/InstanceOf.result similarity index 100% rename from core/codegen/src/test/resources/specifications/InstanceOf.result rename to core/codegen/javagen/src/test/resources/specifications/InstanceOf.result diff --git a/core/codegen/src/test/resources/specifications/LetDefExp b/core/codegen/javagen/src/test/resources/specifications/LetDefExp similarity index 100% rename from core/codegen/src/test/resources/specifications/LetDefExp rename to core/codegen/javagen/src/test/resources/specifications/LetDefExp diff --git a/core/codegen/src/test/resources/specifications/LetDefExp.result b/core/codegen/javagen/src/test/resources/specifications/LetDefExp.result similarity index 100% rename from core/codegen/src/test/resources/specifications/LetDefExp.result rename to core/codegen/javagen/src/test/resources/specifications/LetDefExp.result diff --git a/core/codegen/src/test/resources/specifications/MapApplyClone b/core/codegen/javagen/src/test/resources/specifications/MapApplyClone similarity index 100% rename from core/codegen/src/test/resources/specifications/MapApplyClone rename to core/codegen/javagen/src/test/resources/specifications/MapApplyClone diff --git a/core/codegen/src/test/resources/specifications/MapApplyClone.result b/core/codegen/javagen/src/test/resources/specifications/MapApplyClone.result similarity index 100% rename from core/codegen/src/test/resources/specifications/MapApplyClone.result rename to core/codegen/javagen/src/test/resources/specifications/MapApplyClone.result diff --git a/core/codegen/src/test/resources/specifications/MapComparisonClone b/core/codegen/javagen/src/test/resources/specifications/MapComparisonClone similarity index 100% rename from core/codegen/src/test/resources/specifications/MapComparisonClone rename to core/codegen/javagen/src/test/resources/specifications/MapComparisonClone diff --git a/core/codegen/src/test/resources/specifications/MapComparisonClone.result b/core/codegen/javagen/src/test/resources/specifications/MapComparisonClone.result similarity index 100% rename from core/codegen/src/test/resources/specifications/MapComparisonClone.result rename to core/codegen/javagen/src/test/resources/specifications/MapComparisonClone.result diff --git a/core/codegen/src/test/resources/specifications/MapDomClone b/core/codegen/javagen/src/test/resources/specifications/MapDomClone similarity index 100% rename from core/codegen/src/test/resources/specifications/MapDomClone rename to core/codegen/javagen/src/test/resources/specifications/MapDomClone diff --git a/core/codegen/src/test/resources/specifications/MapDomClone.result b/core/codegen/javagen/src/test/resources/specifications/MapDomClone.result similarity index 100% rename from core/codegen/src/test/resources/specifications/MapDomClone.result rename to core/codegen/javagen/src/test/resources/specifications/MapDomClone.result diff --git a/core/codegen/src/test/resources/specifications/MapDomResByClone b/core/codegen/javagen/src/test/resources/specifications/MapDomResByClone similarity index 100% rename from core/codegen/src/test/resources/specifications/MapDomResByClone rename to core/codegen/javagen/src/test/resources/specifications/MapDomResByClone diff --git a/core/codegen/src/test/resources/specifications/MapDomResByClone.result b/core/codegen/javagen/src/test/resources/specifications/MapDomResByClone.result similarity index 100% rename from core/codegen/src/test/resources/specifications/MapDomResByClone.result rename to core/codegen/javagen/src/test/resources/specifications/MapDomResByClone.result diff --git a/core/codegen/src/test/resources/specifications/MapDomResToClone b/core/codegen/javagen/src/test/resources/specifications/MapDomResToClone similarity index 100% rename from core/codegen/src/test/resources/specifications/MapDomResToClone rename to core/codegen/javagen/src/test/resources/specifications/MapDomResToClone diff --git a/core/codegen/src/test/resources/specifications/MapDomResToClone.result b/core/codegen/javagen/src/test/resources/specifications/MapDomResToClone.result similarity index 100% rename from core/codegen/src/test/resources/specifications/MapDomResToClone.result rename to core/codegen/javagen/src/test/resources/specifications/MapDomResToClone.result diff --git a/core/codegen/src/test/resources/specifications/MapInverseClone b/core/codegen/javagen/src/test/resources/specifications/MapInverseClone similarity index 100% rename from core/codegen/src/test/resources/specifications/MapInverseClone rename to core/codegen/javagen/src/test/resources/specifications/MapInverseClone diff --git a/core/codegen/src/test/resources/specifications/MapInverseClone.result b/core/codegen/javagen/src/test/resources/specifications/MapInverseClone.result similarity index 100% rename from core/codegen/src/test/resources/specifications/MapInverseClone.result rename to core/codegen/javagen/src/test/resources/specifications/MapInverseClone.result diff --git a/core/codegen/src/test/resources/specifications/MapMapUnionClone b/core/codegen/javagen/src/test/resources/specifications/MapMapUnionClone similarity index 100% rename from core/codegen/src/test/resources/specifications/MapMapUnionClone rename to core/codegen/javagen/src/test/resources/specifications/MapMapUnionClone diff --git a/core/codegen/src/test/resources/specifications/MapMapUnionClone.result b/core/codegen/javagen/src/test/resources/specifications/MapMapUnionClone.result similarity index 100% rename from core/codegen/src/test/resources/specifications/MapMapUnionClone.result rename to core/codegen/javagen/src/test/resources/specifications/MapMapUnionClone.result diff --git a/core/codegen/src/test/resources/specifications/MapMergeClone b/core/codegen/javagen/src/test/resources/specifications/MapMergeClone similarity index 100% rename from core/codegen/src/test/resources/specifications/MapMergeClone rename to core/codegen/javagen/src/test/resources/specifications/MapMergeClone diff --git a/core/codegen/src/test/resources/specifications/MapMergeClone.result b/core/codegen/javagen/src/test/resources/specifications/MapMergeClone.result similarity index 100% rename from core/codegen/src/test/resources/specifications/MapMergeClone.result rename to core/codegen/javagen/src/test/resources/specifications/MapMergeClone.result diff --git a/core/codegen/src/test/resources/specifications/MapOverrideClone b/core/codegen/javagen/src/test/resources/specifications/MapOverrideClone similarity index 100% rename from core/codegen/src/test/resources/specifications/MapOverrideClone rename to core/codegen/javagen/src/test/resources/specifications/MapOverrideClone diff --git a/core/codegen/src/test/resources/specifications/MapOverrideClone.result b/core/codegen/javagen/src/test/resources/specifications/MapOverrideClone.result similarity index 100% rename from core/codegen/src/test/resources/specifications/MapOverrideClone.result rename to core/codegen/javagen/src/test/resources/specifications/MapOverrideClone.result diff --git a/core/codegen/src/test/resources/specifications/MapPhoneBook b/core/codegen/javagen/src/test/resources/specifications/MapPhoneBook similarity index 100% rename from core/codegen/src/test/resources/specifications/MapPhoneBook rename to core/codegen/javagen/src/test/resources/specifications/MapPhoneBook diff --git a/core/codegen/src/test/resources/specifications/MapPhoneBook.result b/core/codegen/javagen/src/test/resources/specifications/MapPhoneBook.result similarity index 100% rename from core/codegen/src/test/resources/specifications/MapPhoneBook.result rename to core/codegen/javagen/src/test/resources/specifications/MapPhoneBook.result diff --git a/core/codegen/src/test/resources/specifications/MapRangeClone b/core/codegen/javagen/src/test/resources/specifications/MapRangeClone similarity index 100% rename from core/codegen/src/test/resources/specifications/MapRangeClone rename to core/codegen/javagen/src/test/resources/specifications/MapRangeClone diff --git a/core/codegen/src/test/resources/specifications/MapRangeClone.result b/core/codegen/javagen/src/test/resources/specifications/MapRangeClone.result similarity index 100% rename from core/codegen/src/test/resources/specifications/MapRangeClone.result rename to core/codegen/javagen/src/test/resources/specifications/MapRangeClone.result diff --git a/core/codegen/src/test/resources/specifications/MapRangeResByClone b/core/codegen/javagen/src/test/resources/specifications/MapRangeResByClone similarity index 100% rename from core/codegen/src/test/resources/specifications/MapRangeResByClone rename to core/codegen/javagen/src/test/resources/specifications/MapRangeResByClone diff --git a/core/codegen/src/test/resources/specifications/MapRangeResByClone.result b/core/codegen/javagen/src/test/resources/specifications/MapRangeResByClone.result similarity index 100% rename from core/codegen/src/test/resources/specifications/MapRangeResByClone.result rename to core/codegen/javagen/src/test/resources/specifications/MapRangeResByClone.result diff --git a/core/codegen/src/test/resources/specifications/MapRangeResToClone b/core/codegen/javagen/src/test/resources/specifications/MapRangeResToClone similarity index 100% rename from core/codegen/src/test/resources/specifications/MapRangeResToClone rename to core/codegen/javagen/src/test/resources/specifications/MapRangeResToClone diff --git a/core/codegen/src/test/resources/specifications/MapRangeResToClone.result b/core/codegen/javagen/src/test/resources/specifications/MapRangeResToClone.result similarity index 100% rename from core/codegen/src/test/resources/specifications/MapRangeResToClone.result rename to core/codegen/javagen/src/test/resources/specifications/MapRangeResToClone.result diff --git a/core/codegen/src/test/resources/specifications/MathLib b/core/codegen/javagen/src/test/resources/specifications/MathLib similarity index 100% rename from core/codegen/src/test/resources/specifications/MathLib rename to core/codegen/javagen/src/test/resources/specifications/MathLib diff --git a/core/codegen/src/test/resources/specifications/MathLib.result b/core/codegen/javagen/src/test/resources/specifications/MathLib.result similarity index 100% rename from core/codegen/src/test/resources/specifications/MathLib.result rename to core/codegen/javagen/src/test/resources/specifications/MathLib.result diff --git a/core/codegen/src/test/resources/specifications/NameViolationClassName b/core/codegen/javagen/src/test/resources/specifications/NameViolationClassName similarity index 100% rename from core/codegen/src/test/resources/specifications/NameViolationClassName rename to core/codegen/javagen/src/test/resources/specifications/NameViolationClassName diff --git a/core/codegen/src/test/resources/specifications/NameViolationClassName.result b/core/codegen/javagen/src/test/resources/specifications/NameViolationClassName.result similarity index 100% rename from core/codegen/src/test/resources/specifications/NameViolationClassName.result rename to core/codegen/javagen/src/test/resources/specifications/NameViolationClassName.result diff --git a/core/codegen/src/test/resources/specifications/NameViolationsJavakeyword b/core/codegen/javagen/src/test/resources/specifications/NameViolationsJavakeyword similarity index 100% rename from core/codegen/src/test/resources/specifications/NameViolationsJavakeyword rename to core/codegen/javagen/src/test/resources/specifications/NameViolationsJavakeyword diff --git a/core/codegen/src/test/resources/specifications/NameViolationsJavakeyword.result b/core/codegen/javagen/src/test/resources/specifications/NameViolationsJavakeyword.result similarity index 100% rename from core/codegen/src/test/resources/specifications/NameViolationsJavakeyword.result rename to core/codegen/javagen/src/test/resources/specifications/NameViolationsJavakeyword.result diff --git a/core/codegen/src/test/resources/specifications/NamedInvariantType b/core/codegen/javagen/src/test/resources/specifications/NamedInvariantType similarity index 100% rename from core/codegen/src/test/resources/specifications/NamedInvariantType rename to core/codegen/javagen/src/test/resources/specifications/NamedInvariantType diff --git a/core/codegen/src/test/resources/specifications/NamedInvariantType.result b/core/codegen/javagen/src/test/resources/specifications/NamedInvariantType.result similarity index 100% rename from core/codegen/src/test/resources/specifications/NamedInvariantType.result rename to core/codegen/javagen/src/test/resources/specifications/NamedInvariantType.result diff --git a/core/codegen/src/test/resources/specifications/NotYetSpecified b/core/codegen/javagen/src/test/resources/specifications/NotYetSpecified similarity index 100% rename from core/codegen/src/test/resources/specifications/NotYetSpecified rename to core/codegen/javagen/src/test/resources/specifications/NotYetSpecified diff --git a/core/codegen/src/test/resources/specifications/NotYetSpecified.result b/core/codegen/javagen/src/test/resources/specifications/NotYetSpecified.result similarity index 100% rename from core/codegen/src/test/resources/specifications/NotYetSpecified.result rename to core/codegen/javagen/src/test/resources/specifications/NotYetSpecified.result diff --git a/core/codegen/src/test/resources/specifications/ObjectDesignatorField b/core/codegen/javagen/src/test/resources/specifications/ObjectDesignatorField similarity index 100% rename from core/codegen/src/test/resources/specifications/ObjectDesignatorField rename to core/codegen/javagen/src/test/resources/specifications/ObjectDesignatorField diff --git a/core/codegen/src/test/resources/specifications/ObjectDesignatorField.result b/core/codegen/javagen/src/test/resources/specifications/ObjectDesignatorField.result similarity index 100% rename from core/codegen/src/test/resources/specifications/ObjectDesignatorField.result rename to core/codegen/javagen/src/test/resources/specifications/ObjectDesignatorField.result diff --git a/core/codegen/src/test/resources/specifications/ObjectDesignatorIdentifier b/core/codegen/javagen/src/test/resources/specifications/ObjectDesignatorIdentifier similarity index 100% rename from core/codegen/src/test/resources/specifications/ObjectDesignatorIdentifier rename to core/codegen/javagen/src/test/resources/specifications/ObjectDesignatorIdentifier diff --git a/core/codegen/src/test/resources/specifications/ObjectDesignatorIdentifier.result b/core/codegen/javagen/src/test/resources/specifications/ObjectDesignatorIdentifier.result similarity index 100% rename from core/codegen/src/test/resources/specifications/ObjectDesignatorIdentifier.result rename to core/codegen/javagen/src/test/resources/specifications/ObjectDesignatorIdentifier.result diff --git a/core/codegen/src/test/resources/specifications/ObjectDesignatorNew b/core/codegen/javagen/src/test/resources/specifications/ObjectDesignatorNew similarity index 100% rename from core/codegen/src/test/resources/specifications/ObjectDesignatorNew rename to core/codegen/javagen/src/test/resources/specifications/ObjectDesignatorNew diff --git a/core/codegen/src/test/resources/specifications/ObjectDesignatorNew.result b/core/codegen/javagen/src/test/resources/specifications/ObjectDesignatorNew.result similarity index 100% rename from core/codegen/src/test/resources/specifications/ObjectDesignatorNew.result rename to core/codegen/javagen/src/test/resources/specifications/ObjectDesignatorNew.result diff --git a/core/codegen/src/test/resources/specifications/ObjectDesignatorSelf b/core/codegen/javagen/src/test/resources/specifications/ObjectDesignatorSelf similarity index 100% rename from core/codegen/src/test/resources/specifications/ObjectDesignatorSelf rename to core/codegen/javagen/src/test/resources/specifications/ObjectDesignatorSelf diff --git a/core/codegen/src/test/resources/specifications/ObjectDesignatorSelf.result b/core/codegen/javagen/src/test/resources/specifications/ObjectDesignatorSelf.result similarity index 100% rename from core/codegen/src/test/resources/specifications/ObjectDesignatorSelf.result rename to core/codegen/javagen/src/test/resources/specifications/ObjectDesignatorSelf.result diff --git a/core/codegen/src/test/resources/specifications/OperationReturnsValueType b/core/codegen/javagen/src/test/resources/specifications/OperationReturnsValueType similarity index 100% rename from core/codegen/src/test/resources/specifications/OperationReturnsValueType rename to core/codegen/javagen/src/test/resources/specifications/OperationReturnsValueType diff --git a/core/codegen/src/test/resources/specifications/OperationReturnsValueType.result b/core/codegen/javagen/src/test/resources/specifications/OperationReturnsValueType.result similarity index 100% rename from core/codegen/src/test/resources/specifications/OperationReturnsValueType.result rename to core/codegen/javagen/src/test/resources/specifications/OperationReturnsValueType.result diff --git a/core/codegen/src/test/resources/specifications/OptionalType b/core/codegen/javagen/src/test/resources/specifications/OptionalType similarity index 100% rename from core/codegen/src/test/resources/specifications/OptionalType rename to core/codegen/javagen/src/test/resources/specifications/OptionalType diff --git a/core/codegen/src/test/resources/specifications/OptionalType.result b/core/codegen/javagen/src/test/resources/specifications/OptionalType.result similarity index 100% rename from core/codegen/src/test/resources/specifications/OptionalType.result rename to core/codegen/javagen/src/test/resources/specifications/OptionalType.result diff --git a/core/codegen/src/test/resources/specifications/RecordComparison b/core/codegen/javagen/src/test/resources/specifications/RecordComparison similarity index 100% rename from core/codegen/src/test/resources/specifications/RecordComparison rename to core/codegen/javagen/src/test/resources/specifications/RecordComparison diff --git a/core/codegen/src/test/resources/specifications/RecordComparison.result b/core/codegen/javagen/src/test/resources/specifications/RecordComparison.result similarity index 100% rename from core/codegen/src/test/resources/specifications/RecordComparison.result rename to core/codegen/javagen/src/test/resources/specifications/RecordComparison.result diff --git a/core/codegen/src/test/resources/specifications/RecordCreation b/core/codegen/javagen/src/test/resources/specifications/RecordCreation similarity index 100% rename from core/codegen/src/test/resources/specifications/RecordCreation rename to core/codegen/javagen/src/test/resources/specifications/RecordCreation diff --git a/core/codegen/src/test/resources/specifications/RecordCreation.result b/core/codegen/javagen/src/test/resources/specifications/RecordCreation.result similarity index 100% rename from core/codegen/src/test/resources/specifications/RecordCreation.result rename to core/codegen/javagen/src/test/resources/specifications/RecordCreation.result diff --git a/core/codegen/src/test/resources/specifications/RecordCycle b/core/codegen/javagen/src/test/resources/specifications/RecordCycle similarity index 100% rename from core/codegen/src/test/resources/specifications/RecordCycle rename to core/codegen/javagen/src/test/resources/specifications/RecordCycle diff --git a/core/codegen/src/test/resources/specifications/RecordCycle.result b/core/codegen/javagen/src/test/resources/specifications/RecordCycle.result similarity index 100% rename from core/codegen/src/test/resources/specifications/RecordCycle.result rename to core/codegen/javagen/src/test/resources/specifications/RecordCycle.result diff --git a/core/codegen/src/test/resources/specifications/RecordDecls b/core/codegen/javagen/src/test/resources/specifications/RecordDecls similarity index 100% rename from core/codegen/src/test/resources/specifications/RecordDecls rename to core/codegen/javagen/src/test/resources/specifications/RecordDecls diff --git a/core/codegen/src/test/resources/specifications/RecordDecls.result b/core/codegen/javagen/src/test/resources/specifications/RecordDecls.result similarity index 100% rename from core/codegen/src/test/resources/specifications/RecordDecls.result rename to core/codegen/javagen/src/test/resources/specifications/RecordDecls.result diff --git a/core/codegen/src/test/resources/specifications/RecordNesting b/core/codegen/javagen/src/test/resources/specifications/RecordNesting similarity index 100% rename from core/codegen/src/test/resources/specifications/RecordNesting rename to core/codegen/javagen/src/test/resources/specifications/RecordNesting diff --git a/core/codegen/src/test/resources/specifications/RecordNesting.result b/core/codegen/javagen/src/test/resources/specifications/RecordNesting.result similarity index 100% rename from core/codegen/src/test/resources/specifications/RecordNesting.result rename to core/codegen/javagen/src/test/resources/specifications/RecordNesting.result diff --git a/core/codegen/src/test/resources/specifications/RecordPrimitiveFields b/core/codegen/javagen/src/test/resources/specifications/RecordPrimitiveFields similarity index 100% rename from core/codegen/src/test/resources/specifications/RecordPrimitiveFields rename to core/codegen/javagen/src/test/resources/specifications/RecordPrimitiveFields diff --git a/core/codegen/src/test/resources/specifications/RecordPrimitiveFields.result b/core/codegen/javagen/src/test/resources/specifications/RecordPrimitiveFields.result similarity index 100% rename from core/codegen/src/test/resources/specifications/RecordPrimitiveFields.result rename to core/codegen/javagen/src/test/resources/specifications/RecordPrimitiveFields.result diff --git a/core/codegen/src/test/resources/specifications/RecordUsage b/core/codegen/javagen/src/test/resources/specifications/RecordUsage similarity index 100% rename from core/codegen/src/test/resources/specifications/RecordUsage rename to core/codegen/javagen/src/test/resources/specifications/RecordUsage diff --git a/core/codegen/src/test/resources/specifications/RecordUsage.result b/core/codegen/javagen/src/test/resources/specifications/RecordUsage.result similarity index 100% rename from core/codegen/src/test/resources/specifications/RecordUsage.result rename to core/codegen/javagen/src/test/resources/specifications/RecordUsage.result diff --git a/core/codegen/src/test/resources/specifications/RecordUsageAcrossClass b/core/codegen/javagen/src/test/resources/specifications/RecordUsageAcrossClass similarity index 100% rename from core/codegen/src/test/resources/specifications/RecordUsageAcrossClass rename to core/codegen/javagen/src/test/resources/specifications/RecordUsageAcrossClass diff --git a/core/codegen/src/test/resources/specifications/RecordUsageAcrossClass.result b/core/codegen/javagen/src/test/resources/specifications/RecordUsageAcrossClass.result similarity index 100% rename from core/codegen/src/test/resources/specifications/RecordUsageAcrossClass.result rename to core/codegen/javagen/src/test/resources/specifications/RecordUsageAcrossClass.result diff --git a/core/codegen/src/test/resources/specifications/ReturnVoid b/core/codegen/javagen/src/test/resources/specifications/ReturnVoid similarity index 100% rename from core/codegen/src/test/resources/specifications/ReturnVoid rename to core/codegen/javagen/src/test/resources/specifications/ReturnVoid diff --git a/core/codegen/src/test/resources/specifications/ReturnVoid.result b/core/codegen/javagen/src/test/resources/specifications/ReturnVoid.result similarity index 100% rename from core/codegen/src/test/resources/specifications/ReturnVoid.result rename to core/codegen/javagen/src/test/resources/specifications/ReturnVoid.result diff --git a/core/codegen/src/test/resources/specifications/SeqDistConcOpResult b/core/codegen/javagen/src/test/resources/specifications/SeqDistConcOpResult similarity index 100% rename from core/codegen/src/test/resources/specifications/SeqDistConcOpResult rename to core/codegen/javagen/src/test/resources/specifications/SeqDistConcOpResult diff --git a/core/codegen/src/test/resources/specifications/SeqDistConcOpResult.result b/core/codegen/javagen/src/test/resources/specifications/SeqDistConcOpResult.result similarity index 100% rename from core/codegen/src/test/resources/specifications/SeqDistConcOpResult.result rename to core/codegen/javagen/src/test/resources/specifications/SeqDistConcOpResult.result diff --git a/core/codegen/src/test/resources/specifications/SeqDistConcatOperationCalls b/core/codegen/javagen/src/test/resources/specifications/SeqDistConcatOperationCalls similarity index 100% rename from core/codegen/src/test/resources/specifications/SeqDistConcatOperationCalls rename to core/codegen/javagen/src/test/resources/specifications/SeqDistConcatOperationCalls diff --git a/core/codegen/src/test/resources/specifications/SeqDistConcatOperationCalls.result b/core/codegen/javagen/src/test/resources/specifications/SeqDistConcatOperationCalls.result similarity index 100% rename from core/codegen/src/test/resources/specifications/SeqDistConcatOperationCalls.result rename to core/codegen/javagen/src/test/resources/specifications/SeqDistConcatOperationCalls.result diff --git a/core/codegen/src/test/resources/specifications/SeqModCloning b/core/codegen/javagen/src/test/resources/specifications/SeqModCloning similarity index 100% rename from core/codegen/src/test/resources/specifications/SeqModCloning rename to core/codegen/javagen/src/test/resources/specifications/SeqModCloning diff --git a/core/codegen/src/test/resources/specifications/SeqModCloning.result b/core/codegen/javagen/src/test/resources/specifications/SeqModCloning.result similarity index 100% rename from core/codegen/src/test/resources/specifications/SeqModCloning.result rename to core/codegen/javagen/src/test/resources/specifications/SeqModCloning.result diff --git a/core/codegen/src/test/resources/specifications/SeqNoteBook b/core/codegen/javagen/src/test/resources/specifications/SeqNoteBook similarity index 100% rename from core/codegen/src/test/resources/specifications/SeqNoteBook rename to core/codegen/javagen/src/test/resources/specifications/SeqNoteBook diff --git a/core/codegen/src/test/resources/specifications/SeqNoteBook.result b/core/codegen/javagen/src/test/resources/specifications/SeqNoteBook.result similarity index 100% rename from core/codegen/src/test/resources/specifications/SeqNoteBook.result rename to core/codegen/javagen/src/test/resources/specifications/SeqNoteBook.result diff --git a/core/codegen/src/test/resources/specifications/SeqReverseBasicTypes b/core/codegen/javagen/src/test/resources/specifications/SeqReverseBasicTypes similarity index 100% rename from core/codegen/src/test/resources/specifications/SeqReverseBasicTypes rename to core/codegen/javagen/src/test/resources/specifications/SeqReverseBasicTypes diff --git a/core/codegen/src/test/resources/specifications/SeqReverseBasicTypes.result b/core/codegen/javagen/src/test/resources/specifications/SeqReverseBasicTypes.result similarity index 100% rename from core/codegen/src/test/resources/specifications/SeqReverseBasicTypes.result rename to core/codegen/javagen/src/test/resources/specifications/SeqReverseBasicTypes.result diff --git a/core/codegen/src/test/resources/specifications/SetBag b/core/codegen/javagen/src/test/resources/specifications/SetBag similarity index 100% rename from core/codegen/src/test/resources/specifications/SetBag rename to core/codegen/javagen/src/test/resources/specifications/SetBag diff --git a/core/codegen/src/test/resources/specifications/SetBag.result b/core/codegen/javagen/src/test/resources/specifications/SetBag.result similarity index 100% rename from core/codegen/src/test/resources/specifications/SetBag.result rename to core/codegen/javagen/src/test/resources/specifications/SetBag.result diff --git a/core/codegen/src/test/resources/specifications/SetDiffClone b/core/codegen/javagen/src/test/resources/specifications/SetDiffClone similarity index 100% rename from core/codegen/src/test/resources/specifications/SetDiffClone rename to core/codegen/javagen/src/test/resources/specifications/SetDiffClone diff --git a/core/codegen/src/test/resources/specifications/SetDiffClone.result b/core/codegen/javagen/src/test/resources/specifications/SetDiffClone.result similarity index 100% rename from core/codegen/src/test/resources/specifications/SetDiffClone.result rename to core/codegen/javagen/src/test/resources/specifications/SetDiffClone.result diff --git a/core/codegen/src/test/resources/specifications/SetDistInterClone b/core/codegen/javagen/src/test/resources/specifications/SetDistInterClone similarity index 100% rename from core/codegen/src/test/resources/specifications/SetDistInterClone rename to core/codegen/javagen/src/test/resources/specifications/SetDistInterClone diff --git a/core/codegen/src/test/resources/specifications/SetDistInterClone.result b/core/codegen/javagen/src/test/resources/specifications/SetDistInterClone.result similarity index 100% rename from core/codegen/src/test/resources/specifications/SetDistInterClone.result rename to core/codegen/javagen/src/test/resources/specifications/SetDistInterClone.result diff --git a/core/codegen/src/test/resources/specifications/SetDistUnionClone b/core/codegen/javagen/src/test/resources/specifications/SetDistUnionClone similarity index 100% rename from core/codegen/src/test/resources/specifications/SetDistUnionClone rename to core/codegen/javagen/src/test/resources/specifications/SetDistUnionClone diff --git a/core/codegen/src/test/resources/specifications/SetDistUnionClone.result b/core/codegen/javagen/src/test/resources/specifications/SetDistUnionClone.result similarity index 100% rename from core/codegen/src/test/resources/specifications/SetDistUnionClone.result rename to core/codegen/javagen/src/test/resources/specifications/SetDistUnionClone.result diff --git a/core/codegen/src/test/resources/specifications/SetIntersectClone b/core/codegen/javagen/src/test/resources/specifications/SetIntersectClone similarity index 100% rename from core/codegen/src/test/resources/specifications/SetIntersectClone rename to core/codegen/javagen/src/test/resources/specifications/SetIntersectClone diff --git a/core/codegen/src/test/resources/specifications/SetIntersectClone.result b/core/codegen/javagen/src/test/resources/specifications/SetIntersectClone.result similarity index 100% rename from core/codegen/src/test/resources/specifications/SetIntersectClone.result rename to core/codegen/javagen/src/test/resources/specifications/SetIntersectClone.result diff --git a/core/codegen/src/test/resources/specifications/SetPowerSetClone b/core/codegen/javagen/src/test/resources/specifications/SetPowerSetClone similarity index 100% rename from core/codegen/src/test/resources/specifications/SetPowerSetClone rename to core/codegen/javagen/src/test/resources/specifications/SetPowerSetClone diff --git a/core/codegen/src/test/resources/specifications/SetPowerSetClone.result b/core/codegen/javagen/src/test/resources/specifications/SetPowerSetClone.result similarity index 100% rename from core/codegen/src/test/resources/specifications/SetPowerSetClone.result rename to core/codegen/javagen/src/test/resources/specifications/SetPowerSetClone.result diff --git a/core/codegen/src/test/resources/specifications/SetProperSubsetClone b/core/codegen/javagen/src/test/resources/specifications/SetProperSubsetClone similarity index 100% rename from core/codegen/src/test/resources/specifications/SetProperSubsetClone rename to core/codegen/javagen/src/test/resources/specifications/SetProperSubsetClone diff --git a/core/codegen/src/test/resources/specifications/SetProperSubsetClone.result b/core/codegen/javagen/src/test/resources/specifications/SetProperSubsetClone.result similarity index 100% rename from core/codegen/src/test/resources/specifications/SetProperSubsetClone.result rename to core/codegen/javagen/src/test/resources/specifications/SetProperSubsetClone.result diff --git a/core/codegen/src/test/resources/specifications/SetSubsetClone b/core/codegen/javagen/src/test/resources/specifications/SetSubsetClone similarity index 100% rename from core/codegen/src/test/resources/specifications/SetSubsetClone rename to core/codegen/javagen/src/test/resources/specifications/SetSubsetClone diff --git a/core/codegen/src/test/resources/specifications/SetSubsetClone.result b/core/codegen/javagen/src/test/resources/specifications/SetSubsetClone.result similarity index 100% rename from core/codegen/src/test/resources/specifications/SetSubsetClone.result rename to core/codegen/javagen/src/test/resources/specifications/SetSubsetClone.result diff --git a/core/codegen/src/test/resources/specifications/SetUnionCloning b/core/codegen/javagen/src/test/resources/specifications/SetUnionCloning similarity index 100% rename from core/codegen/src/test/resources/specifications/SetUnionCloning rename to core/codegen/javagen/src/test/resources/specifications/SetUnionCloning diff --git a/core/codegen/src/test/resources/specifications/SetUnionCloning.result b/core/codegen/javagen/src/test/resources/specifications/SetUnionCloning.result similarity index 100% rename from core/codegen/src/test/resources/specifications/SetUnionCloning.result rename to core/codegen/javagen/src/test/resources/specifications/SetUnionCloning.result diff --git a/core/codegen/src/test/resources/specifications/StringType b/core/codegen/javagen/src/test/resources/specifications/StringType similarity index 100% rename from core/codegen/src/test/resources/specifications/StringType rename to core/codegen/javagen/src/test/resources/specifications/StringType diff --git a/core/codegen/src/test/resources/specifications/StringType.result b/core/codegen/javagen/src/test/resources/specifications/StringType.result similarity index 100% rename from core/codegen/src/test/resources/specifications/StringType.result rename to core/codegen/javagen/src/test/resources/specifications/StringType.result diff --git a/core/codegen/src/test/resources/specifications/Strings b/core/codegen/javagen/src/test/resources/specifications/Strings similarity index 100% rename from core/codegen/src/test/resources/specifications/Strings rename to core/codegen/javagen/src/test/resources/specifications/Strings diff --git a/core/codegen/src/test/resources/specifications/Strings.result b/core/codegen/javagen/src/test/resources/specifications/Strings.result similarity index 100% rename from core/codegen/src/test/resources/specifications/Strings.result rename to core/codegen/javagen/src/test/resources/specifications/Strings.result diff --git a/core/codegen/src/test/resources/specifications/TemplateTypes b/core/codegen/javagen/src/test/resources/specifications/TemplateTypes similarity index 100% rename from core/codegen/src/test/resources/specifications/TemplateTypes rename to core/codegen/javagen/src/test/resources/specifications/TemplateTypes diff --git a/core/codegen/src/test/resources/specifications/TemplateTypes.result b/core/codegen/javagen/src/test/resources/specifications/TemplateTypes.result similarity index 100% rename from core/codegen/src/test/resources/specifications/TemplateTypes.result rename to core/codegen/javagen/src/test/resources/specifications/TemplateTypes.result diff --git a/core/codegen/src/test/resources/specifications/TupleUsage b/core/codegen/javagen/src/test/resources/specifications/TupleUsage similarity index 100% rename from core/codegen/src/test/resources/specifications/TupleUsage rename to core/codegen/javagen/src/test/resources/specifications/TupleUsage diff --git a/core/codegen/src/test/resources/specifications/TupleUsage.result b/core/codegen/javagen/src/test/resources/specifications/TupleUsage.result similarity index 100% rename from core/codegen/src/test/resources/specifications/TupleUsage.result rename to core/codegen/javagen/src/test/resources/specifications/TupleUsage.result diff --git a/core/codegen/src/test/resources/specifications/Tuples b/core/codegen/javagen/src/test/resources/specifications/Tuples similarity index 100% rename from core/codegen/src/test/resources/specifications/Tuples rename to core/codegen/javagen/src/test/resources/specifications/Tuples diff --git a/core/codegen/src/test/resources/specifications/Tuples.result b/core/codegen/javagen/src/test/resources/specifications/Tuples.result similarity index 100% rename from core/codegen/src/test/resources/specifications/Tuples.result rename to core/codegen/javagen/src/test/resources/specifications/Tuples.result diff --git a/core/codegen/src/test/resources/specifications/UnionOfQuotes b/core/codegen/javagen/src/test/resources/specifications/UnionOfQuotes similarity index 100% rename from core/codegen/src/test/resources/specifications/UnionOfQuotes rename to core/codegen/javagen/src/test/resources/specifications/UnionOfQuotes diff --git a/core/codegen/src/test/resources/specifications/UnionOfQuotes.result b/core/codegen/javagen/src/test/resources/specifications/UnionOfQuotes.result similarity index 100% rename from core/codegen/src/test/resources/specifications/UnionOfQuotes.result rename to core/codegen/javagen/src/test/resources/specifications/UnionOfQuotes.result diff --git a/core/codegen/src/test/resources/specifications/UnknownTypes b/core/codegen/javagen/src/test/resources/specifications/UnknownTypes similarity index 100% rename from core/codegen/src/test/resources/specifications/UnknownTypes rename to core/codegen/javagen/src/test/resources/specifications/UnknownTypes diff --git a/core/codegen/src/test/resources/specifications/UnknownTypes.result b/core/codegen/javagen/src/test/resources/specifications/UnknownTypes.result similarity index 100% rename from core/codegen/src/test/resources/specifications/UnknownTypes.result rename to core/codegen/javagen/src/test/resources/specifications/UnknownTypes.result diff --git a/core/codegen/src/test/resources/specifications/UnsupportedModelingConstructs b/core/codegen/javagen/src/test/resources/specifications/UnsupportedModelingConstructs similarity index 100% rename from core/codegen/src/test/resources/specifications/UnsupportedModelingConstructs rename to core/codegen/javagen/src/test/resources/specifications/UnsupportedModelingConstructs diff --git a/core/codegen/src/test/resources/specifications/UnsupportedModelingConstructs.result b/core/codegen/javagen/src/test/resources/specifications/UnsupportedModelingConstructs.result similarity index 100% rename from core/codegen/src/test/resources/specifications/UnsupportedModelingConstructs.result rename to core/codegen/javagen/src/test/resources/specifications/UnsupportedModelingConstructs.result diff --git a/core/codegen/src/test/resources/specifications/ValueRefInAcrossClass b/core/codegen/javagen/src/test/resources/specifications/ValueRefInAcrossClass similarity index 100% rename from core/codegen/src/test/resources/specifications/ValueRefInAcrossClass rename to core/codegen/javagen/src/test/resources/specifications/ValueRefInAcrossClass diff --git a/core/codegen/src/test/resources/specifications/ValueRefInAcrossClass.result b/core/codegen/javagen/src/test/resources/specifications/ValueRefInAcrossClass.result similarity index 100% rename from core/codegen/src/test/resources/specifications/ValueRefInAcrossClass.result rename to core/codegen/javagen/src/test/resources/specifications/ValueRefInAcrossClass.result diff --git a/core/codegen/src/test/resources/specifications/VariableExpressions b/core/codegen/javagen/src/test/resources/specifications/VariableExpressions similarity index 100% rename from core/codegen/src/test/resources/specifications/VariableExpressions rename to core/codegen/javagen/src/test/resources/specifications/VariableExpressions diff --git a/core/codegen/src/test/resources/specifications/VariableExpressions.result b/core/codegen/javagen/src/test/resources/specifications/VariableExpressions.result similarity index 100% rename from core/codegen/src/test/resources/specifications/VariableExpressions.result rename to core/codegen/javagen/src/test/resources/specifications/VariableExpressions.result diff --git a/core/codegen/src/test/resources/string_specs/ApplyExpMissingSeqOfCharInOneClass b/core/codegen/javagen/src/test/resources/string_specs/ApplyExpMissingSeqOfCharInOneClass similarity index 100% rename from core/codegen/src/test/resources/string_specs/ApplyExpMissingSeqOfCharInOneClass rename to core/codegen/javagen/src/test/resources/string_specs/ApplyExpMissingSeqOfCharInOneClass diff --git a/core/codegen/src/test/resources/string_specs/ApplyExpMissingSeqOfCharInOneClass.result b/core/codegen/javagen/src/test/resources/string_specs/ApplyExpMissingSeqOfCharInOneClass.result similarity index 100% rename from core/codegen/src/test/resources/string_specs/ApplyExpMissingSeqOfCharInOneClass.result rename to core/codegen/javagen/src/test/resources/string_specs/ApplyExpMissingSeqOfCharInOneClass.result diff --git a/core/codegen/src/test/resources/string_specs/Comparison b/core/codegen/javagen/src/test/resources/string_specs/Comparison similarity index 100% rename from core/codegen/src/test/resources/string_specs/Comparison rename to core/codegen/javagen/src/test/resources/string_specs/Comparison diff --git a/core/codegen/src/test/resources/string_specs/Comparison.result b/core/codegen/javagen/src/test/resources/string_specs/Comparison.result similarity index 100% rename from core/codegen/src/test/resources/string_specs/Comparison.result rename to core/codegen/javagen/src/test/resources/string_specs/Comparison.result diff --git a/core/codegen/src/test/resources/string_specs/Concat b/core/codegen/javagen/src/test/resources/string_specs/Concat similarity index 100% rename from core/codegen/src/test/resources/string_specs/Concat rename to core/codegen/javagen/src/test/resources/string_specs/Concat diff --git a/core/codegen/src/test/resources/string_specs/Concat.result b/core/codegen/javagen/src/test/resources/string_specs/Concat.result similarity index 100% rename from core/codegen/src/test/resources/string_specs/Concat.result rename to core/codegen/javagen/src/test/resources/string_specs/Concat.result diff --git a/core/codegen/src/test/resources/string_specs/DistConcat b/core/codegen/javagen/src/test/resources/string_specs/DistConcat similarity index 100% rename from core/codegen/src/test/resources/string_specs/DistConcat rename to core/codegen/javagen/src/test/resources/string_specs/DistConcat diff --git a/core/codegen/src/test/resources/string_specs/DistConcat.result b/core/codegen/javagen/src/test/resources/string_specs/DistConcat.result similarity index 100% rename from core/codegen/src/test/resources/string_specs/DistConcat.result rename to core/codegen/javagen/src/test/resources/string_specs/DistConcat.result diff --git a/core/codegen/src/test/resources/string_specs/Elems b/core/codegen/javagen/src/test/resources/string_specs/Elems similarity index 100% rename from core/codegen/src/test/resources/string_specs/Elems rename to core/codegen/javagen/src/test/resources/string_specs/Elems diff --git a/core/codegen/src/test/resources/string_specs/Elems.result b/core/codegen/javagen/src/test/resources/string_specs/Elems.result similarity index 100% rename from core/codegen/src/test/resources/string_specs/Elems.result rename to core/codegen/javagen/src/test/resources/string_specs/Elems.result diff --git a/core/codegen/src/test/resources/string_specs/EqualsNotEqualsSeqConversion b/core/codegen/javagen/src/test/resources/string_specs/EqualsNotEqualsSeqConversion similarity index 100% rename from core/codegen/src/test/resources/string_specs/EqualsNotEqualsSeqConversion rename to core/codegen/javagen/src/test/resources/string_specs/EqualsNotEqualsSeqConversion diff --git a/core/codegen/src/test/resources/string_specs/EqualsNotEqualsSeqConversion.result b/core/codegen/javagen/src/test/resources/string_specs/EqualsNotEqualsSeqConversion.result similarity index 100% rename from core/codegen/src/test/resources/string_specs/EqualsNotEqualsSeqConversion.result rename to core/codegen/javagen/src/test/resources/string_specs/EqualsNotEqualsSeqConversion.result diff --git a/core/codegen/src/test/resources/string_specs/EscapedCharacters b/core/codegen/javagen/src/test/resources/string_specs/EscapedCharacters similarity index 100% rename from core/codegen/src/test/resources/string_specs/EscapedCharacters rename to core/codegen/javagen/src/test/resources/string_specs/EscapedCharacters diff --git a/core/codegen/src/test/resources/string_specs/EscapedCharacters.result b/core/codegen/javagen/src/test/resources/string_specs/EscapedCharacters.result similarity index 100% rename from core/codegen/src/test/resources/string_specs/EscapedCharacters.result rename to core/codegen/javagen/src/test/resources/string_specs/EscapedCharacters.result diff --git a/core/codegen/src/test/resources/string_specs/Head b/core/codegen/javagen/src/test/resources/string_specs/Head similarity index 100% rename from core/codegen/src/test/resources/string_specs/Head rename to core/codegen/javagen/src/test/resources/string_specs/Head diff --git a/core/codegen/src/test/resources/string_specs/Head.result b/core/codegen/javagen/src/test/resources/string_specs/Head.result similarity index 100% rename from core/codegen/src/test/resources/string_specs/Head.result rename to core/codegen/javagen/src/test/resources/string_specs/Head.result diff --git a/core/codegen/src/test/resources/string_specs/Indexing b/core/codegen/javagen/src/test/resources/string_specs/Indexing similarity index 100% rename from core/codegen/src/test/resources/string_specs/Indexing rename to core/codegen/javagen/src/test/resources/string_specs/Indexing diff --git a/core/codegen/src/test/resources/string_specs/Indexing.result b/core/codegen/javagen/src/test/resources/string_specs/Indexing.result similarity index 100% rename from core/codegen/src/test/resources/string_specs/Indexing.result rename to core/codegen/javagen/src/test/resources/string_specs/Indexing.result diff --git a/core/codegen/src/test/resources/string_specs/Indices b/core/codegen/javagen/src/test/resources/string_specs/Indices similarity index 100% rename from core/codegen/src/test/resources/string_specs/Indices rename to core/codegen/javagen/src/test/resources/string_specs/Indices diff --git a/core/codegen/src/test/resources/string_specs/Indices.result b/core/codegen/javagen/src/test/resources/string_specs/Indices.result similarity index 100% rename from core/codegen/src/test/resources/string_specs/Indices.result rename to core/codegen/javagen/src/test/resources/string_specs/Indices.result diff --git a/core/codegen/src/test/resources/string_specs/Modification b/core/codegen/javagen/src/test/resources/string_specs/Modification similarity index 100% rename from core/codegen/src/test/resources/string_specs/Modification rename to core/codegen/javagen/src/test/resources/string_specs/Modification diff --git a/core/codegen/src/test/resources/string_specs/Modification.result b/core/codegen/javagen/src/test/resources/string_specs/Modification.result similarity index 100% rename from core/codegen/src/test/resources/string_specs/Modification.result rename to core/codegen/javagen/src/test/resources/string_specs/Modification.result diff --git a/core/codegen/src/test/resources/string_specs/Reverse b/core/codegen/javagen/src/test/resources/string_specs/Reverse similarity index 100% rename from core/codegen/src/test/resources/string_specs/Reverse rename to core/codegen/javagen/src/test/resources/string_specs/Reverse diff --git a/core/codegen/src/test/resources/string_specs/Reverse.result b/core/codegen/javagen/src/test/resources/string_specs/Reverse.result similarity index 100% rename from core/codegen/src/test/resources/string_specs/Reverse.result rename to core/codegen/javagen/src/test/resources/string_specs/Reverse.result diff --git a/core/codegen/src/test/resources/string_specs/SeqConversion b/core/codegen/javagen/src/test/resources/string_specs/SeqConversion similarity index 100% rename from core/codegen/src/test/resources/string_specs/SeqConversion rename to core/codegen/javagen/src/test/resources/string_specs/SeqConversion diff --git a/core/codegen/src/test/resources/string_specs/SeqConversion.result b/core/codegen/javagen/src/test/resources/string_specs/SeqConversion.result similarity index 100% rename from core/codegen/src/test/resources/string_specs/SeqConversion.result rename to core/codegen/javagen/src/test/resources/string_specs/SeqConversion.result diff --git a/core/codegen/src/test/resources/string_specs/SeqToStrFieldNumberExp b/core/codegen/javagen/src/test/resources/string_specs/SeqToStrFieldNumberExp similarity index 100% rename from core/codegen/src/test/resources/string_specs/SeqToStrFieldNumberExp rename to core/codegen/javagen/src/test/resources/string_specs/SeqToStrFieldNumberExp diff --git a/core/codegen/src/test/resources/string_specs/SeqToStrFieldNumberExp.result b/core/codegen/javagen/src/test/resources/string_specs/SeqToStrFieldNumberExp.result similarity index 100% rename from core/codegen/src/test/resources/string_specs/SeqToStrFieldNumberExp.result rename to core/codegen/javagen/src/test/resources/string_specs/SeqToStrFieldNumberExp.result diff --git a/core/codegen/src/test/resources/string_specs/Size b/core/codegen/javagen/src/test/resources/string_specs/Size similarity index 100% rename from core/codegen/src/test/resources/string_specs/Size rename to core/codegen/javagen/src/test/resources/string_specs/Size diff --git a/core/codegen/src/test/resources/string_specs/Size.result b/core/codegen/javagen/src/test/resources/string_specs/Size.result similarity index 100% rename from core/codegen/src/test/resources/string_specs/Size.result rename to core/codegen/javagen/src/test/resources/string_specs/Size.result diff --git a/core/codegen/src/test/resources/string_specs/StringPattern b/core/codegen/javagen/src/test/resources/string_specs/StringPattern similarity index 100% rename from core/codegen/src/test/resources/string_specs/StringPattern rename to core/codegen/javagen/src/test/resources/string_specs/StringPattern diff --git a/core/codegen/src/test/resources/string_specs/StringPattern.result b/core/codegen/javagen/src/test/resources/string_specs/StringPattern.result similarity index 100% rename from core/codegen/src/test/resources/string_specs/StringPattern.result rename to core/codegen/javagen/src/test/resources/string_specs/StringPattern.result diff --git a/core/codegen/src/test/resources/string_specs/SubSeqString1 b/core/codegen/javagen/src/test/resources/string_specs/SubSeqString1 similarity index 100% rename from core/codegen/src/test/resources/string_specs/SubSeqString1 rename to core/codegen/javagen/src/test/resources/string_specs/SubSeqString1 diff --git a/core/codegen/src/test/resources/string_specs/SubSeqString1.result b/core/codegen/javagen/src/test/resources/string_specs/SubSeqString1.result similarity index 100% rename from core/codegen/src/test/resources/string_specs/SubSeqString1.result rename to core/codegen/javagen/src/test/resources/string_specs/SubSeqString1.result diff --git a/core/codegen/src/test/resources/string_specs/SubSeqString2 b/core/codegen/javagen/src/test/resources/string_specs/SubSeqString2 similarity index 100% rename from core/codegen/src/test/resources/string_specs/SubSeqString2 rename to core/codegen/javagen/src/test/resources/string_specs/SubSeqString2 diff --git a/core/codegen/src/test/resources/string_specs/SubSeqString2.result b/core/codegen/javagen/src/test/resources/string_specs/SubSeqString2.result similarity index 100% rename from core/codegen/src/test/resources/string_specs/SubSeqString2.result rename to core/codegen/javagen/src/test/resources/string_specs/SubSeqString2.result diff --git a/core/codegen/src/test/resources/string_specs/SubSeqString3 b/core/codegen/javagen/src/test/resources/string_specs/SubSeqString3 similarity index 100% rename from core/codegen/src/test/resources/string_specs/SubSeqString3 rename to core/codegen/javagen/src/test/resources/string_specs/SubSeqString3 diff --git a/core/codegen/src/test/resources/string_specs/SubSeqString3.result b/core/codegen/javagen/src/test/resources/string_specs/SubSeqString3.result similarity index 100% rename from core/codegen/src/test/resources/string_specs/SubSeqString3.result rename to core/codegen/javagen/src/test/resources/string_specs/SubSeqString3.result diff --git a/core/codegen/src/test/resources/string_specs/SubSeqString4 b/core/codegen/javagen/src/test/resources/string_specs/SubSeqString4 similarity index 100% rename from core/codegen/src/test/resources/string_specs/SubSeqString4 rename to core/codegen/javagen/src/test/resources/string_specs/SubSeqString4 diff --git a/core/codegen/src/test/resources/string_specs/SubSeqString4.result b/core/codegen/javagen/src/test/resources/string_specs/SubSeqString4.result similarity index 100% rename from core/codegen/src/test/resources/string_specs/SubSeqString4.result rename to core/codegen/javagen/src/test/resources/string_specs/SubSeqString4.result diff --git a/core/codegen/src/test/resources/string_specs/SubSeqString5 b/core/codegen/javagen/src/test/resources/string_specs/SubSeqString5 similarity index 100% rename from core/codegen/src/test/resources/string_specs/SubSeqString5 rename to core/codegen/javagen/src/test/resources/string_specs/SubSeqString5 diff --git a/core/codegen/src/test/resources/string_specs/SubSeqString5.result b/core/codegen/javagen/src/test/resources/string_specs/SubSeqString5.result similarity index 100% rename from core/codegen/src/test/resources/string_specs/SubSeqString5.result rename to core/codegen/javagen/src/test/resources/string_specs/SubSeqString5.result diff --git a/core/codegen/src/test/resources/string_specs/SubSeqString6 b/core/codegen/javagen/src/test/resources/string_specs/SubSeqString6 similarity index 100% rename from core/codegen/src/test/resources/string_specs/SubSeqString6 rename to core/codegen/javagen/src/test/resources/string_specs/SubSeqString6 diff --git a/core/codegen/src/test/resources/string_specs/SubSeqString6.result b/core/codegen/javagen/src/test/resources/string_specs/SubSeqString6.result similarity index 100% rename from core/codegen/src/test/resources/string_specs/SubSeqString6.result rename to core/codegen/javagen/src/test/resources/string_specs/SubSeqString6.result diff --git a/core/codegen/src/test/resources/string_specs/Tail b/core/codegen/javagen/src/test/resources/string_specs/Tail similarity index 100% rename from core/codegen/src/test/resources/string_specs/Tail rename to core/codegen/javagen/src/test/resources/string_specs/Tail diff --git a/core/codegen/src/test/resources/string_specs/Tail.result b/core/codegen/javagen/src/test/resources/string_specs/Tail.result similarity index 100% rename from core/codegen/src/test/resources/string_specs/Tail.result rename to core/codegen/javagen/src/test/resources/string_specs/Tail.result diff --git a/core/codegen/src/test/resources/string_specs/Val2SeqOfChar b/core/codegen/javagen/src/test/resources/string_specs/Val2SeqOfChar similarity index 100% rename from core/codegen/src/test/resources/string_specs/Val2SeqOfChar rename to core/codegen/javagen/src/test/resources/string_specs/Val2SeqOfChar diff --git a/core/codegen/src/test/resources/string_specs/Val2SeqOfChar.result b/core/codegen/javagen/src/test/resources/string_specs/Val2SeqOfChar.result similarity index 100% rename from core/codegen/src/test/resources/string_specs/Val2SeqOfChar.result rename to core/codegen/javagen/src/test/resources/string_specs/Val2SeqOfChar.result diff --git a/core/codegen/src/test/resources/traces_expansion_specs/Alternative1 b/core/codegen/javagen/src/test/resources/traces_expansion_specs/Alternative1 similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/Alternative1 rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/Alternative1 diff --git a/core/codegen/src/test/resources/traces_expansion_specs/Alternative1.result b/core/codegen/javagen/src/test/resources/traces_expansion_specs/Alternative1.result similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/Alternative1.result rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/Alternative1.result diff --git a/core/codegen/src/test/resources/traces_expansion_specs/AlternativeConcurrent1 b/core/codegen/javagen/src/test/resources/traces_expansion_specs/AlternativeConcurrent1 similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/AlternativeConcurrent1 rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/AlternativeConcurrent1 diff --git a/core/codegen/src/test/resources/traces_expansion_specs/AlternativeConcurrent1.result b/core/codegen/javagen/src/test/resources/traces_expansion_specs/AlternativeConcurrent1.result similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/AlternativeConcurrent1.result rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/AlternativeConcurrent1.result diff --git a/core/codegen/src/test/resources/traces_expansion_specs/AlternativeRepeat1 b/core/codegen/javagen/src/test/resources/traces_expansion_specs/AlternativeRepeat1 similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/AlternativeRepeat1 rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/AlternativeRepeat1 diff --git a/core/codegen/src/test/resources/traces_expansion_specs/AlternativeRepeat1.result b/core/codegen/javagen/src/test/resources/traces_expansion_specs/AlternativeRepeat1.result similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/AlternativeRepeat1.result rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/AlternativeRepeat1.result diff --git a/core/codegen/src/test/resources/traces_expansion_specs/Concurrent1 b/core/codegen/javagen/src/test/resources/traces_expansion_specs/Concurrent1 similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/Concurrent1 rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/Concurrent1 diff --git a/core/codegen/src/test/resources/traces_expansion_specs/Concurrent1.result b/core/codegen/javagen/src/test/resources/traces_expansion_specs/Concurrent1.result similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/Concurrent1.result rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/Concurrent1.result diff --git a/core/codegen/src/test/resources/traces_expansion_specs/Concurrent2 b/core/codegen/javagen/src/test/resources/traces_expansion_specs/Concurrent2 similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/Concurrent2 rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/Concurrent2 diff --git a/core/codegen/src/test/resources/traces_expansion_specs/Concurrent2.result b/core/codegen/javagen/src/test/resources/traces_expansion_specs/Concurrent2.result similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/Concurrent2.result rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/Concurrent2.result diff --git a/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentAlternative1 b/core/codegen/javagen/src/test/resources/traces_expansion_specs/ConcurrentAlternative1 similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/ConcurrentAlternative1 rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/ConcurrentAlternative1 diff --git a/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentAlternative1.result b/core/codegen/javagen/src/test/resources/traces_expansion_specs/ConcurrentAlternative1.result similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/ConcurrentAlternative1.result rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/ConcurrentAlternative1.result diff --git a/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentRepeat1 b/core/codegen/javagen/src/test/resources/traces_expansion_specs/ConcurrentRepeat1 similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/ConcurrentRepeat1 rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/ConcurrentRepeat1 diff --git a/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentRepeat1.result b/core/codegen/javagen/src/test/resources/traces_expansion_specs/ConcurrentRepeat1.result similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/ConcurrentRepeat1.result rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/ConcurrentRepeat1.result diff --git a/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentRepeat2 b/core/codegen/javagen/src/test/resources/traces_expansion_specs/ConcurrentRepeat2 similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/ConcurrentRepeat2 rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/ConcurrentRepeat2 diff --git a/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentRepeat2.result b/core/codegen/javagen/src/test/resources/traces_expansion_specs/ConcurrentRepeat2.result similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/ConcurrentRepeat2.result rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/ConcurrentRepeat2.result diff --git a/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentWithLetBeSt b/core/codegen/javagen/src/test/resources/traces_expansion_specs/ConcurrentWithLetBeSt similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/ConcurrentWithLetBeSt rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/ConcurrentWithLetBeSt diff --git a/core/codegen/src/test/resources/traces_expansion_specs/ConcurrentWithLetBeSt.result b/core/codegen/javagen/src/test/resources/traces_expansion_specs/ConcurrentWithLetBeSt.result similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/ConcurrentWithLetBeSt.result rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/ConcurrentWithLetBeSt.result diff --git a/core/codegen/src/test/resources/traces_expansion_specs/LetBeSt1 b/core/codegen/javagen/src/test/resources/traces_expansion_specs/LetBeSt1 similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/LetBeSt1 rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/LetBeSt1 diff --git a/core/codegen/src/test/resources/traces_expansion_specs/LetBeSt1.result b/core/codegen/javagen/src/test/resources/traces_expansion_specs/LetBeSt1.result similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/LetBeSt1.result rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/LetBeSt1.result diff --git a/core/codegen/src/test/resources/traces_expansion_specs/LetBeStNested b/core/codegen/javagen/src/test/resources/traces_expansion_specs/LetBeStNested similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/LetBeStNested rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/LetBeStNested diff --git a/core/codegen/src/test/resources/traces_expansion_specs/LetBeStNested.result b/core/codegen/javagen/src/test/resources/traces_expansion_specs/LetBeStNested.result similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/LetBeStNested.result rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/LetBeStNested.result diff --git a/core/codegen/src/test/resources/traces_expansion_specs/LetBeStRecPattern b/core/codegen/javagen/src/test/resources/traces_expansion_specs/LetBeStRecPattern similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/LetBeStRecPattern rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/LetBeStRecPattern diff --git a/core/codegen/src/test/resources/traces_expansion_specs/LetBeStRecPattern.result b/core/codegen/javagen/src/test/resources/traces_expansion_specs/LetBeStRecPattern.result similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/LetBeStRecPattern.result rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/LetBeStRecPattern.result diff --git a/core/codegen/src/test/resources/traces_expansion_specs/LetBeStTupPattern b/core/codegen/javagen/src/test/resources/traces_expansion_specs/LetBeStTupPattern similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/LetBeStTupPattern rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/LetBeStTupPattern diff --git a/core/codegen/src/test/resources/traces_expansion_specs/LetBeStTupPattern.result b/core/codegen/javagen/src/test/resources/traces_expansion_specs/LetBeStTupPattern.result similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/LetBeStTupPattern.result rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/LetBeStTupPattern.result diff --git a/core/codegen/src/test/resources/traces_expansion_specs/LetDef1 b/core/codegen/javagen/src/test/resources/traces_expansion_specs/LetDef1 similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/LetDef1 rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/LetDef1 diff --git a/core/codegen/src/test/resources/traces_expansion_specs/LetDef1.result b/core/codegen/javagen/src/test/resources/traces_expansion_specs/LetDef1.result similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/LetDef1.result rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/LetDef1.result diff --git a/core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutive b/core/codegen/javagen/src/test/resources/traces_expansion_specs/LetDefConsecutive similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutive rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/LetDefConsecutive diff --git a/core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutive.result b/core/codegen/javagen/src/test/resources/traces_expansion_specs/LetDefConsecutive.result similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutive.result rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/LetDefConsecutive.result diff --git a/core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutiveRepeat b/core/codegen/javagen/src/test/resources/traces_expansion_specs/LetDefConsecutiveRepeat similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutiveRepeat rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/LetDefConsecutiveRepeat diff --git a/core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutiveRepeat.result b/core/codegen/javagen/src/test/resources/traces_expansion_specs/LetDefConsecutiveRepeat.result similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/LetDefConsecutiveRepeat.result rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/LetDefConsecutiveRepeat.result diff --git a/core/codegen/src/test/resources/traces_expansion_specs/LetDefTuplePattern b/core/codegen/javagen/src/test/resources/traces_expansion_specs/LetDefTuplePattern similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/LetDefTuplePattern rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/LetDefTuplePattern diff --git a/core/codegen/src/test/resources/traces_expansion_specs/LetDefTuplePattern.result b/core/codegen/javagen/src/test/resources/traces_expansion_specs/LetDefTuplePattern.result similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/LetDefTuplePattern.result rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/LetDefTuplePattern.result diff --git a/core/codegen/src/test/resources/traces_expansion_specs/ObjectBind b/core/codegen/javagen/src/test/resources/traces_expansion_specs/ObjectBind similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/ObjectBind rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/ObjectBind diff --git a/core/codegen/src/test/resources/traces_expansion_specs/ObjectBind.result b/core/codegen/javagen/src/test/resources/traces_expansion_specs/ObjectBind.result similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/ObjectBind.result rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/ObjectBind.result diff --git a/core/codegen/src/test/resources/traces_expansion_specs/OpCallsUsedToInitLocalDefs b/core/codegen/javagen/src/test/resources/traces_expansion_specs/OpCallsUsedToInitLocalDefs similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/OpCallsUsedToInitLocalDefs rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/OpCallsUsedToInitLocalDefs diff --git a/core/codegen/src/test/resources/traces_expansion_specs/OpCallsUsedToInitLocalDefs.result b/core/codegen/javagen/src/test/resources/traces_expansion_specs/OpCallsUsedToInitLocalDefs.result similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/OpCallsUsedToInitLocalDefs.result rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/OpCallsUsedToInitLocalDefs.result diff --git a/core/codegen/src/test/resources/traces_expansion_specs/Repeat1 b/core/codegen/javagen/src/test/resources/traces_expansion_specs/Repeat1 similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/Repeat1 rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/Repeat1 diff --git a/core/codegen/src/test/resources/traces_expansion_specs/Repeat1.result b/core/codegen/javagen/src/test/resources/traces_expansion_specs/Repeat1.result similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/Repeat1.result rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/Repeat1.result diff --git a/core/codegen/src/test/resources/traces_expansion_specs/RepeatAlternative1 b/core/codegen/javagen/src/test/resources/traces_expansion_specs/RepeatAlternative1 similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/RepeatAlternative1 rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/RepeatAlternative1 diff --git a/core/codegen/src/test/resources/traces_expansion_specs/RepeatAlternative1.result b/core/codegen/javagen/src/test/resources/traces_expansion_specs/RepeatAlternative1.result similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/RepeatAlternative1.result rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/RepeatAlternative1.result diff --git a/core/codegen/src/test/resources/traces_expansion_specs/RepeatConcurrent1 b/core/codegen/javagen/src/test/resources/traces_expansion_specs/RepeatConcurrent1 similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/RepeatConcurrent1 rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/RepeatConcurrent1 diff --git a/core/codegen/src/test/resources/traces_expansion_specs/RepeatConcurrent1.result b/core/codegen/javagen/src/test/resources/traces_expansion_specs/RepeatConcurrent1.result similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/RepeatConcurrent1.result rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/RepeatConcurrent1.result diff --git a/core/codegen/src/test/resources/traces_expansion_specs/SharedObjectBind b/core/codegen/javagen/src/test/resources/traces_expansion_specs/SharedObjectBind similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/SharedObjectBind rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/SharedObjectBind diff --git a/core/codegen/src/test/resources/traces_expansion_specs/SharedObjectBind.result b/core/codegen/javagen/src/test/resources/traces_expansion_specs/SharedObjectBind.result similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/SharedObjectBind.result rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/SharedObjectBind.result diff --git a/core/codegen/src/test/resources/traces_expansion_specs/SingleStatement1 b/core/codegen/javagen/src/test/resources/traces_expansion_specs/SingleStatement1 similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/SingleStatement1 rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/SingleStatement1 diff --git a/core/codegen/src/test/resources/traces_expansion_specs/SingleStatement1.result b/core/codegen/javagen/src/test/resources/traces_expansion_specs/SingleStatement1.result similarity index 100% rename from core/codegen/src/test/resources/traces_expansion_specs/SingleStatement1.result rename to core/codegen/javagen/src/test/resources/traces_expansion_specs/SingleStatement1.result diff --git a/core/codegen/src/test/resources/traces_verdict_specs/DivByZero b/core/codegen/javagen/src/test/resources/traces_verdict_specs/DivByZero similarity index 100% rename from core/codegen/src/test/resources/traces_verdict_specs/DivByZero rename to core/codegen/javagen/src/test/resources/traces_verdict_specs/DivByZero diff --git a/core/codegen/src/test/resources/traces_verdict_specs/DivByZero.result b/core/codegen/javagen/src/test/resources/traces_verdict_specs/DivByZero.result similarity index 100% rename from core/codegen/src/test/resources/traces_verdict_specs/DivByZero.result rename to core/codegen/javagen/src/test/resources/traces_verdict_specs/DivByZero.result diff --git a/core/codegen/src/test/resources/traces_verdict_specs/Filter b/core/codegen/javagen/src/test/resources/traces_verdict_specs/Filter similarity index 100% rename from core/codegen/src/test/resources/traces_verdict_specs/Filter rename to core/codegen/javagen/src/test/resources/traces_verdict_specs/Filter diff --git a/core/codegen/src/test/resources/traces_verdict_specs/Filter.result b/core/codegen/javagen/src/test/resources/traces_verdict_specs/Filter.result similarity index 100% rename from core/codegen/src/test/resources/traces_verdict_specs/Filter.result rename to core/codegen/javagen/src/test/resources/traces_verdict_specs/Filter.result diff --git a/core/codegen/src/test/resources/traces_verdict_specs/LetBeStNoBinding b/core/codegen/javagen/src/test/resources/traces_verdict_specs/LetBeStNoBinding similarity index 100% rename from core/codegen/src/test/resources/traces_verdict_specs/LetBeStNoBinding rename to core/codegen/javagen/src/test/resources/traces_verdict_specs/LetBeStNoBinding diff --git a/core/codegen/src/test/resources/traces_verdict_specs/LetBeStNoBinding.result b/core/codegen/javagen/src/test/resources/traces_verdict_specs/LetBeStNoBinding.result similarity index 100% rename from core/codegen/src/test/resources/traces_verdict_specs/LetBeStNoBinding.result rename to core/codegen/javagen/src/test/resources/traces_verdict_specs/LetBeStNoBinding.result diff --git a/core/codegen/src/test/resources/traces_verdict_specs/MapNoSuchKey b/core/codegen/javagen/src/test/resources/traces_verdict_specs/MapNoSuchKey similarity index 100% rename from core/codegen/src/test/resources/traces_verdict_specs/MapNoSuchKey rename to core/codegen/javagen/src/test/resources/traces_verdict_specs/MapNoSuchKey diff --git a/core/codegen/src/test/resources/traces_verdict_specs/MapNoSuchKey.result b/core/codegen/javagen/src/test/resources/traces_verdict_specs/MapNoSuchKey.result similarity index 100% rename from core/codegen/src/test/resources/traces_verdict_specs/MapNoSuchKey.result rename to core/codegen/javagen/src/test/resources/traces_verdict_specs/MapNoSuchKey.result diff --git a/core/codegen/src/test/resources/traces_verdict_specs/NilRefError b/core/codegen/javagen/src/test/resources/traces_verdict_specs/NilRefError similarity index 100% rename from core/codegen/src/test/resources/traces_verdict_specs/NilRefError rename to core/codegen/javagen/src/test/resources/traces_verdict_specs/NilRefError diff --git a/core/codegen/src/test/resources/traces_verdict_specs/NilRefError.result b/core/codegen/javagen/src/test/resources/traces_verdict_specs/NilRefError.result similarity index 100% rename from core/codegen/src/test/resources/traces_verdict_specs/NilRefError.result rename to core/codegen/javagen/src/test/resources/traces_verdict_specs/NilRefError.result diff --git a/core/codegen/src/test/resources/traces_verdict_specs/PreCondViolation b/core/codegen/javagen/src/test/resources/traces_verdict_specs/PreCondViolation similarity index 100% rename from core/codegen/src/test/resources/traces_verdict_specs/PreCondViolation rename to core/codegen/javagen/src/test/resources/traces_verdict_specs/PreCondViolation diff --git a/core/codegen/src/test/resources/traces_verdict_specs/PreCondViolation.result b/core/codegen/javagen/src/test/resources/traces_verdict_specs/PreCondViolation.result similarity index 100% rename from core/codegen/src/test/resources/traces_verdict_specs/PreCondViolation.result rename to core/codegen/javagen/src/test/resources/traces_verdict_specs/PreCondViolation.result diff --git a/core/codegen/src/test/resources/traces_verdict_specs/SameTestTwice b/core/codegen/javagen/src/test/resources/traces_verdict_specs/SameTestTwice similarity index 100% rename from core/codegen/src/test/resources/traces_verdict_specs/SameTestTwice rename to core/codegen/javagen/src/test/resources/traces_verdict_specs/SameTestTwice diff --git a/core/codegen/src/test/resources/traces_verdict_specs/SameTestTwice.result b/core/codegen/javagen/src/test/resources/traces_verdict_specs/SameTestTwice.result similarity index 100% rename from core/codegen/src/test/resources/traces_verdict_specs/SameTestTwice.result rename to core/codegen/javagen/src/test/resources/traces_verdict_specs/SameTestTwice.result diff --git a/core/codegen/src/test/resources/traces_verdict_specs/SeqIndexOutOfRange b/core/codegen/javagen/src/test/resources/traces_verdict_specs/SeqIndexOutOfRange similarity index 100% rename from core/codegen/src/test/resources/traces_verdict_specs/SeqIndexOutOfRange rename to core/codegen/javagen/src/test/resources/traces_verdict_specs/SeqIndexOutOfRange diff --git a/core/codegen/src/test/resources/traces_verdict_specs/SeqIndexOutOfRange.result b/core/codegen/javagen/src/test/resources/traces_verdict_specs/SeqIndexOutOfRange.result similarity index 100% rename from core/codegen/src/test/resources/traces_verdict_specs/SeqIndexOutOfRange.result rename to core/codegen/javagen/src/test/resources/traces_verdict_specs/SeqIndexOutOfRange.result diff --git a/core/codegen/src/test/resources/traces_verdict_specs/UnionTypeFailure b/core/codegen/javagen/src/test/resources/traces_verdict_specs/UnionTypeFailure similarity index 100% rename from core/codegen/src/test/resources/traces_verdict_specs/UnionTypeFailure rename to core/codegen/javagen/src/test/resources/traces_verdict_specs/UnionTypeFailure diff --git a/core/codegen/src/test/resources/traces_verdict_specs/UnionTypeFailure.result b/core/codegen/javagen/src/test/resources/traces_verdict_specs/UnionTypeFailure.result similarity index 100% rename from core/codegen/src/test/resources/traces_verdict_specs/UnionTypeFailure.result rename to core/codegen/javagen/src/test/resources/traces_verdict_specs/UnionTypeFailure.result diff --git a/core/codegen/src/test/resources/union_type_specs/ApplyExpInElseIfStm b/core/codegen/javagen/src/test/resources/union_type_specs/ApplyExpInElseIfStm similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/ApplyExpInElseIfStm rename to core/codegen/javagen/src/test/resources/union_type_specs/ApplyExpInElseIfStm diff --git a/core/codegen/src/test/resources/union_type_specs/ApplyExpInElseIfStm.result b/core/codegen/javagen/src/test/resources/union_type_specs/ApplyExpInElseIfStm.result similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/ApplyExpInElseIfStm.result rename to core/codegen/javagen/src/test/resources/union_type_specs/ApplyExpInElseIfStm.result diff --git a/core/codegen/src/test/resources/union_type_specs/ApplyExpMethodTypeRoot b/core/codegen/javagen/src/test/resources/union_type_specs/ApplyExpMethodTypeRoot similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/ApplyExpMethodTypeRoot rename to core/codegen/javagen/src/test/resources/union_type_specs/ApplyExpMethodTypeRoot diff --git a/core/codegen/src/test/resources/union_type_specs/ApplyExpMethodTypeRoot.result b/core/codegen/javagen/src/test/resources/union_type_specs/ApplyExpMethodTypeRoot.result similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/ApplyExpMethodTypeRoot.result rename to core/codegen/javagen/src/test/resources/union_type_specs/ApplyExpMethodTypeRoot.result diff --git a/core/codegen/src/test/resources/union_type_specs/ApplyExpMissingFunInOneClass b/core/codegen/javagen/src/test/resources/union_type_specs/ApplyExpMissingFunInOneClass similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/ApplyExpMissingFunInOneClass rename to core/codegen/javagen/src/test/resources/union_type_specs/ApplyExpMissingFunInOneClass diff --git a/core/codegen/src/test/resources/union_type_specs/ApplyExpMissingFunInOneClass.result b/core/codegen/javagen/src/test/resources/union_type_specs/ApplyExpMissingFunInOneClass.result similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/ApplyExpMissingFunInOneClass.result rename to core/codegen/javagen/src/test/resources/union_type_specs/ApplyExpMissingFunInOneClass.result diff --git a/core/codegen/src/test/resources/union_type_specs/ApplyExpMissingMapInOneClass b/core/codegen/javagen/src/test/resources/union_type_specs/ApplyExpMissingMapInOneClass similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/ApplyExpMissingMapInOneClass rename to core/codegen/javagen/src/test/resources/union_type_specs/ApplyExpMissingMapInOneClass diff --git a/core/codegen/src/test/resources/union_type_specs/ApplyExpMissingMapInOneClass.result b/core/codegen/javagen/src/test/resources/union_type_specs/ApplyExpMissingMapInOneClass.result similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/ApplyExpMissingMapInOneClass.result rename to core/codegen/javagen/src/test/resources/union_type_specs/ApplyExpMissingMapInOneClass.result diff --git a/core/codegen/src/test/resources/union_type_specs/ApplyExpMissingSeqInOneClass b/core/codegen/javagen/src/test/resources/union_type_specs/ApplyExpMissingSeqInOneClass similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/ApplyExpMissingSeqInOneClass rename to core/codegen/javagen/src/test/resources/union_type_specs/ApplyExpMissingSeqInOneClass diff --git a/core/codegen/src/test/resources/union_type_specs/ApplyExpMissingSeqInOneClass.result b/core/codegen/javagen/src/test/resources/union_type_specs/ApplyExpMissingSeqInOneClass.result similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/ApplyExpMissingSeqInOneClass.result rename to core/codegen/javagen/src/test/resources/union_type_specs/ApplyExpMissingSeqInOneClass.result diff --git a/core/codegen/src/test/resources/union_type_specs/ApplyExpMissingSeqOfCharInOneClass b/core/codegen/javagen/src/test/resources/union_type_specs/ApplyExpMissingSeqOfCharInOneClass similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/ApplyExpMissingSeqOfCharInOneClass rename to core/codegen/javagen/src/test/resources/union_type_specs/ApplyExpMissingSeqOfCharInOneClass diff --git a/core/codegen/src/test/resources/union_type_specs/ApplyExpMissingSeqOfCharInOneClass.result b/core/codegen/javagen/src/test/resources/union_type_specs/ApplyExpMissingSeqOfCharInOneClass.result similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/ApplyExpMissingSeqOfCharInOneClass.result rename to core/codegen/javagen/src/test/resources/union_type_specs/ApplyExpMissingSeqOfCharInOneClass.result diff --git a/core/codegen/src/test/resources/union_type_specs/ApplyExpNested b/core/codegen/javagen/src/test/resources/union_type_specs/ApplyExpNested similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/ApplyExpNested rename to core/codegen/javagen/src/test/resources/union_type_specs/ApplyExpNested diff --git a/core/codegen/src/test/resources/union_type_specs/ApplyExpNested.result b/core/codegen/javagen/src/test/resources/union_type_specs/ApplyExpNested.result similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/ApplyExpNested.result rename to core/codegen/javagen/src/test/resources/union_type_specs/ApplyExpNested.result diff --git a/core/codegen/src/test/resources/union_type_specs/CallObjStmInheritedOpProtected b/core/codegen/javagen/src/test/resources/union_type_specs/CallObjStmInheritedOpProtected similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/CallObjStmInheritedOpProtected rename to core/codegen/javagen/src/test/resources/union_type_specs/CallObjStmInheritedOpProtected diff --git a/core/codegen/src/test/resources/union_type_specs/CallObjStmInheritedOpProtected.result b/core/codegen/javagen/src/test/resources/union_type_specs/CallObjStmInheritedOpProtected.result similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/CallObjStmInheritedOpProtected.result rename to core/codegen/javagen/src/test/resources/union_type_specs/CallObjStmInheritedOpProtected.result diff --git a/core/codegen/src/test/resources/union_type_specs/CallObjStmInheritedOpPublic b/core/codegen/javagen/src/test/resources/union_type_specs/CallObjStmInheritedOpPublic similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/CallObjStmInheritedOpPublic rename to core/codegen/javagen/src/test/resources/union_type_specs/CallObjStmInheritedOpPublic diff --git a/core/codegen/src/test/resources/union_type_specs/CallObjStmInheritedOpPublic.result b/core/codegen/javagen/src/test/resources/union_type_specs/CallObjStmInheritedOpPublic.result similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/CallObjStmInheritedOpPublic.result rename to core/codegen/javagen/src/test/resources/union_type_specs/CallObjStmInheritedOpPublic.result diff --git a/core/codegen/src/test/resources/union_type_specs/CallObjStmMissingOpInOneClass b/core/codegen/javagen/src/test/resources/union_type_specs/CallObjStmMissingOpInOneClass similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/CallObjStmMissingOpInOneClass rename to core/codegen/javagen/src/test/resources/union_type_specs/CallObjStmMissingOpInOneClass diff --git a/core/codegen/src/test/resources/union_type_specs/CallObjStmMissingOpInOneClass.result b/core/codegen/javagen/src/test/resources/union_type_specs/CallObjStmMissingOpInOneClass.result similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/CallObjStmMissingOpInOneClass.result rename to core/codegen/javagen/src/test/resources/union_type_specs/CallObjStmMissingOpInOneClass.result diff --git a/core/codegen/src/test/resources/union_type_specs/CallObjStmNoArgs b/core/codegen/javagen/src/test/resources/union_type_specs/CallObjStmNoArgs similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/CallObjStmNoArgs rename to core/codegen/javagen/src/test/resources/union_type_specs/CallObjStmNoArgs diff --git a/core/codegen/src/test/resources/union_type_specs/CallObjStmNoArgs.result b/core/codegen/javagen/src/test/resources/union_type_specs/CallObjStmNoArgs.result similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/CallObjStmNoArgs.result rename to core/codegen/javagen/src/test/resources/union_type_specs/CallObjStmNoArgs.result diff --git a/core/codegen/src/test/resources/union_type_specs/CallObjStmNoArgsInLoop b/core/codegen/javagen/src/test/resources/union_type_specs/CallObjStmNoArgsInLoop similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/CallObjStmNoArgsInLoop rename to core/codegen/javagen/src/test/resources/union_type_specs/CallObjStmNoArgsInLoop diff --git a/core/codegen/src/test/resources/union_type_specs/CallObjStmNoArgsInLoop.result b/core/codegen/javagen/src/test/resources/union_type_specs/CallObjStmNoArgsInLoop.result similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/CallObjStmNoArgsInLoop.result rename to core/codegen/javagen/src/test/resources/union_type_specs/CallObjStmNoArgsInLoop.result diff --git a/core/codegen/src/test/resources/union_type_specs/CallObjStmWithArguments b/core/codegen/javagen/src/test/resources/union_type_specs/CallObjStmWithArguments similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/CallObjStmWithArguments rename to core/codegen/javagen/src/test/resources/union_type_specs/CallObjStmWithArguments diff --git a/core/codegen/src/test/resources/union_type_specs/CallObjStmWithArguments.result b/core/codegen/javagen/src/test/resources/union_type_specs/CallObjStmWithArguments.result similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/CallObjStmWithArguments.result rename to core/codegen/javagen/src/test/resources/union_type_specs/CallObjStmWithArguments.result diff --git a/core/codegen/src/test/resources/union_type_specs/CallStmInheritedOp b/core/codegen/javagen/src/test/resources/union_type_specs/CallStmInheritedOp similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/CallStmInheritedOp rename to core/codegen/javagen/src/test/resources/union_type_specs/CallStmInheritedOp diff --git a/core/codegen/src/test/resources/union_type_specs/CallStmInheritedOp.result b/core/codegen/javagen/src/test/resources/union_type_specs/CallStmInheritedOp.result similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/CallStmInheritedOp.result rename to core/codegen/javagen/src/test/resources/union_type_specs/CallStmInheritedOp.result diff --git a/core/codegen/src/test/resources/union_type_specs/CallStmLocalOp b/core/codegen/javagen/src/test/resources/union_type_specs/CallStmLocalOp similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/CallStmLocalOp rename to core/codegen/javagen/src/test/resources/union_type_specs/CallStmLocalOp diff --git a/core/codegen/src/test/resources/union_type_specs/CallStmLocalOp.result b/core/codegen/javagen/src/test/resources/union_type_specs/CallStmLocalOp.result similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/CallStmLocalOp.result rename to core/codegen/javagen/src/test/resources/union_type_specs/CallStmLocalOp.result diff --git a/core/codegen/src/test/resources/union_type_specs/Card b/core/codegen/javagen/src/test/resources/union_type_specs/Card similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/Card rename to core/codegen/javagen/src/test/resources/union_type_specs/Card diff --git a/core/codegen/src/test/resources/union_type_specs/Card.result b/core/codegen/javagen/src/test/resources/union_type_specs/Card.result similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/Card.result rename to core/codegen/javagen/src/test/resources/union_type_specs/Card.result diff --git a/core/codegen/src/test/resources/union_type_specs/FieldExpArgToOpCall b/core/codegen/javagen/src/test/resources/union_type_specs/FieldExpArgToOpCall similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/FieldExpArgToOpCall rename to core/codegen/javagen/src/test/resources/union_type_specs/FieldExpArgToOpCall diff --git a/core/codegen/src/test/resources/union_type_specs/FieldExpArgToOpCall.result b/core/codegen/javagen/src/test/resources/union_type_specs/FieldExpArgToOpCall.result similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/FieldExpArgToOpCall.result rename to core/codegen/javagen/src/test/resources/union_type_specs/FieldExpArgToOpCall.result diff --git a/core/codegen/src/test/resources/union_type_specs/FieldExpInReturnStm b/core/codegen/javagen/src/test/resources/union_type_specs/FieldExpInReturnStm similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/FieldExpInReturnStm rename to core/codegen/javagen/src/test/resources/union_type_specs/FieldExpInReturnStm diff --git a/core/codegen/src/test/resources/union_type_specs/FieldExpInReturnStm.result b/core/codegen/javagen/src/test/resources/union_type_specs/FieldExpInReturnStm.result similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/FieldExpInReturnStm.result rename to core/codegen/javagen/src/test/resources/union_type_specs/FieldExpInReturnStm.result diff --git a/core/codegen/src/test/resources/union_type_specs/FieldExpMissingRecField b/core/codegen/javagen/src/test/resources/union_type_specs/FieldExpMissingRecField similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/FieldExpMissingRecField rename to core/codegen/javagen/src/test/resources/union_type_specs/FieldExpMissingRecField diff --git a/core/codegen/src/test/resources/union_type_specs/FieldExpMissingRecField.result b/core/codegen/javagen/src/test/resources/union_type_specs/FieldExpMissingRecField.result similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/FieldExpMissingRecField.result rename to core/codegen/javagen/src/test/resources/union_type_specs/FieldExpMissingRecField.result diff --git a/core/codegen/src/test/resources/union_type_specs/FieldExpNotRootOfApplyExp b/core/codegen/javagen/src/test/resources/union_type_specs/FieldExpNotRootOfApplyExp similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/FieldExpNotRootOfApplyExp rename to core/codegen/javagen/src/test/resources/union_type_specs/FieldExpNotRootOfApplyExp diff --git a/core/codegen/src/test/resources/union_type_specs/FieldExpNotRootOfApplyExp.result b/core/codegen/javagen/src/test/resources/union_type_specs/FieldExpNotRootOfApplyExp.result similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/FieldExpNotRootOfApplyExp.result rename to core/codegen/javagen/src/test/resources/union_type_specs/FieldExpNotRootOfApplyExp.result diff --git a/core/codegen/src/test/resources/union_type_specs/FieldExpOfRecord b/core/codegen/javagen/src/test/resources/union_type_specs/FieldExpOfRecord similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/FieldExpOfRecord rename to core/codegen/javagen/src/test/resources/union_type_specs/FieldExpOfRecord diff --git a/core/codegen/src/test/resources/union_type_specs/FieldExpOfRecord.result b/core/codegen/javagen/src/test/resources/union_type_specs/FieldExpOfRecord.result similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/FieldExpOfRecord.result rename to core/codegen/javagen/src/test/resources/union_type_specs/FieldExpOfRecord.result diff --git a/core/codegen/src/test/resources/union_type_specs/FieldExpOfRecordArgToApplyExp b/core/codegen/javagen/src/test/resources/union_type_specs/FieldExpOfRecordArgToApplyExp similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/FieldExpOfRecordArgToApplyExp rename to core/codegen/javagen/src/test/resources/union_type_specs/FieldExpOfRecordArgToApplyExp diff --git a/core/codegen/src/test/resources/union_type_specs/FieldExpOfRecordArgToApplyExp.result b/core/codegen/javagen/src/test/resources/union_type_specs/FieldExpOfRecordArgToApplyExp.result similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/FieldExpOfRecordArgToApplyExp.result rename to core/codegen/javagen/src/test/resources/union_type_specs/FieldExpOfRecordArgToApplyExp.result diff --git a/core/codegen/src/test/resources/union_type_specs/FieldExpSeqApply b/core/codegen/javagen/src/test/resources/union_type_specs/FieldExpSeqApply similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/FieldExpSeqApply rename to core/codegen/javagen/src/test/resources/union_type_specs/FieldExpSeqApply diff --git a/core/codegen/src/test/resources/union_type_specs/FieldExpSeqApply.result b/core/codegen/javagen/src/test/resources/union_type_specs/FieldExpSeqApply.result similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/FieldExpSeqApply.result rename to core/codegen/javagen/src/test/resources/union_type_specs/FieldExpSeqApply.result diff --git a/core/codegen/src/test/resources/union_type_specs/FieldExpWithApplyExpParent b/core/codegen/javagen/src/test/resources/union_type_specs/FieldExpWithApplyExpParent similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/FieldExpWithApplyExpParent rename to core/codegen/javagen/src/test/resources/union_type_specs/FieldExpWithApplyExpParent diff --git a/core/codegen/src/test/resources/union_type_specs/FieldExpWithApplyExpParent.result b/core/codegen/javagen/src/test/resources/union_type_specs/FieldExpWithApplyExpParent.result similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/FieldExpWithApplyExpParent.result rename to core/codegen/javagen/src/test/resources/union_type_specs/FieldExpWithApplyExpParent.result diff --git a/core/codegen/src/test/resources/union_type_specs/FieldExpWithApplyExpParentInIfStm b/core/codegen/javagen/src/test/resources/union_type_specs/FieldExpWithApplyExpParentInIfStm similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/FieldExpWithApplyExpParentInIfStm rename to core/codegen/javagen/src/test/resources/union_type_specs/FieldExpWithApplyExpParentInIfStm diff --git a/core/codegen/src/test/resources/union_type_specs/FieldExpWithApplyExpParentInIfStm.result b/core/codegen/javagen/src/test/resources/union_type_specs/FieldExpWithApplyExpParentInIfStm.result similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/FieldExpWithApplyExpParentInIfStm.result rename to core/codegen/javagen/src/test/resources/union_type_specs/FieldExpWithApplyExpParentInIfStm.result diff --git a/core/codegen/src/test/resources/union_type_specs/FieldExpWithObjectAsApplyExp b/core/codegen/javagen/src/test/resources/union_type_specs/FieldExpWithObjectAsApplyExp similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/FieldExpWithObjectAsApplyExp rename to core/codegen/javagen/src/test/resources/union_type_specs/FieldExpWithObjectAsApplyExp diff --git a/core/codegen/src/test/resources/union_type_specs/FieldExpWithObjectAsApplyExp.result b/core/codegen/javagen/src/test/resources/union_type_specs/FieldExpWithObjectAsApplyExp.result similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/FieldExpWithObjectAsApplyExp.result rename to core/codegen/javagen/src/test/resources/union_type_specs/FieldExpWithObjectAsApplyExp.result diff --git a/core/codegen/src/test/resources/union_type_specs/FieldNumberExpArgToApplyExp b/core/codegen/javagen/src/test/resources/union_type_specs/FieldNumberExpArgToApplyExp similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/FieldNumberExpArgToApplyExp rename to core/codegen/javagen/src/test/resources/union_type_specs/FieldNumberExpArgToApplyExp diff --git a/core/codegen/src/test/resources/union_type_specs/FieldNumberExpArgToApplyExp.result b/core/codegen/javagen/src/test/resources/union_type_specs/FieldNumberExpArgToApplyExp.result similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/FieldNumberExpArgToApplyExp.result rename to core/codegen/javagen/src/test/resources/union_type_specs/FieldNumberExpArgToApplyExp.result diff --git a/core/codegen/src/test/resources/union_type_specs/FieldNumberExpDifferentFieldTyps b/core/codegen/javagen/src/test/resources/union_type_specs/FieldNumberExpDifferentFieldTyps similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/FieldNumberExpDifferentFieldTyps rename to core/codegen/javagen/src/test/resources/union_type_specs/FieldNumberExpDifferentFieldTyps diff --git a/core/codegen/src/test/resources/union_type_specs/FieldNumberExpDifferentFieldTyps.result b/core/codegen/javagen/src/test/resources/union_type_specs/FieldNumberExpDifferentFieldTyps.result similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/FieldNumberExpDifferentFieldTyps.result rename to core/codegen/javagen/src/test/resources/union_type_specs/FieldNumberExpDifferentFieldTyps.result diff --git a/core/codegen/src/test/resources/union_type_specs/FieldNumberExpUnknownType b/core/codegen/javagen/src/test/resources/union_type_specs/FieldNumberExpUnknownType similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/FieldNumberExpUnknownType rename to core/codegen/javagen/src/test/resources/union_type_specs/FieldNumberExpUnknownType diff --git a/core/codegen/src/test/resources/union_type_specs/FieldNumberExpUnknownType.result b/core/codegen/javagen/src/test/resources/union_type_specs/FieldNumberExpUnknownType.result similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/FieldNumberExpUnknownType.result rename to core/codegen/javagen/src/test/resources/union_type_specs/FieldNumberExpUnknownType.result diff --git a/core/codegen/src/test/resources/union_type_specs/IfStm b/core/codegen/javagen/src/test/resources/union_type_specs/IfStm similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/IfStm rename to core/codegen/javagen/src/test/resources/union_type_specs/IfStm diff --git a/core/codegen/src/test/resources/union_type_specs/IfStm.result b/core/codegen/javagen/src/test/resources/union_type_specs/IfStm.result similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/IfStm.result rename to core/codegen/javagen/src/test/resources/union_type_specs/IfStm.result diff --git a/core/codegen/src/test/resources/union_type_specs/Len b/core/codegen/javagen/src/test/resources/union_type_specs/Len similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/Len rename to core/codegen/javagen/src/test/resources/union_type_specs/Len diff --git a/core/codegen/src/test/resources/union_type_specs/Len.result b/core/codegen/javagen/src/test/resources/union_type_specs/Len.result similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/Len.result rename to core/codegen/javagen/src/test/resources/union_type_specs/Len.result diff --git a/core/codegen/src/test/resources/union_type_specs/LetBeStRecElem b/core/codegen/javagen/src/test/resources/union_type_specs/LetBeStRecElem similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/LetBeStRecElem rename to core/codegen/javagen/src/test/resources/union_type_specs/LetBeStRecElem diff --git a/core/codegen/src/test/resources/union_type_specs/LetBeStRecElem.result b/core/codegen/javagen/src/test/resources/union_type_specs/LetBeStRecElem.result similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/LetBeStRecElem.result rename to core/codegen/javagen/src/test/resources/union_type_specs/LetBeStRecElem.result diff --git a/core/codegen/src/test/resources/union_type_specs/MapApply b/core/codegen/javagen/src/test/resources/union_type_specs/MapApply similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/MapApply rename to core/codegen/javagen/src/test/resources/union_type_specs/MapApply diff --git a/core/codegen/src/test/resources/union_type_specs/MapApply.result b/core/codegen/javagen/src/test/resources/union_type_specs/MapApply.result similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/MapApply.result rename to core/codegen/javagen/src/test/resources/union_type_specs/MapApply.result diff --git a/core/codegen/src/test/resources/union_type_specs/MapCompUnionOfMapTypes b/core/codegen/javagen/src/test/resources/union_type_specs/MapCompUnionOfMapTypes similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/MapCompUnionOfMapTypes rename to core/codegen/javagen/src/test/resources/union_type_specs/MapCompUnionOfMapTypes diff --git a/core/codegen/src/test/resources/union_type_specs/MapCompUnionOfMapTypes.result b/core/codegen/javagen/src/test/resources/union_type_specs/MapCompUnionOfMapTypes.result similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/MapCompUnionOfMapTypes.result rename to core/codegen/javagen/src/test/resources/union_type_specs/MapCompUnionOfMapTypes.result diff --git a/core/codegen/src/test/resources/union_type_specs/NewExpClass b/core/codegen/javagen/src/test/resources/union_type_specs/NewExpClass similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/NewExpClass rename to core/codegen/javagen/src/test/resources/union_type_specs/NewExpClass diff --git a/core/codegen/src/test/resources/union_type_specs/NewExpClass.result b/core/codegen/javagen/src/test/resources/union_type_specs/NewExpClass.result similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/NewExpClass.result rename to core/codegen/javagen/src/test/resources/union_type_specs/NewExpClass.result diff --git a/core/codegen/src/test/resources/union_type_specs/NewExpRecord b/core/codegen/javagen/src/test/resources/union_type_specs/NewExpRecord similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/NewExpRecord rename to core/codegen/javagen/src/test/resources/union_type_specs/NewExpRecord diff --git a/core/codegen/src/test/resources/union_type_specs/NewExpRecord.result b/core/codegen/javagen/src/test/resources/union_type_specs/NewExpRecord.result similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/NewExpRecord.result rename to core/codegen/javagen/src/test/resources/union_type_specs/NewExpRecord.result diff --git a/core/codegen/src/test/resources/union_type_specs/NotExp b/core/codegen/javagen/src/test/resources/union_type_specs/NotExp similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/NotExp rename to core/codegen/javagen/src/test/resources/union_type_specs/NotExp diff --git a/core/codegen/src/test/resources/union_type_specs/NotExp.result b/core/codegen/javagen/src/test/resources/union_type_specs/NotExp.result similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/NotExp.result rename to core/codegen/javagen/src/test/resources/union_type_specs/NotExp.result diff --git a/core/codegen/src/test/resources/union_type_specs/NumericPlus b/core/codegen/javagen/src/test/resources/union_type_specs/NumericPlus similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/NumericPlus rename to core/codegen/javagen/src/test/resources/union_type_specs/NumericPlus diff --git a/core/codegen/src/test/resources/union_type_specs/NumericPlus.result b/core/codegen/javagen/src/test/resources/union_type_specs/NumericPlus.result similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/NumericPlus.result rename to core/codegen/javagen/src/test/resources/union_type_specs/NumericPlus.result diff --git a/core/codegen/src/test/resources/union_type_specs/ReturnStm b/core/codegen/javagen/src/test/resources/union_type_specs/ReturnStm similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/ReturnStm rename to core/codegen/javagen/src/test/resources/union_type_specs/ReturnStm diff --git a/core/codegen/src/test/resources/union_type_specs/ReturnStm.result b/core/codegen/javagen/src/test/resources/union_type_specs/ReturnStm.result similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/ReturnStm.result rename to core/codegen/javagen/src/test/resources/union_type_specs/ReturnStm.result diff --git a/core/codegen/src/test/resources/union_type_specs/SeqApply b/core/codegen/javagen/src/test/resources/union_type_specs/SeqApply similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/SeqApply rename to core/codegen/javagen/src/test/resources/union_type_specs/SeqApply diff --git a/core/codegen/src/test/resources/union_type_specs/SeqApply.result b/core/codegen/javagen/src/test/resources/union_type_specs/SeqApply.result similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/SeqApply.result rename to core/codegen/javagen/src/test/resources/union_type_specs/SeqApply.result diff --git a/core/codegen/src/test/resources/union_type_specs/SeqCompUnionOfSeqTypes b/core/codegen/javagen/src/test/resources/union_type_specs/SeqCompUnionOfSeqTypes similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/SeqCompUnionOfSeqTypes rename to core/codegen/javagen/src/test/resources/union_type_specs/SeqCompUnionOfSeqTypes diff --git a/core/codegen/src/test/resources/union_type_specs/SeqCompUnionOfSeqTypes.result b/core/codegen/javagen/src/test/resources/union_type_specs/SeqCompUnionOfSeqTypes.result similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/SeqCompUnionOfSeqTypes.result rename to core/codegen/javagen/src/test/resources/union_type_specs/SeqCompUnionOfSeqTypes.result diff --git a/core/codegen/src/test/resources/union_type_specs/SeqConc b/core/codegen/javagen/src/test/resources/union_type_specs/SeqConc similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/SeqConc rename to core/codegen/javagen/src/test/resources/union_type_specs/SeqConc diff --git a/core/codegen/src/test/resources/union_type_specs/SeqConc.result b/core/codegen/javagen/src/test/resources/union_type_specs/SeqConc.result similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/SeqConc.result rename to core/codegen/javagen/src/test/resources/union_type_specs/SeqConc.result diff --git a/core/codegen/src/test/resources/union_type_specs/SetCompUnionOfSetTypes b/core/codegen/javagen/src/test/resources/union_type_specs/SetCompUnionOfSetTypes similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/SetCompUnionOfSetTypes rename to core/codegen/javagen/src/test/resources/union_type_specs/SetCompUnionOfSetTypes diff --git a/core/codegen/src/test/resources/union_type_specs/SetCompUnionOfSetTypes.result b/core/codegen/javagen/src/test/resources/union_type_specs/SetCompUnionOfSetTypes.result similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/SetCompUnionOfSetTypes.result rename to core/codegen/javagen/src/test/resources/union_type_specs/SetCompUnionOfSetTypes.result diff --git a/core/codegen/src/test/resources/union_type_specs/UnionOfQuotes b/core/codegen/javagen/src/test/resources/union_type_specs/UnionOfQuotes similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/UnionOfQuotes rename to core/codegen/javagen/src/test/resources/union_type_specs/UnionOfQuotes diff --git a/core/codegen/src/test/resources/union_type_specs/UnionOfQuotes.result b/core/codegen/javagen/src/test/resources/union_type_specs/UnionOfQuotes.result similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/UnionOfQuotes.result rename to core/codegen/javagen/src/test/resources/union_type_specs/UnionOfQuotes.result diff --git a/core/codegen/src/test/resources/union_type_specs/UnknownTypeInUnionType b/core/codegen/javagen/src/test/resources/union_type_specs/UnknownTypeInUnionType similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/UnknownTypeInUnionType rename to core/codegen/javagen/src/test/resources/union_type_specs/UnknownTypeInUnionType diff --git a/core/codegen/src/test/resources/union_type_specs/UnknownTypeInUnionType.result b/core/codegen/javagen/src/test/resources/union_type_specs/UnknownTypeInUnionType.result similarity index 100% rename from core/codegen/src/test/resources/union_type_specs/UnknownTypeInUnionType.result rename to core/codegen/javagen/src/test/resources/union_type_specs/UnknownTypeInUnionType.result diff --git a/core/codegen/src/test/resources/var_shadowing_specs/CasesExpTuplePattern b/core/codegen/javagen/src/test/resources/var_shadowing_specs/CasesExpTuplePattern similarity index 100% rename from core/codegen/src/test/resources/var_shadowing_specs/CasesExpTuplePattern rename to core/codegen/javagen/src/test/resources/var_shadowing_specs/CasesExpTuplePattern diff --git a/core/codegen/src/test/resources/var_shadowing_specs/CasesStmTuplePattern b/core/codegen/javagen/src/test/resources/var_shadowing_specs/CasesStmTuplePattern similarity index 100% rename from core/codegen/src/test/resources/var_shadowing_specs/CasesStmTuplePattern rename to core/codegen/javagen/src/test/resources/var_shadowing_specs/CasesStmTuplePattern diff --git a/core/codegen/src/test/resources/var_shadowing_specs/DefExp b/core/codegen/javagen/src/test/resources/var_shadowing_specs/DefExp similarity index 100% rename from core/codegen/src/test/resources/var_shadowing_specs/DefExp rename to core/codegen/javagen/src/test/resources/var_shadowing_specs/DefExp diff --git a/core/codegen/src/test/resources/var_shadowing_specs/ExistsTwoMultipleSetBinds b/core/codegen/javagen/src/test/resources/var_shadowing_specs/ExistsTwoMultipleSetBinds similarity index 100% rename from core/codegen/src/test/resources/var_shadowing_specs/ExistsTwoMultipleSetBinds rename to core/codegen/javagen/src/test/resources/var_shadowing_specs/ExistsTwoMultipleSetBinds diff --git a/core/codegen/src/test/resources/var_shadowing_specs/ForAllExpTwoMultipleBinds b/core/codegen/javagen/src/test/resources/var_shadowing_specs/ForAllExpTwoMultipleBinds similarity index 100% rename from core/codegen/src/test/resources/var_shadowing_specs/ForAllExpTwoMultipleBinds rename to core/codegen/javagen/src/test/resources/var_shadowing_specs/ForAllExpTwoMultipleBinds diff --git a/core/codegen/src/test/resources/var_shadowing_specs/ForAllExpTwoMultipleTypeBindsOneName b/core/codegen/javagen/src/test/resources/var_shadowing_specs/ForAllExpTwoMultipleTypeBindsOneName similarity index 100% rename from core/codegen/src/test/resources/var_shadowing_specs/ForAllExpTwoMultipleTypeBindsOneName rename to core/codegen/javagen/src/test/resources/var_shadowing_specs/ForAllExpTwoMultipleTypeBindsOneName diff --git a/core/codegen/src/test/resources/var_shadowing_specs/ForAllExpTwoMultipleTypeBindsTwoNames b/core/codegen/javagen/src/test/resources/var_shadowing_specs/ForAllExpTwoMultipleTypeBindsTwoNames similarity index 100% rename from core/codegen/src/test/resources/var_shadowing_specs/ForAllExpTwoMultipleTypeBindsTwoNames rename to core/codegen/javagen/src/test/resources/var_shadowing_specs/ForAllExpTwoMultipleTypeBindsTwoNames diff --git a/core/codegen/src/test/resources/var_shadowing_specs/ForAllStmTuplePattern b/core/codegen/javagen/src/test/resources/var_shadowing_specs/ForAllStmTuplePattern similarity index 100% rename from core/codegen/src/test/resources/var_shadowing_specs/ForAllStmTuplePattern rename to core/codegen/javagen/src/test/resources/var_shadowing_specs/ForAllStmTuplePattern diff --git a/core/codegen/src/test/resources/var_shadowing_specs/ForIndexLoopVar b/core/codegen/javagen/src/test/resources/var_shadowing_specs/ForIndexLoopVar similarity index 100% rename from core/codegen/src/test/resources/var_shadowing_specs/ForIndexLoopVar rename to core/codegen/javagen/src/test/resources/var_shadowing_specs/ForIndexLoopVar diff --git a/core/codegen/src/test/resources/var_shadowing_specs/ForPatternBindTuple b/core/codegen/javagen/src/test/resources/var_shadowing_specs/ForPatternBindTuple similarity index 100% rename from core/codegen/src/test/resources/var_shadowing_specs/ForPatternBindTuple rename to core/codegen/javagen/src/test/resources/var_shadowing_specs/ForPatternBindTuple diff --git a/core/codegen/src/test/resources/var_shadowing_specs/GenUniqueNameLetStm b/core/codegen/javagen/src/test/resources/var_shadowing_specs/GenUniqueNameLetStm similarity index 100% rename from core/codegen/src/test/resources/var_shadowing_specs/GenUniqueNameLetStm rename to core/codegen/javagen/src/test/resources/var_shadowing_specs/GenUniqueNameLetStm diff --git a/core/codegen/src/test/resources/var_shadowing_specs/IdShadowingVarExp b/core/codegen/javagen/src/test/resources/var_shadowing_specs/IdShadowingVarExp similarity index 100% rename from core/codegen/src/test/resources/var_shadowing_specs/IdShadowingVarExp rename to core/codegen/javagen/src/test/resources/var_shadowing_specs/IdShadowingVarExp diff --git a/core/codegen/src/test/resources/var_shadowing_specs/IdStateDesignatorNestedBlocks b/core/codegen/javagen/src/test/resources/var_shadowing_specs/IdStateDesignatorNestedBlocks similarity index 100% rename from core/codegen/src/test/resources/var_shadowing_specs/IdStateDesignatorNestedBlocks rename to core/codegen/javagen/src/test/resources/var_shadowing_specs/IdStateDesignatorNestedBlocks diff --git a/core/codegen/src/test/resources/var_shadowing_specs/IdStateDesignatorSingleBlock b/core/codegen/javagen/src/test/resources/var_shadowing_specs/IdStateDesignatorSingleBlock similarity index 100% rename from core/codegen/src/test/resources/var_shadowing_specs/IdStateDesignatorSingleBlock rename to core/codegen/javagen/src/test/resources/var_shadowing_specs/IdStateDesignatorSingleBlock diff --git a/core/codegen/src/test/resources/var_shadowing_specs/LambdaInLet b/core/codegen/javagen/src/test/resources/var_shadowing_specs/LambdaInLet similarity index 100% rename from core/codegen/src/test/resources/var_shadowing_specs/LambdaInLet rename to core/codegen/javagen/src/test/resources/var_shadowing_specs/LambdaInLet diff --git a/core/codegen/src/test/resources/var_shadowing_specs/LambdaParam b/core/codegen/javagen/src/test/resources/var_shadowing_specs/LambdaParam similarity index 100% rename from core/codegen/src/test/resources/var_shadowing_specs/LambdaParam rename to core/codegen/javagen/src/test/resources/var_shadowing_specs/LambdaParam diff --git a/core/codegen/src/test/resources/var_shadowing_specs/LetBeStExpNested b/core/codegen/javagen/src/test/resources/var_shadowing_specs/LetBeStExpNested similarity index 100% rename from core/codegen/src/test/resources/var_shadowing_specs/LetBeStExpNested rename to core/codegen/javagen/src/test/resources/var_shadowing_specs/LetBeStExpNested diff --git a/core/codegen/src/test/resources/var_shadowing_specs/LetBeStStmCond b/core/codegen/javagen/src/test/resources/var_shadowing_specs/LetBeStStmCond similarity index 100% rename from core/codegen/src/test/resources/var_shadowing_specs/LetBeStStmCond rename to core/codegen/javagen/src/test/resources/var_shadowing_specs/LetBeStStmCond diff --git a/core/codegen/src/test/resources/var_shadowing_specs/LetBeStStmMultipleSetBind b/core/codegen/javagen/src/test/resources/var_shadowing_specs/LetBeStStmMultipleSetBind similarity index 100% rename from core/codegen/src/test/resources/var_shadowing_specs/LetBeStStmMultipleSetBind rename to core/codegen/javagen/src/test/resources/var_shadowing_specs/LetBeStStmMultipleSetBind diff --git a/core/codegen/src/test/resources/var_shadowing_specs/LetBeStStmMultipleTypeBind b/core/codegen/javagen/src/test/resources/var_shadowing_specs/LetBeStStmMultipleTypeBind similarity index 100% rename from core/codegen/src/test/resources/var_shadowing_specs/LetBeStStmMultipleTypeBind rename to core/codegen/javagen/src/test/resources/var_shadowing_specs/LetBeStStmMultipleTypeBind diff --git a/core/codegen/src/test/resources/var_shadowing_specs/LetBeStTrace b/core/codegen/javagen/src/test/resources/var_shadowing_specs/LetBeStTrace similarity index 100% rename from core/codegen/src/test/resources/var_shadowing_specs/LetBeStTrace rename to core/codegen/javagen/src/test/resources/var_shadowing_specs/LetBeStTrace diff --git a/core/codegen/src/test/resources/var_shadowing_specs/LetBeStTraceMultipleTypeBind b/core/codegen/javagen/src/test/resources/var_shadowing_specs/LetBeStTraceMultipleTypeBind similarity index 100% rename from core/codegen/src/test/resources/var_shadowing_specs/LetBeStTraceMultipleTypeBind rename to core/codegen/javagen/src/test/resources/var_shadowing_specs/LetBeStTraceMultipleTypeBind diff --git a/core/codegen/src/test/resources/var_shadowing_specs/LetStmCrossClassDependency b/core/codegen/javagen/src/test/resources/var_shadowing_specs/LetStmCrossClassDependency similarity index 100% rename from core/codegen/src/test/resources/var_shadowing_specs/LetStmCrossClassDependency rename to core/codegen/javagen/src/test/resources/var_shadowing_specs/LetStmCrossClassDependency diff --git a/core/codegen/src/test/resources/var_shadowing_specs/LetStmHidingAtSameScopeLevel b/core/codegen/javagen/src/test/resources/var_shadowing_specs/LetStmHidingAtSameScopeLevel similarity index 100% rename from core/codegen/src/test/resources/var_shadowing_specs/LetStmHidingAtSameScopeLevel rename to core/codegen/javagen/src/test/resources/var_shadowing_specs/LetStmHidingAtSameScopeLevel diff --git a/core/codegen/src/test/resources/var_shadowing_specs/LetStmNested b/core/codegen/javagen/src/test/resources/var_shadowing_specs/LetStmNested similarity index 100% rename from core/codegen/src/test/resources/var_shadowing_specs/LetStmNested rename to core/codegen/javagen/src/test/resources/var_shadowing_specs/LetStmNested diff --git a/core/codegen/src/test/resources/var_shadowing_specs/LetStmTuplePatterns b/core/codegen/javagen/src/test/resources/var_shadowing_specs/LetStmTuplePatterns similarity index 100% rename from core/codegen/src/test/resources/var_shadowing_specs/LetStmTuplePatterns rename to core/codegen/javagen/src/test/resources/var_shadowing_specs/LetStmTuplePatterns diff --git a/core/codegen/src/test/resources/var_shadowing_specs/LetStmVarHiddenMultipleTimes b/core/codegen/javagen/src/test/resources/var_shadowing_specs/LetStmVarHiddenMultipleTimes similarity index 100% rename from core/codegen/src/test/resources/var_shadowing_specs/LetStmVarHiddenMultipleTimes rename to core/codegen/javagen/src/test/resources/var_shadowing_specs/LetStmVarHiddenMultipleTimes diff --git a/core/codegen/src/test/resources/var_shadowing_specs/LetVarHidesFuncParam b/core/codegen/javagen/src/test/resources/var_shadowing_specs/LetVarHidesFuncParam similarity index 100% rename from core/codegen/src/test/resources/var_shadowing_specs/LetVarHidesFuncParam rename to core/codegen/javagen/src/test/resources/var_shadowing_specs/LetVarHidesFuncParam diff --git a/core/codegen/src/test/resources/var_shadowing_specs/LetVarHidesOpParam b/core/codegen/javagen/src/test/resources/var_shadowing_specs/LetVarHidesOpParam similarity index 100% rename from core/codegen/src/test/resources/var_shadowing_specs/LetVarHidesOpParam rename to core/codegen/javagen/src/test/resources/var_shadowing_specs/LetVarHidesOpParam diff --git a/core/codegen/src/test/resources/var_shadowing_specs/MapCompTwoMultipleSetBinds b/core/codegen/javagen/src/test/resources/var_shadowing_specs/MapCompTwoMultipleSetBinds similarity index 100% rename from core/codegen/src/test/resources/var_shadowing_specs/MapCompTwoMultipleSetBinds rename to core/codegen/javagen/src/test/resources/var_shadowing_specs/MapCompTwoMultipleSetBinds diff --git a/core/codegen/src/test/resources/var_shadowing_specs/SetCompTwoMultipleSetBinds b/core/codegen/javagen/src/test/resources/var_shadowing_specs/SetCompTwoMultipleSetBinds similarity index 100% rename from core/codegen/src/test/resources/var_shadowing_specs/SetCompTwoMultipleSetBinds rename to core/codegen/javagen/src/test/resources/var_shadowing_specs/SetCompTwoMultipleSetBinds diff --git a/core/codegen/src/test/resources/var_shadowing_specs/StmBlockSimple b/core/codegen/javagen/src/test/resources/var_shadowing_specs/StmBlockSimple similarity index 100% rename from core/codegen/src/test/resources/var_shadowing_specs/StmBlockSimple rename to core/codegen/javagen/src/test/resources/var_shadowing_specs/StmBlockSimple diff --git a/core/codegen/src/test/resources/var_shadowing_specs/TixeStmTuplePattern b/core/codegen/javagen/src/test/resources/var_shadowing_specs/TixeStmTuplePattern similarity index 100% rename from core/codegen/src/test/resources/var_shadowing_specs/TixeStmTuplePattern rename to core/codegen/javagen/src/test/resources/var_shadowing_specs/TixeStmTuplePattern diff --git a/core/codegen/src/test/resources/var_shadowing_specs/TrapStmTuplePattern b/core/codegen/javagen/src/test/resources/var_shadowing_specs/TrapStmTuplePattern similarity index 100% rename from core/codegen/src/test/resources/var_shadowing_specs/TrapStmTuplePattern rename to core/codegen/javagen/src/test/resources/var_shadowing_specs/TrapStmTuplePattern diff --git a/core/codegen/src/test/resources/var_shadowing_specs/TuplePatternIdsShadowing b/core/codegen/javagen/src/test/resources/var_shadowing_specs/TuplePatternIdsShadowing similarity index 100% rename from core/codegen/src/test/resources/var_shadowing_specs/TuplePatternIdsShadowing rename to core/codegen/javagen/src/test/resources/var_shadowing_specs/TuplePatternIdsShadowing From 888935586efcf5ac2c37cd21162ce6f16918bb69 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Mon, 9 Mar 2015 15:38:08 +0100 Subject: [PATCH 267/323] Updated poms to fit the new structure of code generation related projects --- core/codegen/README.md | 15 ++++++++++++++ core/codegen/cgisa/pom.xml | 12 ++++++------ core/codegen/codegen-maven-plugin/pom.xml | 6 +++--- core/codegen/codegen-runtime/pom.xml | 8 ++++---- core/codegen/javagen/pom.xml | 14 ++++++------- core/codegen/pom.xml | 24 +++++++++++++++++++++++ core/pom.xml | 2 -- ide/plugins/codegen/META-INF/MANIFEST.MF | 2 +- ide/plugins/codegen/pom.xml | 12 ++++++------ 9 files changed, 66 insertions(+), 29 deletions(-) create mode 100644 core/codegen/README.md create mode 100644 core/codegen/pom.xml diff --git a/core/codegen/README.md b/core/codegen/README.md new file mode 100644 index 0000000000..e38774f328 --- /dev/null +++ b/core/codegen/README.md @@ -0,0 +1,15 @@ +# Code Generation +- **Primary Contacts:** + Peter Würtz Vinther Tran-Jørgensen +- **Status:** + Production + +## Description: + + +## Known Issues: + + +## Contributors: + + diff --git a/core/codegen/cgisa/pom.xml b/core/codegen/cgisa/pom.xml index d46b150f52..e5a9849899 100644 --- a/core/codegen/cgisa/pom.xml +++ b/core/codegen/cgisa/pom.xml @@ -2,15 +2,15 @@ 4.0.0 - org.overturetool - core + org.overturetool.core + codegen 2.2.3-SNAPSHOT ../pom.xml - org.overturetool.core + org.overturetool.core.codegen cgisa - VDM to Isabelle Translation + The VDM to Isabelle Translator 1.6.7-SNAPSHOT @@ -23,8 +23,8 @@ ${project.version} - org.overturetool.core - codegen + org.overturetool.core.codegen + javagen ${project.version} diff --git a/core/codegen/codegen-maven-plugin/pom.xml b/core/codegen/codegen-maven-plugin/pom.xml index 337094e719..e708aaa49c 100644 --- a/core/codegen/codegen-maven-plugin/pom.xml +++ b/core/codegen/codegen-maven-plugin/pom.xml @@ -11,7 +11,7 @@ maven-plugin codegen-plugin - Overture CodeGen Maven Plugin + The Java Code Generator Maven Plugin @@ -59,8 +59,8 @@ - org.overturetool.core - codegen + org.overturetool.core.codegen + javagen ${project.version} diff --git a/core/codegen/codegen-runtime/pom.xml b/core/codegen/codegen-runtime/pom.xml index bffc84b03a..0cdf760e36 100644 --- a/core/codegen/codegen-runtime/pom.xml +++ b/core/codegen/codegen-runtime/pom.xml @@ -2,15 +2,15 @@ 4.0.0 - org.overturetool - core + org.overturetool.core + codegen 2.2.3-SNAPSHOT ../pom.xml - org.overturetool.core + org.overturetool.core.codegen codegen-runtime - VDM Code Generator Runtime + The Java Code Generator Runtime diff --git a/core/codegen/javagen/pom.xml b/core/codegen/javagen/pom.xml index 0632c5bd10..ec8f88017c 100644 --- a/core/codegen/javagen/pom.xml +++ b/core/codegen/javagen/pom.xml @@ -2,18 +2,18 @@ 4.0.0 - org.overturetool - core + org.overturetool.core + codegen 2.2.3-SNAPSHOT ../pom.xml - org.overturetool.core - codegen - VDM Code Generator + org.overturetool.core.codegen + javagen + The Java Code Generator - 1.6.7-SNAPSHOT + 1.6.6 @@ -43,7 +43,7 @@ ${project.version} - org.overturetool.core + org.overturetool.core.codegen codegen-runtime ${project.version} diff --git a/core/codegen/pom.xml b/core/codegen/pom.xml new file mode 100644 index 0000000000..318ff33334 --- /dev/null +++ b/core/codegen/pom.xml @@ -0,0 +1,24 @@ + + 4.0.0 + + + core + org.overturetool + 2.2.3-SNAPSHOT + ../pom.xml + + + pom + + org.overturetool.core + codegen + Code Generation + + + javagen + codegen-runtime + codegen-maven-plugin + + + + diff --git a/core/pom.xml b/core/pom.xml index 55a1c0416e..27041300ef 100644 --- a/core/pom.xml +++ b/core/pom.xml @@ -25,8 +25,6 @@ commandline vdmjc codegen - codegen-runtime - cgisa guibuilder modelcheckers diff --git a/ide/plugins/codegen/META-INF/MANIFEST.MF b/ide/plugins/codegen/META-INF/MANIFEST.MF index a85ac6ea4b..d0656c98c0 100644 --- a/ide/plugins/codegen/META-INF/MANIFEST.MF +++ b/ide/plugins/codegen/META-INF/MANIFEST.MF @@ -14,7 +14,7 @@ Require-Bundle: org.eclipse.ui.console, Bundle-Activator: org.overture.ide.plugins.codegen.Activator Bundle-RequiredExecutionEnvironment: JavaSE-1.7 Bundle-ClassPath: ., - jars/codegen.jar, + jars/javagen.jar, jars/commons-collections.jar, jars/commons-lang.jar, jars/jalopy.jar, diff --git a/ide/plugins/codegen/pom.xml b/ide/plugins/codegen/pom.xml index 8e45a04d2b..8ad1614f00 100644 --- a/ide/plugins/codegen/pom.xml +++ b/ide/plugins/codegen/pom.xml @@ -13,7 +13,7 @@ org.overturetool.ide.plugins org.overture.ide.plugins.codegen - Code Generator Plugin + The Java Code Generator Plugin @@ -35,13 +35,13 @@ true - org.overturetool.core + org.overturetool.core.codegen codegen-runtime ${project.version} - org.overturetool.core - codegen + org.overturetool.core.codegen + javagen ${project.version} @@ -81,7 +81,7 @@ - org.overturetool.core + org.overturetool.core.codegen codegen-runtime ${project.version} jar @@ -90,7 +90,7 @@ codegen-runtime.jar - org.overturetool.core + org.overturetool.core.codegen codegen-runtime ${project.version} sources From 2c465b2f13f2410676ea7634d3cb62e6d2883f03 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Mon, 9 Mar 2015 18:29:17 +0100 Subject: [PATCH 268/323] Slight improvement to checking of Java keywords --- .../overture/codegen/utils/GeneralCodeGenUtils.java | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/core/codegen/javagen/src/main/java/org/overture/codegen/utils/GeneralCodeGenUtils.java b/core/codegen/javagen/src/main/java/org/overture/codegen/utils/GeneralCodeGenUtils.java index f4f51e1873..b472bf6979 100644 --- a/core/codegen/javagen/src/main/java/org/overture/codegen/utils/GeneralCodeGenUtils.java +++ b/core/codegen/javagen/src/main/java/org/overture/codegen/utils/GeneralCodeGenUtils.java @@ -416,10 +416,19 @@ public static boolean isQuote(SDeclCG decl) public static boolean isJavaKeyword(String s) { - if(s == null || s.isEmpty()) + if(s == null) { return false; } + else + { + s = s.trim(); + + if(s.isEmpty()) + { + return false; + } + } for(String kw : IJavaCodeGenConstants.RESERVED_WORDS) { From c3dd1071dde3320ae1c7f94f3ebebaf0daffcd67 Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Tue, 10 Mar 2015 11:07:57 +0100 Subject: [PATCH 269/323] Make IRStatus generic on INodes [Issue: #428] --- .../codegen/ir/IRClassDeclStatus.java | 50 ------------------- .../org/overture/codegen/ir/IRExpStatus.java | 43 ---------------- .../org/overture/codegen/ir/IRStatus.java | 30 ++++++++++- .../codegen/vdm2java/JavaCodeGen.java | 43 ++++++++-------- 4 files changed, 49 insertions(+), 117 deletions(-) delete mode 100644 core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRClassDeclStatus.java delete mode 100644 core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRExpStatus.java diff --git a/core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRClassDeclStatus.java b/core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRClassDeclStatus.java deleted file mode 100644 index ec023510ef..0000000000 --- a/core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRClassDeclStatus.java +++ /dev/null @@ -1,50 +0,0 @@ -/* - * #%~ - * VDM Code Generator - * %% - * Copyright (C) 2008 - 2014 Overture - * %% - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as - * published by the Free Software Foundation, either version 3 of the - * License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public - * License along with this program. If not, see - * . - * #~% - */ -package org.overture.codegen.ir; - -import java.util.Set; - -import org.overture.codegen.cgast.declarations.AClassDeclCG; - -public class IRClassDeclStatus extends IRStatus -{ - protected String className; - protected AClassDeclCG classCg; - - public IRClassDeclStatus(String className, AClassDeclCG classCg, - Set unsupportedNodes) - { - super(unsupportedNodes); - this.className = className; - this.classCg = classCg; - } - - public String getClassName() - { - return className; - } - - public AClassDeclCG getClassCg() - { - return classCg; - } -} diff --git a/core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRExpStatus.java b/core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRExpStatus.java deleted file mode 100644 index 0cbaa87e21..0000000000 --- a/core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRExpStatus.java +++ /dev/null @@ -1,43 +0,0 @@ -/* - * #%~ - * VDM Code Generator - * %% - * Copyright (C) 2008 - 2014 Overture - * %% - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as - * published by the Free Software Foundation, either version 3 of the - * License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public - * License along with this program. If not, see - * . - * #~% - */ -package org.overture.codegen.ir; - -import java.util.Set; - -import org.overture.codegen.cgast.SExpCG; - -public class IRExpStatus extends IRStatus -{ - private SExpCG expCg; - - public IRExpStatus(SExpCG expCg, Set unsupportedNodes) - { - super(unsupportedNodes); - this.expCg = expCg; - } - - public SExpCG getExpCg() - { - return expCg; - } - -} diff --git a/core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRStatus.java b/core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRStatus.java index 67fba286b6..48baf4f7ca 100644 --- a/core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRStatus.java +++ b/core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRStatus.java @@ -24,10 +24,14 @@ import java.util.HashSet; import java.util.Set; -public class IRStatus +import org.overture.codegen.cgast.INode; + +public class IRStatus { protected Set unsupportedInIr; protected Set transformationWarnings; + protected T node; + protected String nodeName; public IRStatus(Set unsupportedInIr) { @@ -35,11 +39,19 @@ public IRStatus(Set unsupportedInIr) this.transformationWarnings = new HashSet(); } + public IRStatus(String nodeName, T node, + Set unsupportedNodes) + { + this(unsupportedNodes); + this.nodeName = nodeName; + this.node = node; + } + public Set getUnsupportedInIr() { return unsupportedInIr; } - + public void addTransformationWarnings(Set transformationWarnings) { this.transformationWarnings.addAll(transformationWarnings); @@ -54,4 +66,18 @@ public Set getTransformationWarnings() { return transformationWarnings; } + + public T getIrNode() + { + return node; + } + + public void setIrNode(T newNode) + { + this.node = newNode; + } + + public String getIrNodeName(){ + return nodeName; + } } diff --git a/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java index cfe2ddb19c..57dac376ce 100644 --- a/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java +++ b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java @@ -62,9 +62,8 @@ import org.overture.codegen.cgast.declarations.AClassDeclCG; import org.overture.codegen.cgast.declarations.AInterfaceDeclCG; import org.overture.codegen.ir.CodeGenBase; -import org.overture.codegen.ir.IRClassDeclStatus; +import org.overture.codegen.ir.IRStatus; import org.overture.codegen.ir.IRConstants; -import org.overture.codegen.ir.IRExpStatus; import org.overture.codegen.ir.IrNodeInfo; import org.overture.codegen.ir.VdmNodeInfo; import org.overture.codegen.logging.ILogger; @@ -238,7 +237,7 @@ public GeneratedData generateJavaFromVdm( InvalidNamesResult invalidNamesResult = validateVdmModelNames(userClasses); validateVdmModelingConstructs(userClasses); - List statuses = new ArrayList(); + List> statuses = new ArrayList>(); for (SClassDefinition classDef : ast) { @@ -247,9 +246,9 @@ public GeneratedData generateJavaFromVdm( if(getJavaSettings().getJavaRootPackage() != null) { - for(IRClassDeclStatus irStatus : statuses) + for(IRStatus irStatus : statuses) { - irStatus.getClassCg().setPackage(getJavaSettings().getJavaRootPackage()); + irStatus.getIrNode().setPackage(getJavaSettings().getJavaRootPackage()); } } @@ -257,17 +256,17 @@ public GeneratedData generateJavaFromVdm( List classes = getClassDecls(statuses); javaFormat.setClasses(classes); - LinkedList canBeGenerated = new LinkedList(); + LinkedList> canBeGenerated = new LinkedList>(); List generated = new ArrayList(); - for (IRClassDeclStatus status : statuses) + for (IRStatus status : statuses) { if (status.canBeGenerated()) { canBeGenerated.add(status); } else { - generated.add(new GeneratedModule(status.getClassName(), status.getUnsupportedInIr(), new HashSet())); + generated.add(new GeneratedModule(status.getIrNodeName(), status.getUnsupportedInIr(), new HashSet())); } } @@ -278,19 +277,19 @@ public GeneratedData generateJavaFromVdm( for (DepthFirstAnalysisAdaptor transformation : analyses) { - for (IRClassDeclStatus status : canBeGenerated) + for (IRStatus status : canBeGenerated) { try { - if (!getInfo().getDeclAssistant().isLibraryName(status.getClassName())) + if (!getInfo().getDeclAssistant().isLibraryName(status.getIrNodeName())) { - generator.applyTransformation(status, transformation); + generator.applyPartialTransformation(status, transformation); } } catch (org.overture.codegen.cgast.analysis.AnalysisException e) { Logger.getLog().printErrorln("Error when generating code for class " - + status.getClassName() + ": " + e.getMessage()); + + status.getIrNodeName() + ": " + e.getMessage()); Logger.getLog().printErrorln("Skipping class.."); e.printStackTrace(); } @@ -302,12 +301,12 @@ public GeneratedData generateJavaFromVdm( MergeVisitor mergeVisitor = javaFormat.getMergeVisitor(); javaFormat.setFunctionValueAssistant(functionValueAssistant); - for (IRClassDeclStatus status : canBeGenerated) + for (IRStatus status : canBeGenerated) { StringWriter writer = new StringWriter(); - AClassDeclCG classCg = status.getClassCg(); - String className = status.getClassName(); - SClassDefinition vdmClass = (SClassDefinition) status.getClassCg().getSourceNode().getVdmNode(); + AClassDeclCG classCg = status.getIrNode(); + String className = status.getIrNodeName(); + SClassDefinition vdmClass = (SClassDefinition) status.getIrNode().getSourceNode().getVdmNode(); if(vdmClass == mainClass) { @@ -349,7 +348,7 @@ else if(mergeVisitor.hasUnsupportedTargLangNodes()) } catch (org.overture.codegen.cgast.analysis.AnalysisException e) { Logger.getLog().printErrorln("Error generating code for class " - + status.getClassName() + ": " + e.getMessage()); + + status.getIrNodeName() + ": " + e.getMessage()); Logger.getLog().printErrorln("Skipping class.."); e.printStackTrace(); } @@ -509,13 +508,13 @@ else if (def instanceof SFunctionDefinition) } } - private List getClassDecls(List statuses) + private List getClassDecls(List> statuses) { List classDecls = new LinkedList(); - for (IRClassDeclStatus status : statuses) + for (IRStatus status : statuses) { - AClassDeclCG classCg = status.getClassCg(); + AClassDeclCG classCg = status.getIrNode(); if (classCg != null) { @@ -529,13 +528,13 @@ private List getClassDecls(List statuses) public Generated generateJavaFromVdmExp(PExp exp) throws AnalysisException { // There is no name validation here. - IRExpStatus expStatus = generator.generateFrom(exp); + IRStatus expStatus = generator.generateFrom(exp); StringWriter writer = new StringWriter(); try { - SExpCG expCg = expStatus.getExpCg(); + SExpCG expCg = expStatus.getIrNode(); if (expStatus.canBeGenerated()) { From 8e5231eadc6f234c96584b45d7bade99559b162a Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Tue, 10 Mar 2015 11:08:46 +0100 Subject: [PATCH 270/323] Add total transformation interface and use it in IRGenerator # description [Issue: #428] --- .../org/overture/codegen/ir/IRGenerator.java | 39 +++++++++++++------ .../codegen/trans/ITotalTransformation.java | 11 ++++++ 2 files changed, 38 insertions(+), 12 deletions(-) create mode 100644 core/codegen/javagen/src/main/java/org/overture/codegen/trans/ITotalTransformation.java diff --git a/core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRGenerator.java b/core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRGenerator.java index aea3b51329..150fc62852 100644 --- a/core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRGenerator.java +++ b/core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRGenerator.java @@ -26,14 +26,14 @@ import java.util.Set; import org.overture.ast.analysis.AnalysisException; -import org.overture.ast.analysis.intf.IAnalysis; import org.overture.ast.definitions.SClassDefinition; import org.overture.ast.expressions.PExp; +import org.overture.codegen.cgast.INode; import org.overture.codegen.cgast.SExpCG; -import org.overture.codegen.cgast.analysis.DepthFirstAnalysisAdaptor; import org.overture.codegen.cgast.declarations.AClassDeclCG; import org.overture.codegen.logging.ILogger; import org.overture.codegen.logging.Logger; +import org.overture.codegen.trans.ITotalTransformation; public class IRGenerator { @@ -44,13 +44,13 @@ public IRGenerator(ILogger log, String objectInitCallPrefix) this.codeGenInfo = new IRInfo(objectInitCallPrefix); Logger.setLog(log); } - + public void clear() { codeGenInfo.clear(); } - public IRClassDeclStatus generateFrom(SClassDefinition classDef) + public IRStatus generateFrom(SClassDefinition classDef) throws AnalysisException { codeGenInfo.clearNodes(); @@ -58,27 +58,42 @@ public IRClassDeclStatus generateFrom(SClassDefinition classDef) AClassDeclCG classCg = classDef.apply(codeGenInfo.getClassVisitor(), codeGenInfo); Set unsupportedNodes = new HashSet(codeGenInfo.getUnsupportedNodes()); - return new IRClassDeclStatus(classDef.getName().getName(), classCg, unsupportedNodes); + return new IRStatus(classDef.getName().getName(), classCg, unsupportedNodes); + } + + public void applyPartialTransformation(IRStatus status, + org.overture.codegen.cgast.analysis.intf.IAnalysis transformation) + throws org.overture.codegen.cgast.analysis.AnalysisException + { + codeGenInfo.clearTransformationWarnings(); + + status.getIrNode().apply(transformation); + HashSet transformationWarnings = new HashSet(codeGenInfo.getTransformationWarnings()); + + status.addTransformationWarnings(transformationWarnings); } - - public void applyTransformation(IRClassDeclStatus status, org.overture.codegen.cgast.analysis.intf.IAnalysis transformation) throws org.overture.codegen.cgast.analysis.AnalysisException + + public void applyTotalTransformation(IRStatus status, + ITotalTransformation trans) + throws org.overture.codegen.cgast.analysis.AnalysisException { codeGenInfo.clearTransformationWarnings(); - - status.getClassCg().apply(transformation); + + status.getIrNode().apply(trans); HashSet transformationWarnings = new HashSet(codeGenInfo.getTransformationWarnings()); - status.addTransformationWarnings(transformationWarnings); + status.setIrNode(trans.getResult()); + } - public IRExpStatus generateFrom(PExp exp) throws AnalysisException + public IRStatus generateFrom(PExp exp) throws AnalysisException { codeGenInfo.clearNodes(); SExpCG expCg = exp.apply(codeGenInfo.getExpVisitor(), codeGenInfo); Set unsupportedNodes = new HashSet(codeGenInfo.getUnsupportedNodes()); - return new IRExpStatus(expCg, unsupportedNodes); + return new IRStatus("expression",expCg, unsupportedNodes); } public List getQuoteValues() diff --git a/core/codegen/javagen/src/main/java/org/overture/codegen/trans/ITotalTransformation.java b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/ITotalTransformation.java new file mode 100644 index 0000000000..8f2c5f9aeb --- /dev/null +++ b/core/codegen/javagen/src/main/java/org/overture/codegen/trans/ITotalTransformation.java @@ -0,0 +1,11 @@ +package org.overture.codegen.trans; + +import org.overture.codegen.cgast.INode; +import org.overture.codegen.cgast.analysis.intf.IAnalysis; + +public interface ITotalTransformation extends IAnalysis +{ + + public INode getResult(); + +} From 7ab7acec18a8a2cee2071fa79275ddde00d39830 Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Tue, 10 Mar 2015 14:22:57 +0100 Subject: [PATCH 271/323] Move astCreator version property to toplevel codegen pom. # description [Issue: #428] --- core/codegen/cgisa/pom.xml | 4 ---- core/codegen/javagen/pom.xml | 4 ---- core/codegen/pom.xml | 4 ++++ 3 files changed, 4 insertions(+), 8 deletions(-) diff --git a/core/codegen/cgisa/pom.xml b/core/codegen/cgisa/pom.xml index e5a9849899..49efae4691 100644 --- a/core/codegen/cgisa/pom.xml +++ b/core/codegen/cgisa/pom.xml @@ -12,10 +12,6 @@ cgisa The VDM to Isabelle Translator - - 1.6.7-SNAPSHOT - - org.overturetool.core diff --git a/core/codegen/javagen/pom.xml b/core/codegen/javagen/pom.xml index ec8f88017c..abfa242b77 100644 --- a/core/codegen/javagen/pom.xml +++ b/core/codegen/javagen/pom.xml @@ -12,10 +12,6 @@ javagen The Java Code Generator - - 1.6.6 - - junit diff --git a/core/codegen/pom.xml b/core/codegen/pom.xml index 318ff33334..2238f72666 100644 --- a/core/codegen/pom.xml +++ b/core/codegen/pom.xml @@ -14,6 +14,10 @@ codegen Code Generation + + 1.6.6 + + javagen codegen-runtime From ccca4dedabe8db335ccaa4b10ed274a10c75011f Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Tue, 10 Mar 2015 15:01:24 +0100 Subject: [PATCH 272/323] Refactor nodename in the IrStatus # description [Issue: #428] --- .../org/overture/codegen/ir/IRStatus.java | 19 ++++++++++++------- 1 file changed, 12 insertions(+), 7 deletions(-) diff --git a/core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRStatus.java b/core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRStatus.java index 48baf4f7ca..7010747d7c 100644 --- a/core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRStatus.java +++ b/core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRStatus.java @@ -31,7 +31,7 @@ public class IRStatus protected Set unsupportedInIr; protected Set transformationWarnings; protected T node; - protected String nodeName; + protected String irNodeName; public IRStatus(Set unsupportedInIr) { @@ -39,14 +39,13 @@ public IRStatus(Set unsupportedInIr) this.transformationWarnings = new HashSet(); } - public IRStatus(String nodeName, T node, - Set unsupportedNodes) + public IRStatus(String nodeName, T node, Set unsupportedNodes) { this(unsupportedNodes); - this.nodeName = nodeName; + this.irNodeName = nodeName; this.node = node; } - + public Set getUnsupportedInIr() { return unsupportedInIr; @@ -77,7 +76,13 @@ public void setIrNode(T newNode) this.node = newNode; } - public String getIrNodeName(){ - return nodeName; + public String getIrNodeName() + { + return irNodeName; + } + + public void setIrNodeName(String irNodeName) + { + this.irNodeName = irNodeName; } } From 944a5731bd5a5b69c7539e09892aabecca359608 Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Tue, 10 Mar 2015 15:03:33 +0100 Subject: [PATCH 273/323] Make IR transformation machinery more generic The committed classes now operate over INodes instead of AClassDecls. We can now apply arbitrary tree transformations. [Issue: #428] --- .../org/overture/codegen/ir/IRGenerator.java | 7 +++---- .../codegen/utils/GeneralCodeGenUtils.java | 3 ++- .../overture/codegen/utils/GeneratedModule.java | 16 ++++++++-------- 3 files changed, 13 insertions(+), 13 deletions(-) diff --git a/core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRGenerator.java b/core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRGenerator.java index 150fc62852..2993acb60b 100644 --- a/core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRGenerator.java +++ b/core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRGenerator.java @@ -50,7 +50,7 @@ public void clear() codeGenInfo.clear(); } - public IRStatus generateFrom(SClassDefinition classDef) + public IRStatus generateFrom(SClassDefinition classDef) throws AnalysisException { codeGenInfo.clearNodes(); @@ -58,10 +58,10 @@ public IRStatus generateFrom(SClassDefinition classDef) AClassDeclCG classCg = classDef.apply(codeGenInfo.getClassVisitor(), codeGenInfo); Set unsupportedNodes = new HashSet(codeGenInfo.getUnsupportedNodes()); - return new IRStatus(classDef.getName().getName(), classCg, unsupportedNodes); + return new IRStatus(classDef.getName().getName(), classCg, unsupportedNodes); } - public void applyPartialTransformation(IRStatus status, + public void applyPartialTransformation(IRStatus status, org.overture.codegen.cgast.analysis.intf.IAnalysis transformation) throws org.overture.codegen.cgast.analysis.AnalysisException { @@ -83,7 +83,6 @@ public void applyTotalTransformation(IRStatus status, HashSet transformationWarnings = new HashSet(codeGenInfo.getTransformationWarnings()); status.addTransformationWarnings(transformationWarnings); status.setIrNode(trans.getResult()); - } public IRStatus generateFrom(PExp exp) throws AnalysisException diff --git a/core/codegen/javagen/src/main/java/org/overture/codegen/utils/GeneralCodeGenUtils.java b/core/codegen/javagen/src/main/java/org/overture/codegen/utils/GeneralCodeGenUtils.java index b472bf6979..054eb54388 100644 --- a/core/codegen/javagen/src/main/java/org/overture/codegen/utils/GeneralCodeGenUtils.java +++ b/core/codegen/javagen/src/main/java/org/overture/codegen/utils/GeneralCodeGenUtils.java @@ -44,6 +44,7 @@ import org.overture.ast.typechecker.NameScope; import org.overture.ast.types.AVoidType; import org.overture.ast.util.definitions.ClassList; +import org.overture.codegen.cgast.INode; import org.overture.codegen.cgast.SDeclCG; import org.overture.codegen.cgast.declarations.AClassDeclCG; import org.overture.codegen.ir.ITempVarGen; @@ -400,7 +401,7 @@ public static String getFolderFromJavaRootPackage(String pack) } } - public static boolean isQuote(SDeclCG decl) + public static boolean isQuote(INode decl) { if(decl instanceof AClassDeclCG) { diff --git a/core/codegen/javagen/src/main/java/org/overture/codegen/utils/GeneratedModule.java b/core/codegen/javagen/src/main/java/org/overture/codegen/utils/GeneratedModule.java index f7404de691..65c9c1ed2b 100644 --- a/core/codegen/javagen/src/main/java/org/overture/codegen/utils/GeneratedModule.java +++ b/core/codegen/javagen/src/main/java/org/overture/codegen/utils/GeneratedModule.java @@ -24,20 +24,20 @@ import java.util.List; import java.util.Set; -import org.overture.codegen.cgast.SDeclCG; +import org.overture.codegen.cgast.INode; import org.overture.codegen.ir.IrNodeInfo; import org.overture.codegen.ir.VdmNodeInfo; public class GeneratedModule extends Generated { private String name; - private SDeclCG irDecl; + private INode irNode; - public GeneratedModule(String name, SDeclCG irDecl, String content) + public GeneratedModule(String name, INode irDecl, String content) { super(content); this.name = name; - this.irDecl = irDecl; + this.irNode = irDecl; } public GeneratedModule(String name, Set unsupportedIrNodes, Set unsupportedInTargLang) @@ -46,11 +46,11 @@ public GeneratedModule(String name, Set unsupportedIrNodes, Set mergeErrors) + public GeneratedModule(String name, INode irDecl, List mergeErrors) { super(mergeErrors); this.name = name; - this.irDecl = irDecl; + this.irNode = irDecl; } public String getName() @@ -58,8 +58,8 @@ public String getName() return name; } - public SDeclCG getIrDecl() + public INode getIrNode() { - return irDecl; + return irNode; } } From 9d83bc7b7ff94c75194e8e710d608c0f30a9f0f3 Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Tue, 10 Mar 2015 15:04:20 +0100 Subject: [PATCH 274/323] Make JavaCG cope with more generic transformation mechanism We are forced to use guarded casts to Class Decls since all the Java transformations rely on being applied to a class decl specifically. [Issue: #428] --- .../codegen/vdm2java/JavaCodeGen.java | 201 +++++++++--------- 1 file changed, 106 insertions(+), 95 deletions(-) diff --git a/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java index 57dac376ce..601014431f 100644 --- a/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java +++ b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java @@ -87,24 +87,24 @@ public class JavaCodeGen extends CodeGenBase // Classes used from the Java standard library "Utils", "Record", "Long", "Double", "Character", "String", "List", "Set" }; - + public static final String JAVA_QUOTE_NAME_SUFFIX = "Quote"; public static final String JAVA_MAIN_CLASS_NAME = "Main"; - + private JavaFormat javaFormat; private TemplateStructure javaTemplateStructure; - + public JavaCodeGen() { super(null); init(); } - + public void setJavaTemplateStructure(TemplateStructure javaTemplateStructure) { this.javaTemplateStructure = javaTemplateStructure; } - + public TemplateStructure getJavaTemplateStructure() { return javaTemplateStructure; @@ -114,7 +114,7 @@ public void setJavaSettings(JavaSettings javaSettings) { this.javaFormat.setJavaSettings(javaSettings); } - + public JavaSettings getJavaSettings() { return this.javaFormat.getJavaSettings(); @@ -134,7 +134,7 @@ private void init() this.transAssistant = new TransAssistantCG(generator.getIRInfo(), varPrefixes); this.javaFormat = new JavaFormat(varPrefixes, javaTemplateStructure, generator.getIRInfo()); } - + public void clear() { javaFormat.init(); @@ -146,7 +146,7 @@ private void initVelocity() Velocity.setProperty("runtime.log.logsystem.class", "org.apache.velocity.runtime.log.NullLogSystem"); Velocity.init(); } - + public JavaFormat getJavaFormat() { return javaFormat; @@ -164,24 +164,23 @@ public List generateJavaFromVdmQuotes() } javaFormat.init(); - - JavaQuoteValueCreator quoteValueCreator = new JavaQuoteValueCreator(generator.getIRInfo(), - transAssistant); - + + JavaQuoteValueCreator quoteValueCreator = new JavaQuoteValueCreator(generator.getIRInfo(), transAssistant); + List modules = new LinkedList(); - for(String quoteNameVdm : quoteValues) + for (String quoteNameVdm : quoteValues) { AClassDeclCG quoteDecl = quoteValueCreator.consQuoteValue(quoteNameVdm + JAVA_QUOTE_NAME_SUFFIX, getJavaSettings().getJavaRootPackage()); - + StringWriter writer = new StringWriter(); quoteDecl.apply(javaFormat.getMergeVisitor(), writer); String code = writer.toString(); String formattedJavaCode = JavaCodeGenUtil.formatJavaCode(code); - + modules.add(new GeneratedModule(quoteNameVdm, quoteDecl, formattedJavaCode)); } - + return modules; } catch (org.overture.codegen.cgast.analysis.AnalysisException e) @@ -193,39 +192,38 @@ public List generateJavaFromVdmQuotes() return null; } - - public GeneratedData generateJavaFromVdm( - List ast) throws AnalysisException, - UnsupportedModelingException + + public GeneratedData generateJavaFromVdm(List ast) + throws AnalysisException, UnsupportedModelingException { SClassDefinition mainClass = null; - + List warnings = new LinkedList(); - if(getJavaSettings().getVdmEntryExp() != null) + if (getJavaSettings().getVdmEntryExp() != null) { try { - mainClass = GeneralCodeGenUtils.consMainClass(ast, getJavaSettings().getVdmEntryExp(), - Settings.dialect, JAVA_MAIN_CLASS_NAME, getInfo().getTempVarNameGen()); + mainClass = GeneralCodeGenUtils.consMainClass(ast, getJavaSettings().getVdmEntryExp(), Settings.dialect, JAVA_MAIN_CLASS_NAME, getInfo().getTempVarNameGen()); ast.add(mainClass); } catch (Exception e) { // It can go wrong if the VDM entry point does not type check - warnings.add("The chosen launch configuration could not be type checked: " + e.getMessage()); + warnings.add("The chosen launch configuration could not be type checked: " + + e.getMessage()); warnings.add("Skipping launch configuration.."); } } - + List userClasses = getUserClasses(ast); - + List allRenamings = normaliseIdentifiers(userClasses); computeDefTable(userClasses); - + // To document any renaming of variables shadowing other variables removeUnreachableStms(ast); - + allRenamings.addAll(performRenaming(userClasses, getInfo().getIdStateDesignatorDefs())); - + for (SClassDefinition classDef : ast) { if (generator.getIRInfo().getAssistantManager().getDeclAssistant().classIsLibrary(classDef)) @@ -237,21 +235,36 @@ public GeneratedData generateJavaFromVdm( InvalidNamesResult invalidNamesResult = validateVdmModelNames(userClasses); validateVdmModelingConstructs(userClasses); - List> statuses = new ArrayList>(); + List> temp = new ArrayList<>(); + List> statuses = new ArrayList<>(); for (SClassDefinition classDef : ast) { - statuses.add(generator.generateFrom(classDef)); + temp.add(generator.generateFrom(classDef)); + } + + // All our transformations are partial so we need to + // cast the INodes down to Class Decls + //TODO add class extraction method as part of refactoring towards + // a more generic codegen framework + for (IRStatus t : temp) + { + if (t.getIrNode() instanceof AClassDeclCG) + { + IRStatus newStatus = new IRStatus(t.getUnsupportedInIr()); + newStatus.setIrNode((AClassDeclCG) t.getIrNode()); + newStatus.setIrNodeName(t.getIrNodeName()); + statuses.add(newStatus); + } } - - if(getJavaSettings().getJavaRootPackage() != null) + + if (getJavaSettings().getJavaRootPackage() != null) { - for(IRStatus irStatus : statuses) + for (IRStatus irStatus : statuses) { irStatus.getIrNode().setPackage(getJavaSettings().getJavaRootPackage()); } } - List classes = getClassDecls(statuses); javaFormat.setClasses(classes); @@ -269,7 +282,7 @@ public GeneratedData generateJavaFromVdm( generated.add(new GeneratedModule(status.getIrNodeName(), status.getUnsupportedInIr(), new HashSet())); } } - + FunctionValueAssistant functionValueAssistant = new FunctionValueAssistant(); JavaTransSeries javaTransSeries = new JavaTransSeries(this); @@ -295,9 +308,9 @@ public GeneratedData generateJavaFromVdm( } } } - + List skipping = new LinkedList(); - + MergeVisitor mergeVisitor = javaFormat.getMergeVisitor(); javaFormat.setFunctionValueAssistant(functionValueAssistant); @@ -307,8 +320,8 @@ public GeneratedData generateJavaFromVdm( AClassDeclCG classCg = status.getIrNode(); String className = status.getIrNodeName(); SClassDefinition vdmClass = (SClassDefinition) status.getIrNode().getSourceNode().getVdmNode(); - - if(vdmClass == mainClass) + + if (vdmClass == mainClass) { classCg.setTag(new JavaMainTag(classCg)); } @@ -320,24 +333,21 @@ public GeneratedData generateJavaFromVdm( if (shouldBeGenerated(vdmClass, generator.getIRInfo().getAssistantManager().getDeclAssistant())) { classCg.apply(mergeVisitor, writer); - + if (mergeVisitor.hasMergeErrors()) { generated.add(new GeneratedModule(className, classCg, mergeVisitor.getMergeErrors())); - } - else if(mergeVisitor.hasUnsupportedTargLangNodes()) + } else if (mergeVisitor.hasUnsupportedTargLangNodes()) { generated.add(new GeneratedModule(className, new HashSet(), mergeVisitor.getUnsupportedInTargLang())); - } - else + } else { String formattedJavaCode = JavaCodeGenUtil.formatJavaCode(writer.toString()); GeneratedModule generatedModule = new GeneratedModule(className, classCg, formattedJavaCode); generatedModule.setTransformationWarnings(status.getTransformationWarnings()); generated.add(generatedModule); } - } - else + } else { if (!skipping.contains(vdmClass.getName().getName())) { @@ -385,7 +395,7 @@ else if(mergeVisitor.hasUnsupportedTargLangNodes()) data.setSkippedClasses(skipping); data.setAllRenamings(allRenamings); data.setWarnings(warnings); - + return data; } @@ -393,7 +403,7 @@ private List getUserClasses( List mergedParseLists) { List userClasses = new LinkedList(); - + for (SClassDefinition clazz : mergedParseLists) { if (!getInfo().getDeclAssistant().classIsLibrary(clazz)) @@ -404,8 +414,8 @@ private List getUserClasses( return userClasses; } - private List normaliseIdentifiers(List userClasses) - throws AnalysisException + private List normaliseIdentifiers( + List userClasses) throws AnalysisException { NameCollector collector = new NameCollector(); @@ -422,16 +432,16 @@ private List normaliseIdentifiers(List userClasses) { clazz.apply(normaliser); } - + VarRenamer renamer = new VarRenamer(); - + List renamings = normaliser.getRenamings(); - + for (SClassDefinition clazz : userClasses) { renamer.rename(clazz, renamings); } - + return renamings; } @@ -439,48 +449,51 @@ private void computeDefTable(List mergedParseLists) throws AnalysisException { List classesToConsider = new LinkedList<>(); - - for(SClassDefinition c : mergedParseLists) + + for (SClassDefinition c : mergedParseLists) { - if(!getInfo().getDeclAssistant().classIsLibrary(c)) + if (!getInfo().getDeclAssistant().classIsLibrary(c)) { classesToConsider.add(c); } } - + Map idDefs = IdStateDesignatorDefCollector.getIdDefs(classesToConsider); getInfo().setIdStateDesignatorDefs(idDefs); } - private void removeUnreachableStms(List mergedParseLists) throws AnalysisException + private void removeUnreachableStms(List mergedParseLists) + throws AnalysisException { UnreachableStmRemover remover = new UnreachableStmRemover(); - - for(SClassDefinition clazz : mergedParseLists) + + for (SClassDefinition clazz : mergedParseLists) { clazz.apply(remover); } } - private List performRenaming(List mergedParseLists, Map idDefs) + private List performRenaming( + List mergedParseLists, + Map idDefs) throws AnalysisException { List allRenamings = new LinkedList(); - + VarShadowingRenameCollector renamingsCollector = new VarShadowingRenameCollector(generator.getIRInfo().getTcFactory(), idDefs); VarRenamer renamer = new VarRenamer(); - + for (SClassDefinition classDef : mergedParseLists) { List classRenamings = renamer.computeRenamings(classDef, renamingsCollector); - - if(!classRenamings.isEmpty()) + + if (!classRenamings.isEmpty()) { renamer.rename(classDef, classRenamings); allRenamings.addAll(classRenamings); } } - + return allRenamings; } @@ -491,15 +504,14 @@ private void simplifyLibraryClass(SClassDefinition classDef) if (def instanceof SOperationDefinition) { SOperationDefinition op = (SOperationDefinition) def; - + op.setBody(new ANotYetSpecifiedStm()); op.setPrecondition(null); op.setPostcondition(null); - } - else if (def instanceof SFunctionDefinition) + } else if (def instanceof SFunctionDefinition) { SFunctionDefinition func = (SFunctionDefinition) def; - + func.setBody(new ANotYetSpecifiedExp()); func.setPrecondition(null); func.setPostcondition(null); @@ -508,14 +520,15 @@ else if (def instanceof SFunctionDefinition) } } - private List getClassDecls(List> statuses) + private List getClassDecls( + List> statuses) { List classDecls = new LinkedList(); for (IRStatus status : statuses) { AClassDeclCG classCg = status.getIrNode(); - + if (classCg != null) { classDecls.add(classCg); @@ -541,16 +554,14 @@ public Generated generateJavaFromVdmExp(PExp exp) throws AnalysisException javaFormat.init(); MergeVisitor mergeVisitor = javaFormat.getMergeVisitor(); expCg.apply(mergeVisitor, writer); - + if (mergeVisitor.hasMergeErrors()) { return new Generated(mergeVisitor.getMergeErrors()); - } - else if(mergeVisitor.hasUnsupportedTargLangNodes()) + } else if (mergeVisitor.hasUnsupportedTargLangNodes()) { return new Generated(new HashSet(), mergeVisitor.getUnsupportedInTargLang()); - } - else + } else { String code = writer.toString(); @@ -578,14 +589,14 @@ public void generateJavaSourceFile(File outputFolder, && !generatedModule.hasMergeErrors()) { String javaFileName = generatedModule.getName(); - - if(GeneralCodeGenUtils.isQuote(generatedModule.getIrDecl())) + + if (GeneralCodeGenUtils.isQuote(generatedModule.getIrNode())) { javaFileName += JAVA_QUOTE_NAME_SUFFIX; } - + javaFileName += IJavaCodeGenConstants.JAVA_FILE_EXTENSION; - + JavaCodeGenUtil.saveJavaClass(outputFolder, javaFileName, generatedModule.getContent()); } } @@ -643,21 +654,21 @@ private boolean shouldBeGenerated(SClassDefinition classDef, { return false; } - + String name = classDef.getName().getName(); - - if(getJavaSettings().getClassesToSkip().contains(name)) + + if (getJavaSettings().getClassesToSkip().contains(name)) { return false; } - -// for (SClassDefinition superDef : classDef.getSuperDefs()) -// { -// if (declAssistant.classIsLibrary(superDef)) -// { -// return false; -// } -// } + + // for (SClassDefinition superDef : classDef.getSuperDefs()) + // { + // if (declAssistant.classIsLibrary(superDef)) + // { + // return false; + // } + // } return true; } From 7a7830b74ed659b92ccb94a9ece50edd35fcbb35 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Tue, 10 Mar 2015 16:36:48 +0100 Subject: [PATCH 275/323] Small fix to the Java identifier normaliser: skip implicit names --- .../codegen/analysis/vdm/JavaIdentifierNormaliser.java | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/JavaIdentifierNormaliser.java b/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/JavaIdentifierNormaliser.java index ed4ac7be29..0fb454db17 100644 --- a/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/JavaIdentifierNormaliser.java +++ b/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/JavaIdentifierNormaliser.java @@ -31,6 +31,12 @@ public JavaIdentifierNormaliser(Set allNames, ITempVarGen nameGen) @Override public void inILexNameToken(ILexNameToken node) throws AnalysisException { + // "?" is used for implicitly named things + if(node.getName().equals("?")) + { + return; + } + if(!GeneralCodeGenUtils.isValidJavaIdentifier(node.getName())) { String newName = getReplacementName(node.getName()); From 2c3d6fbe9604298ed933349bf8e83ce6646b3f3a Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Tue, 10 Mar 2015 16:46:25 +0100 Subject: [PATCH 276/323] Fix to the identifier state designator definition collector The inherited definitions of a class were not taken into account --- .../vdm/IdStateDesignatorDefCollector.java | 28 ++++++++++++++----- .../codegen/vdm2java/JavaCodeGen.java | 2 +- .../codegen/tests/VarShadowingTestCase.java | 2 +- 3 files changed, 23 insertions(+), 9 deletions(-) diff --git a/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/IdStateDesignatorDefCollector.java b/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/IdStateDesignatorDefCollector.java index 33519653fe..5bb7a59be2 100644 --- a/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/IdStateDesignatorDefCollector.java +++ b/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/IdStateDesignatorDefCollector.java @@ -17,10 +17,13 @@ import org.overture.ast.definitions.AValueDefinition; import org.overture.ast.definitions.PDefinition; import org.overture.ast.definitions.SClassDefinition; +import org.overture.ast.intf.lex.ILexNameToken; import org.overture.ast.node.INode; import org.overture.ast.statements.ABlockSimpleBlockStm; import org.overture.ast.statements.AIdentifierStateDesignator; import org.overture.ast.statements.PStm; +import org.overture.codegen.logging.Logger; +import org.overture.typechecker.assistant.ITypeCheckerAssistantFactory; /** * Computes the definitions of identifier state designators @@ -33,22 +36,24 @@ public class IdStateDesignatorDefCollector extends VdmAnalysis private List defsInScope; private Map idDefs; private Set visited; + private ITypeCheckerAssistantFactory af; - public IdStateDesignatorDefCollector(INode topNode) + public IdStateDesignatorDefCollector(INode topNode, ITypeCheckerAssistantFactory af) { super(topNode); this.defsInScope = new LinkedList(); this.idDefs = new HashMap<>(); this.visited = new HashSet<>(); + this.af = af; } - public static Map getIdDefs(List classes) throws AnalysisException + public static Map getIdDefs(List classes, ITypeCheckerAssistantFactory af) throws AnalysisException { Map allDefs = new HashMap<>(); for(SClassDefinition clazz : classes) { - IdStateDesignatorDefCollector collector = new IdStateDesignatorDefCollector(clazz); + IdStateDesignatorDefCollector collector = new IdStateDesignatorDefCollector(clazz, af); clazz.apply(collector); allDefs.putAll(collector.idDefs); } @@ -65,10 +70,13 @@ public void caseAClassClassDefinition(AClassClassDefinition node) return; } + LinkedList allDefs = new LinkedList(node.getAllInheritedDefinitions()); + allDefs.addAll(node.getDefinitions()); + // Instance variables and values are visible to all operations - for(int i = 0; i < node.getDefinitions().size(); i++) + for(int i = 0; i < allDefs.size(); i++) { - PDefinition def = node.getDefinitions().get(i); + PDefinition def = allDefs.get(i); while(def instanceof AInheritedDefinition) { @@ -77,7 +85,7 @@ public void caseAClassClassDefinition(AClassClassDefinition node) if(def instanceof AInstanceVariableDefinition || def instanceof AValueDefinition) { - defsInScope.add(def); + defsInScope.addAll(af.createPDefinitionAssistant().getDefinitions(def)); } } @@ -131,7 +139,13 @@ public void caseAIdentifierStateDesignator(AIdentifierStateDesignator node) { PDefinition nextDef = defsInScope.get(i); - if(node.getName().equals(nextDef.getName())) + ILexNameToken defname = nextDef.getName(); + + if(defname == null) + { + Logger.getLog().printErrorln("Found definition name to be null in '" + this.getClass().getSimpleName() + "'"); + } + else if(node.getName().getName().equals(nextDef.getName().getName())) { this.idDefs.put(node, nextDef); break; diff --git a/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java index cfe2ddb19c..27f8f7caaa 100644 --- a/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java +++ b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java @@ -449,7 +449,7 @@ private void computeDefTable(List mergedParseLists) } } - Map idDefs = IdStateDesignatorDefCollector.getIdDefs(classesToConsider); + Map idDefs = IdStateDesignatorDefCollector.getIdDefs(classesToConsider, getInfo().getTcFactory()); getInfo().setIdStateDesignatorDefs(idDefs); } diff --git a/core/codegen/javagen/src/test/java/org/overture/codegen/tests/VarShadowingTestCase.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/VarShadowingTestCase.java index 7a6994b7d1..5b20bdfe89 100644 --- a/core/codegen/javagen/src/test/java/org/overture/codegen/tests/VarShadowingTestCase.java +++ b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/VarShadowingTestCase.java @@ -68,7 +68,7 @@ public void test() throws Exception try { TypeCheckResult> originalSpecTcResult = TypeCheckerUtil.typeCheckPp(file); - Map idDefs = IdStateDesignatorDefCollector.getIdDefs(originalSpecTcResult.result); + Map idDefs = IdStateDesignatorDefCollector.getIdDefs(originalSpecTcResult.result, af); Assert.assertTrue(getName() + " has type errors", originalSpecTcResult.errors.isEmpty()); Value orgSpecResult = evalSpec(originalSpecTcResult.result); From 156a9bd562f2a4ce7aa11a8f878147d01a33a6dc Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Tue, 10 Mar 2015 23:35:28 +0100 Subject: [PATCH 277/323] Added IR status conversion methods --- .../org/overture/codegen/ir/IRStatus.java | 53 ++++++++++++++++++- .../codegen/vdm2java/JavaCodeGen.java | 43 +++++---------- 2 files changed, 65 insertions(+), 31 deletions(-) diff --git a/core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRStatus.java b/core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRStatus.java index 7010747d7c..23c2a1127b 100644 --- a/core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRStatus.java +++ b/core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRStatus.java @@ -22,16 +22,18 @@ package org.overture.codegen.ir; import java.util.HashSet; +import java.util.LinkedList; +import java.util.List; import java.util.Set; import org.overture.codegen.cgast.INode; public class IRStatus { + protected String irNodeName; + protected T node; protected Set unsupportedInIr; protected Set transformationWarnings; - protected T node; - protected String irNodeName; public IRStatus(Set unsupportedInIr) { @@ -45,6 +47,12 @@ public IRStatus(String nodeName, T node, Set unsupportedNodes) this.irNodeName = nodeName; this.node = node; } + + public IRStatus(String nodeName, T node, Set unsupportedNodes, Set transformationWarnings) + { + this(nodeName, node, unsupportedNodes); + this.transformationWarnings = transformationWarnings; + } public Set getUnsupportedInIr() { @@ -65,6 +73,11 @@ public Set getTransformationWarnings() { return transformationWarnings; } + + public void setTransformationWarnings(Set transformationWarnings) + { + this.transformationWarnings = transformationWarnings; + } public T getIrNode() { @@ -85,4 +98,40 @@ public void setIrNodeName(String irNodeName) { this.irNodeName = irNodeName; } + + public static IRStatus extract( + IRStatus inputStatus, Class type) + { + String name = inputStatus.getIrNodeName(); + INode node = inputStatus.getIrNode(); + Set unsupportedInIr = inputStatus.getUnsupportedInIr(); + Set warnings = inputStatus.getTransformationWarnings(); + + if (node != null && type != null && type.isInstance(node)) + { + return new IRStatus(name, type.cast(node), unsupportedInIr, warnings); + } else + { + return null; + } + + } + + public static List> extract( + List> inputStatuses, Class type) + { + List> outputStatuses = new LinkedList>(); + + for (IRStatus status : inputStatuses) + { + IRStatus converted = extract(status, type); + + if (converted != null) + { + outputStatuses.add(converted); + } + } + + return outputStatuses; + } } diff --git a/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java index e7527d4380..19f3947cfc 100644 --- a/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java +++ b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java @@ -23,7 +23,6 @@ import java.io.File; import java.io.StringWriter; -import java.util.ArrayList; import java.util.HashSet; import java.util.LinkedList; import java.util.List; @@ -46,8 +45,8 @@ import org.overture.codegen.analysis.vdm.NameCollector; import org.overture.codegen.analysis.vdm.Renaming; import org.overture.codegen.analysis.vdm.UnreachableStmRemover; -import org.overture.codegen.analysis.vdm.VarShadowingRenameCollector; import org.overture.codegen.analysis.vdm.VarRenamer; +import org.overture.codegen.analysis.vdm.VarShadowingRenameCollector; import org.overture.codegen.analysis.violations.GeneratedVarComparison; import org.overture.codegen.analysis.violations.InvalidNamesResult; import org.overture.codegen.analysis.violations.ReservedWordsComparison; @@ -62,8 +61,8 @@ import org.overture.codegen.cgast.declarations.AClassDeclCG; import org.overture.codegen.cgast.declarations.AInterfaceDeclCG; import org.overture.codegen.ir.CodeGenBase; -import org.overture.codegen.ir.IRStatus; import org.overture.codegen.ir.IRConstants; +import org.overture.codegen.ir.IRStatus; import org.overture.codegen.ir.IrNodeInfo; import org.overture.codegen.ir.VdmNodeInfo; import org.overture.codegen.logging.ILogger; @@ -235,32 +234,18 @@ public GeneratedData generateJavaFromVdm(List ast) InvalidNamesResult invalidNamesResult = validateVdmModelNames(userClasses); validateVdmModelingConstructs(userClasses); - List> temp = new ArrayList<>(); - List> statuses = new ArrayList<>(); + List> statuses = new LinkedList<>(); for (SClassDefinition classDef : ast) { - temp.add(generator.generateFrom(classDef)); - } - - // All our transformations are partial so we need to - // cast the INodes down to Class Decls - //TODO add class extraction method as part of refactoring towards - // a more generic codegen framework - for (IRStatus t : temp) - { - if (t.getIrNode() instanceof AClassDeclCG) - { - IRStatus newStatus = new IRStatus(t.getUnsupportedInIr()); - newStatus.setIrNode((AClassDeclCG) t.getIrNode()); - newStatus.setIrNodeName(t.getIrNodeName()); - statuses.add(newStatus); - } + statuses.add(generator.generateFrom(classDef)); } + List> classStatuses = IRStatus.extract(statuses, AClassDeclCG.class); + if (getJavaSettings().getJavaRootPackage() != null) { - for (IRStatus irStatus : statuses) + for (IRStatus irStatus : classStatuses) { irStatus.getIrNode().setPackage(getJavaSettings().getJavaRootPackage()); } @@ -270,9 +255,9 @@ public GeneratedData generateJavaFromVdm(List ast) javaFormat.setClasses(classes); LinkedList> canBeGenerated = new LinkedList>(); - List generated = new ArrayList(); + List generated = new LinkedList(); - for (IRStatus status : statuses) + for (IRStatus status : classStatuses) { if (status.canBeGenerated()) { @@ -521,17 +506,17 @@ private void simplifyLibraryClass(SClassDefinition classDef) } private List getClassDecls( - List> statuses) + List> statuses) { List classDecls = new LinkedList(); - for (IRStatus status : statuses) + for (IRStatus status : statuses) { - AClassDeclCG classCg = status.getIrNode(); + org.overture.codegen.cgast.INode node = status.getIrNode(); - if (classCg != null) + if (node instanceof AClassDeclCG) { - classDecls.add(classCg); + classDecls.add((AClassDeclCG) node); } } From fefa184c9153cf4192eb5886fd339caf959eabfc Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Thu, 12 Mar 2015 12:39:09 +0100 Subject: [PATCH 278/323] Fix: The construction of the IR 'let statement' did not guard against unsupported nodes --- .../java/org/overture/codegen/visitor/StmVisitorCG.java | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/core/codegen/javagen/src/main/java/org/overture/codegen/visitor/StmVisitorCG.java b/core/codegen/javagen/src/main/java/org/overture/codegen/visitor/StmVisitorCG.java index 2daadb5762..1805de0f5c 100644 --- a/core/codegen/javagen/src/main/java/org/overture/codegen/visitor/StmVisitorCG.java +++ b/core/codegen/javagen/src/main/java/org/overture/codegen/visitor/StmVisitorCG.java @@ -310,7 +310,11 @@ public SStmCG caseALetStm(ALetStm node, IRInfo question) question.getDeclAssistant().setLocalDefs(node.getLocalDefs(), block.getLocalDefs(), question); SStmCG stm = node.getStatement().apply(question.getStmVisitor(), question); - block.getStatements().add(stm); + + if (stm != null) + { + block.getStatements().add(stm); + } return block; } From 3c8d3df125e8c167357c983f8da6fc41b642ad44 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Thu, 12 Mar 2015 12:48:24 +0100 Subject: [PATCH 279/323] Updated the commandline version of the Java code generator to filter anything but .vdmpp files --- .../codegen/vdm2java/JavaCodeGenMain.java | 22 +++++++++++++++++-- 1 file changed, 20 insertions(+), 2 deletions(-) diff --git a/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGenMain.java b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGenMain.java index f29acc063e..109f8cbfad 100644 --- a/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGenMain.java +++ b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGenMain.java @@ -113,7 +113,7 @@ public static void main(String[] args) if (path.isDirectory()) { - files.addAll(GeneralUtils.getFiles(path)); + files.addAll(filterPp(GeneralUtils.getFiles(path))); } else { usage("Could not find path: " + path); @@ -169,7 +169,10 @@ else if(arg.equals(VDM_ENTRY_EXP)) if (file.isFile()) { - files.add(file); + if (file.getName().endsWith(".vdmpp")) + { + files.add(file); + } } else { usage("Not a file: " + file); @@ -381,6 +384,21 @@ public static void handleOo(List files, IRSettings irSettings, Logger.getLog().println(JavaCodeGenUtil.constructUnsupportedModelingString(e)); } } + + public static List filterPp(List files) + { + List filtered = new LinkedList(); + + for(File f : files) + { + if(f.getName().endsWith(".vdmpp")) + { + filtered.add(f); + } + } + + return filtered; + } public static void usage(String msg) { From 37f829cc28fc4a56c1e37ec081d10cf429ba0ec9 Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Thu, 12 Mar 2015 18:11:49 +0100 Subject: [PATCH 280/323] Revert quick profiler commits. Specifically: 0442f7a8fdd3b8267d79093c89728e9b2b3a8fec 414af9ede25c1b3b4a2e353e83c756970d57740e 7edd25c88b0f25647ee2ade765ab996104599d9b --- core/interpreter/pom.xml | 5 - .../interpreter/runtime/ClassInterpreter.java | 2 - .../interpreter/util/QuickProfiler.java | 35 -- .../interpreter/values/FunctionValue.java | 438 +++++++++--------- .../interpreter/values/OperationValue.java | 29 +- 5 files changed, 222 insertions(+), 287 deletions(-) delete mode 100644 core/interpreter/src/main/java/org/overture/interpreter/util/QuickProfiler.java diff --git a/core/interpreter/pom.xml b/core/interpreter/pom.xml index 8d70913c39..efe21ca7f8 100644 --- a/core/interpreter/pom.xml +++ b/core/interpreter/pom.xml @@ -13,11 +13,6 @@ The VDM Interpreter - - commons-io - commons-io - 2.4 - org.overturetool.core ast diff --git a/core/interpreter/src/main/java/org/overture/interpreter/runtime/ClassInterpreter.java b/core/interpreter/src/main/java/org/overture/interpreter/runtime/ClassInterpreter.java index 1330bcb75f..113aea716f 100644 --- a/core/interpreter/src/main/java/org/overture/interpreter/runtime/ClassInterpreter.java +++ b/core/interpreter/src/main/java/org/overture/interpreter/runtime/ClassInterpreter.java @@ -63,7 +63,6 @@ import org.overture.interpreter.scheduler.SystemClock; import org.overture.interpreter.traces.CallSequence; import org.overture.interpreter.util.ClassListInterpreter; -import org.overture.interpreter.util.QuickProfiler; import org.overture.interpreter.values.BUSValue; import org.overture.interpreter.values.CPUValue; import org.overture.interpreter.values.NameValuePair; @@ -247,7 +246,6 @@ private Value execute(PExp expr, DBGPReader dbgp) throws Exception RuntimeValidator.stop(); - QuickProfiler.print(); return main.getResult(); // Can throw ContextException } diff --git a/core/interpreter/src/main/java/org/overture/interpreter/util/QuickProfiler.java b/core/interpreter/src/main/java/org/overture/interpreter/util/QuickProfiler.java deleted file mode 100644 index 311e854714..0000000000 --- a/core/interpreter/src/main/java/org/overture/interpreter/util/QuickProfiler.java +++ /dev/null @@ -1,35 +0,0 @@ -package org.overture.interpreter.util; - -import java.io.File; -import java.io.IOException; - -import org.apache.commons.io.FileUtils; - -public abstract class QuickProfiler -{ - - private static String PROFILE_PATH = "profile.csv"; - private static StringBuilder sb = new StringBuilder(); - - public static void printDuration(long start, String name) - { - sb.append("\""); - sb.append(name); - sb.append("\""); - sb.append(", "); - sb.append(System.currentTimeMillis() - start); - sb.append("\n"); - } - - public static void print() - { - try - { - FileUtils.writeStringToFile(new File(PROFILE_PATH), sb.toString(), false); - } catch (IOException e) - { - e.printStackTrace(); - } - } - -} diff --git a/core/interpreter/src/main/java/org/overture/interpreter/values/FunctionValue.java b/core/interpreter/src/main/java/org/overture/interpreter/values/FunctionValue.java index 5056be0241..1b751c7a93 100644 --- a/core/interpreter/src/main/java/org/overture/interpreter/values/FunctionValue.java +++ b/core/interpreter/src/main/java/org/overture/interpreter/values/FunctionValue.java @@ -70,7 +70,6 @@ import org.overture.interpreter.runtime.VdmRuntimeError; import org.overture.interpreter.solver.IConstraintSolver; import org.overture.interpreter.solver.SolverFactory; -import org.overture.interpreter.util.QuickProfiler; import org.overture.typechecker.assistant.pattern.PatternListTC; public class FunctionValue extends Value @@ -303,312 +302,303 @@ public void setClass(SClassDefinition classdef) public Value eval(ILexLocation from, ValueList argValues, Context ctxt, Context sctxt) throws AnalysisException { - long start = System.currentTimeMillis(); + if (uninstantiated) + { + abort(3033, "Polymorphic function has not been instantiated: " + + name, ctxt); + } - try + List paramPatterns = paramPatternList.get(0); + RootContext evalContext = newContext(from, toTitle(), ctxt, sctxt); + + if (typeValues != null) { - if (uninstantiated) - { - abort(3033, "Polymorphic function has not been instantiated: " - + name, ctxt); - } + // Add any @T type values, for recursive polymorphic functions + evalContext.putList(typeValues); + } + + if (argValues.size() != paramPatterns.size()) + { + VdmRuntimeError.abort(type.getLocation(), 4052, "Wrong number of arguments passed to " + + name, ctxt); + } - List paramPatterns = paramPatternList.get(0); - RootContext evalContext = newContext(from, toTitle(), ctxt, sctxt); + Iterator valIter = argValues.iterator(); + Iterator typeIter = type.getParameters().iterator(); + NameValuePairMap args = new NameValuePairMap(); - if (typeValues != null) - { - // Add any @T type values, for recursive polymorphic functions - evalContext.putList(typeValues); - } + for (PPattern p : paramPatterns) + { + Value pv = valIter.next(); - if (argValues.size() != paramPatterns.size()) + if (checkInvariants) // Don't even convert invariant arg values { - VdmRuntimeError.abort(type.getLocation(), 4052, "Wrong number of arguments passed to " - + name, ctxt); + pv = pv.convertTo(typeIter.next(), ctxt); } - Iterator valIter = argValues.iterator(); - Iterator typeIter = type.getParameters().iterator(); - NameValuePairMap args = new NameValuePairMap(); - - for (PPattern p : paramPatterns) + try { - Value pv = valIter.next(); - - if (checkInvariants) // Don't even convert invariant arg values + for (NameValuePair nvp : ctxt.assistantFactory.createPPatternAssistant().getNamedValues(p, pv, ctxt)) { - pv = pv.convertTo(typeIter.next(), ctxt); - } + Value v = args.get(nvp.name); - try - { - for (NameValuePair nvp : ctxt.assistantFactory.createPPatternAssistant().getNamedValues(p, pv, ctxt)) + if (v == null) { - Value v = args.get(nvp.name); - - if (v == null) - { - args.put(nvp); - } else - // Names match, so values must also + args.put(nvp); + } else + // Names match, so values must also + { + if (!v.equals(nvp.value)) { - if (!v.equals(nvp.value)) - { - abort(4053, "Parameter patterns do not match arguments", ctxt); - } + abort(4053, "Parameter patterns do not match arguments", ctxt); } } - } catch (PatternMatchException e) - { - abort(e.number, e, ctxt); } - } - - if (self != null) + } catch (PatternMatchException e) { - evalContext.put(new LexNameToken(location.getModule(), "self", location), self); + abort(e.number, e, ctxt); } + } - evalContext.putAll(args); + if (self != null) + { + evalContext.put(new LexNameToken(location.getModule(), "self", location), self); + } + + evalContext.putAll(args); - if (paramPatternList.size() == 1) + if (paramPatternList.size() == 1) + { + if (precondition != null && Settings.prechecks) { - if (precondition != null && Settings.prechecks) - { - // Evaluate pre/post in evalContext as it includes the type - // variables, if any. We disable the swapping and time (RT) - // as precondition checks should be "free". + // Evaluate pre/post in evalContext as it includes the type + // variables, if any. We disable the swapping and time (RT) + // as precondition checks should be "free". - try - { - evalContext.threadState.setAtomic(true); - evalContext.setPrepost(4055, "Precondition failure: "); - precondition.eval(from, argValues, evalContext); - } finally - { - evalContext.setPrepost(0, null); - evalContext.threadState.setAtomic(false); - } + try + { + evalContext.threadState.setAtomic(true); + evalContext.setPrepost(4055, "Precondition failure: "); + precondition.eval(from, argValues, evalContext); + } finally + { + evalContext.setPrepost(0, null); + evalContext.threadState.setAtomic(false); } + } - Long tid = Thread.currentThread().getId(); + Long tid = Thread.currentThread().getId(); - if (isMeasure) + if (isMeasure) + { + if (measuringThreads.contains(tid)) // We are measuring on this thread { - if (measuringThreads.contains(tid)) // We are measuring on this thread + if (!callingThreads.add(tid)) // And we've been here already { - if (!callingThreads.add(tid)) // And we've been here already - { - abort(4148, "Measure function is called recursively: " - + name, evalContext); - } + abort(4148, "Measure function is called recursively: " + + name, evalContext); } } + } - if (measureName != null) + if (measureName != null) + { + if (measure == null) { - if (measure == null) + measure = evalContext.lookup(measureName).functionValue(ctxt); + + if (typeValues != null) // Function is polymorphic, so measure copies type args { - measure = evalContext.lookup(measureName).functionValue(ctxt); + measure = (FunctionValue) measure.clone(); + measure.uninstantiated = false; + measure.typeValues = typeValues; + } - if (typeValues != null) // Function is polymorphic, so measure copies type args - { - measure = (FunctionValue) measure.clone(); - measure.uninstantiated = false; - measure.typeValues = typeValues; - } + measure.measuringThreads = Collections.synchronizedSet(new HashSet()); + measure.callingThreads = Collections.synchronizedSet(new HashSet()); + measure.isMeasure = true; + } - measure.measuringThreads = Collections.synchronizedSet(new HashSet()); - measure.callingThreads = Collections.synchronizedSet(new HashSet()); - measure.isMeasure = true; - } + // If this is a curried function, then the measure is called with all of the + // previously applied argument values, in addition to the argValues. - // If this is a curried function, then the measure is called with all of the - // previously applied argument values, in addition to the argValues. + ValueList measureArgs = null; - ValueList measureArgs = null; + if (curriedArgs == null) + { + measureArgs = argValues; + } else + { + measureArgs = new ValueList(); + measureArgs.addAll(curriedArgs); // Previous args + measureArgs.addAll(argValues); // Final args + } - if (curriedArgs == null) - { - measureArgs = argValues; - } else - { - measureArgs = new ValueList(); - measureArgs.addAll(curriedArgs); // Previous args - measureArgs.addAll(argValues); // Final args - } + // We disable the swapping and time (RT) as measure checks should be "free". + Value mv; - // We disable the swapping and time (RT) as measure checks should be "free". - Value mv; + try + { + measure.measuringThreads.add(tid); + evalContext.threadState.setAtomic(true); + mv = measure.eval(measure.location, measureArgs, evalContext); + } finally + { + evalContext.threadState.setAtomic(false); + measure.measuringThreads.remove(tid); + } - try - { - measure.measuringThreads.add(tid); - evalContext.threadState.setAtomic(true); - mv = measure.eval(measure.location, measureArgs, evalContext); - } finally - { - evalContext.threadState.setAtomic(false); - measure.measuringThreads.remove(tid); - } + Stack stack = measureValues.get(tid); - Stack stack = measureValues.get(tid); + if (stack == null) + { + stack = new Stack(); + measureValues.put(tid, stack); + } - if (stack == null) - { - stack = new Stack(); - measureValues.put(tid, stack); - } + if (!stack.isEmpty()) + { + Value old = stack.peek(); // Previous value - if (!stack.isEmpty()) + if (old != null && mv.compareTo(old) >= 0) // Not decreasing order { - Value old = stack.peek(); // Previous value - - if (old != null && mv.compareTo(old) >= 0) // Not decreasing order - { - abort(4146, "Measure failure: " - + name - + Utils.listToString("(", argValues, ", ", ")") - + ", measure " + measure.name - + ", current " + mv + ", previous " + old, evalContext); - } + abort(4146, "Measure failure: " + name + + Utils.listToString("(", argValues, ", ", ")") + + ", measure " + measure.name + ", current " + + mv + ", previous " + old, evalContext); } - - stack.push(mv); } - Value rv = null; + stack.push(mv); + } - if (body == null) - { + Value rv = null; - IConstraintSolver solver = SolverFactory.getSolver(Settings.dialect); + if (body == null) + { - if (solver != null) - { - rv = invokeSolver(ctxt, evalContext, args, solver); + IConstraintSolver solver = SolverFactory.getSolver(Settings.dialect); - } else - { - abort(4051, "Cannot apply implicit function: " + name, ctxt); - } + if (solver != null) + { + rv = invokeSolver(ctxt, evalContext, args, solver); } else { - try - { - rv = body.apply(VdmRuntime.getExpressionEvaluator(), evalContext).convertTo(type.getResult(), evalContext); - } catch (AnalysisException e) - { - if (e instanceof ValueException) - { - throw (ValueException) e; - } - e.printStackTrace(); - } + abort(4051, "Cannot apply implicit function: " + name, ctxt); } - if (ctxt.prepost > 0) // Note, caller's context is checked + } else + { + try + { + rv = body.apply(VdmRuntime.getExpressionEvaluator(), evalContext).convertTo(type.getResult(), evalContext); + } catch (AnalysisException e) { - if (!rv.boolValue(ctxt)) + if (e instanceof ValueException) { - // Note that this calls getLocation to find out where the body - // wants to report its location for this error - this may be an - // errs clause in some circumstances. - - throw new ContextException(ctxt.prepost, ctxt.prepostMsg - + name, body.getLocation(), evalContext); + throw (ValueException) e; } + e.printStackTrace(); } + } - if (postcondition != null && Settings.postchecks) + if (ctxt.prepost > 0) // Note, caller's context is checked + { + if (!rv.boolValue(ctxt)) { - ValueList postArgs = new ValueList(argValues); - postArgs.add(rv); - - // Evaluate pre/post in evalContext as it includes the type - // variables, if any. We disable the swapping and time (RT) - // as postcondition checks should be "free". + // Note that this calls getLocation to find out where the body + // wants to report its location for this error - this may be an + // errs clause in some circumstances. - try - { - evalContext.threadState.setAtomic(true); - evalContext.setPrepost(4056, "Postcondition failure: "); - postcondition.eval(from, postArgs, evalContext); - } finally - { - evalContext.setPrepost(0, null); - evalContext.threadState.setAtomic(false); - } + throw new ContextException(ctxt.prepost, ctxt.prepostMsg + + name, body.getLocation(), evalContext); } + } - if (measure != null) - { - measureValues.get(tid).pop(); - } + if (postcondition != null && Settings.postchecks) + { + ValueList postArgs = new ValueList(argValues); + postArgs.add(rv); + + // Evaluate pre/post in evalContext as it includes the type + // variables, if any. We disable the swapping and time (RT) + // as postcondition checks should be "free". - if (isMeasure) + try + { + evalContext.threadState.setAtomic(true); + evalContext.setPrepost(4056, "Postcondition failure: "); + postcondition.eval(from, postArgs, evalContext); + } finally { - callingThreads.remove(tid); + evalContext.setPrepost(0, null); + evalContext.threadState.setAtomic(false); } + } - return rv; - } else - // This is a curried function + if (measure != null) { - if (type.getResult() instanceof AFunctionType) - { - // If a curried function has a pre/postcondition, then the - // result of a partial application has a pre/post condition - // with its free variables taken from the environment (so - // that parameters passed are fixed in subsequent applies). + measureValues.get(tid).pop(); + } - FunctionValue newpre = null; + if (isMeasure) + { + callingThreads.remove(tid); + } - if (precondition != null) - { - newpre = precondition.curry(evalContext); - } + return rv; + } else + // This is a curried function + { + if (type.getResult() instanceof AFunctionType) + { + // If a curried function has a pre/postcondition, then the + // result of a partial application has a pre/post condition + // with its free variables taken from the environment (so + // that parameters passed are fixed in subsequent applies). - FunctionValue newpost = null; + FunctionValue newpre = null; - if (postcondition != null) - { - newpost = postcondition.curry(evalContext); - } + if (precondition != null) + { + newpre = precondition.curry(evalContext); + } - if (freeVariables != null) - { - evalContext.putAll(freeVariables); - } + FunctionValue newpost = null; - // Curried arguments are collected so that we can invoke any measure functions - // once we reach the final apply that does not return a function. + if (postcondition != null) + { + newpost = postcondition.curry(evalContext); + } - ValueList argList = new ValueList(); + if (freeVariables != null) + { + evalContext.putAll(freeVariables); + } - if (curriedArgs != null) - { - argList.addAll(curriedArgs); - } + // Curried arguments are collected so that we can invoke any measure functions + // once we reach the final apply that does not return a function. - argList.addAll(argValues); + ValueList argList = new ValueList(); - FunctionValue rv = new FunctionValue(location, "curried", (AFunctionType) type.getResult(), paramPatternList.subList(1, paramPatternList.size()), body, newpre, newpost, evalContext, false, argList, measureName, measureValues, result); + if (curriedArgs != null) + { + argList.addAll(curriedArgs); + } - rv.setSelf(self); - rv.typeValues = typeValues; + argList.addAll(argValues); - return rv; - } + FunctionValue rv = new FunctionValue(location, "curried", (AFunctionType) type.getResult(), paramPatternList.subList(1, paramPatternList.size()), body, newpre, newpost, evalContext, false, argList, measureName, measureValues, result); - VdmRuntimeError.abort(type.getLocation(), 4057, "Curried function return type is not a function", ctxt); - return null; + rv.setSelf(self); + rv.typeValues = typeValues; + + return rv; } - } finally - { - QuickProfiler.printDuration(start,this.location.getModule()+"."+this.toTitle()); + + VdmRuntimeError.abort(type.getLocation(), 4057, "Curried function return type is not a function", ctxt); + return null; } } diff --git a/core/interpreter/src/main/java/org/overture/interpreter/values/OperationValue.java b/core/interpreter/src/main/java/org/overture/interpreter/values/OperationValue.java index b56d73cfd2..d7f1cab83f 100644 --- a/core/interpreter/src/main/java/org/overture/interpreter/values/OperationValue.java +++ b/core/interpreter/src/main/java/org/overture/interpreter/values/OperationValue.java @@ -87,7 +87,6 @@ import org.overture.interpreter.scheduler.ResourceScheduler; import org.overture.interpreter.solver.IConstraintSolver; import org.overture.interpreter.solver.SolverFactory; -import org.overture.interpreter.util.QuickProfiler; import org.overture.parser.config.Properties; public class OperationValue extends Value @@ -257,35 +256,23 @@ public void prepareGuard(ObjectContext ctxt) public Value eval(ILexLocation from, ValueList argValues, Context ctxt) throws AnalysisException { - long start = System.currentTimeMillis(); + // Note args cannot be Updateable, so we convert them here. This means + // that TransactionValues pass the local "new" value to the far end. + ValueList constValues = argValues.getConstant(); - try + if (Settings.dialect == Dialect.VDM_RT) { - - // Note args cannot be Updateable, so we convert them here. This means - // that TransactionValues pass the local "new" value to the far end. - ValueList constValues = argValues.getConstant(); - - if (Settings.dialect == Dialect.VDM_RT) + if (!isStatic && (ctxt.threadState.CPU != self.getCPU() || isAsync)) { - if (!isStatic - && (ctxt.threadState.CPU != self.getCPU() || isAsync)) - { - return asyncEval(constValues, ctxt); - } else - { - return localEval(from, constValues, ctxt, true); - } + return asyncEval(constValues, ctxt); } else { return localEval(from, constValues, ctxt, true); } - } finally + } else { - QuickProfiler.printDuration(start, this.name.getModule() + "." - + this.toTitle()); + return localEval(from, constValues, ctxt, true); } - } public Value localEval(ILexLocation from, ValueList argValues, From 248f5dee208bdb49a44fe8080a19048ff9e3f4a3 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Thu, 12 Mar 2015 19:09:28 +0100 Subject: [PATCH 281/323] Fix to function that determines if an IR class represents a quote or not --- .../codegen/utils/GeneralCodeGenUtils.java | 18 ------------ .../codegen/vdm2java/JavaCodeGen.java | 2 +- .../codegen/vdm2java/JavaCodeGenUtil.java | 28 +++++++++++++++++++ 3 files changed, 29 insertions(+), 19 deletions(-) diff --git a/core/codegen/javagen/src/main/java/org/overture/codegen/utils/GeneralCodeGenUtils.java b/core/codegen/javagen/src/main/java/org/overture/codegen/utils/GeneralCodeGenUtils.java index 054eb54388..62eae8ad62 100644 --- a/core/codegen/javagen/src/main/java/org/overture/codegen/utils/GeneralCodeGenUtils.java +++ b/core/codegen/javagen/src/main/java/org/overture/codegen/utils/GeneralCodeGenUtils.java @@ -44,13 +44,9 @@ import org.overture.ast.typechecker.NameScope; import org.overture.ast.types.AVoidType; import org.overture.ast.util.definitions.ClassList; -import org.overture.codegen.cgast.INode; -import org.overture.codegen.cgast.SDeclCG; -import org.overture.codegen.cgast.declarations.AClassDeclCG; import org.overture.codegen.ir.ITempVarGen; import org.overture.codegen.logging.Logger; import org.overture.codegen.vdm2java.IJavaCodeGenConstants; -import org.overture.codegen.vdm2java.JavaCodeGen; import org.overture.parser.lex.LexException; import org.overture.parser.lex.LexTokenReader; import org.overture.parser.messages.Console; @@ -401,20 +397,6 @@ public static String getFolderFromJavaRootPackage(String pack) } } - public static boolean isQuote(INode decl) - { - if(decl instanceof AClassDeclCG) - { - AClassDeclCG clazz = (AClassDeclCG) decl; - - return clazz.getPackage() != null && clazz.getPackage().endsWith("." + JavaCodeGen.QUOTES); - } - else - { - return false; - } - } - public static boolean isJavaKeyword(String s) { if(s == null) diff --git a/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java index 19f3947cfc..a9b507db86 100644 --- a/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java +++ b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java @@ -575,7 +575,7 @@ public void generateJavaSourceFile(File outputFolder, { String javaFileName = generatedModule.getName(); - if (GeneralCodeGenUtils.isQuote(generatedModule.getIrNode())) + if (JavaCodeGenUtil.isQuote(generatedModule.getIrNode(), getJavaSettings())) { javaFileName += JAVA_QUOTE_NAME_SUFFIX; } diff --git a/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGenUtil.java b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGenUtil.java index f47f229372..dff09e0405 100644 --- a/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGenUtil.java +++ b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGenUtil.java @@ -45,6 +45,7 @@ import org.overture.codegen.analysis.violations.Violation; import org.overture.codegen.assistant.AssistantManager; import org.overture.codegen.assistant.LocationAssistantCG; +import org.overture.codegen.cgast.declarations.AClassDeclCG; import org.overture.codegen.ir.IRSettings; import org.overture.codegen.ir.IrNodeInfo; import org.overture.codegen.ir.VdmNodeInfo; @@ -386,4 +387,31 @@ public static void printUnsupportedNodes(Set unsupportedNodes) Logger.getLog().println(""); } } + + public static boolean isQuote(org.overture.codegen.cgast.INode decl, JavaSettings settings) + { + if(decl instanceof AClassDeclCG) + { + AClassDeclCG clazz = (AClassDeclCG) decl; + + if(clazz.getPackage() == null) + { + return false; + } + + String javaPackage = settings.getJavaRootPackage(); + + if(javaPackage == null || javaPackage.equals("")) + { + return clazz.getPackage().equals(JavaCodeGen.QUOTES); + } + + if(clazz.getPackage().equals(javaPackage + "." + JavaCodeGen.QUOTES)) + { + return true; + } + } + + return false; + } } From 0a0a58051a56373b110f7bfee465af0b755a93a0 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Thu, 12 Mar 2015 19:26:31 +0100 Subject: [PATCH 282/323] Fix: The java package was not set for the function value interfaces --- .../main/java/org/overture/codegen/vdm2java/JavaCodeGen.java | 2 ++ 1 file changed, 2 insertions(+) diff --git a/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java index a9b507db86..4aee31a0f2 100644 --- a/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java +++ b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java @@ -353,6 +353,8 @@ public GeneratedData generateJavaFromVdm(List ast) for (AInterfaceDeclCG funcValueInterface : funcValueInterfaces) { + funcValueInterface.setPackage(getJavaSettings().getJavaRootPackage()); + StringWriter writer = new StringWriter(); try From f5478c9abbaea090a1f22e1bd97b5fbeab3b64f2 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Thu, 12 Mar 2015 19:40:55 +0100 Subject: [PATCH 283/323] Added regression test for the missing package problem for function value interfaces --- .../package_specs/FuncValueInterface | 11 ++++++ .../package_specs/FuncValueInterface.result | 34 +++++++++++++++++++ 2 files changed, 45 insertions(+) create mode 100644 core/codegen/javagen/src/test/resources/package_specs/FuncValueInterface create mode 100644 core/codegen/javagen/src/test/resources/package_specs/FuncValueInterface.result diff --git a/core/codegen/javagen/src/test/resources/package_specs/FuncValueInterface b/core/codegen/javagen/src/test/resources/package_specs/FuncValueInterface new file mode 100644 index 0000000000..a16e00fd64 --- /dev/null +++ b/core/codegen/javagen/src/test/resources/package_specs/FuncValueInterface @@ -0,0 +1,11 @@ +class Entry + +operations + +public static Run : () ==> int +Run () == +let f = (lambda x : nat & x * x) +in + return f(2); + +end Entry \ No newline at end of file diff --git a/core/codegen/javagen/src/test/resources/package_specs/FuncValueInterface.result b/core/codegen/javagen/src/test/resources/package_specs/FuncValueInterface.result new file mode 100644 index 0000000000..faf0462ca0 --- /dev/null +++ b/core/codegen/javagen/src/test/resources/package_specs/FuncValueInterface.result @@ -0,0 +1,34 @@ +package my.model; + +import org.overture.codegen.runtime.*; + +import java.util.*; + + +public class Entry { + public Entry() { + } + + public static Number Run() { + Func_1 f = new Func_1() { + public Number eval(final Number x) { + return x.longValue() * x.longValue(); + } + }; + + return f.eval(2L); + } + + public String toString() { + return "Entry{}"; + } +} + +########## +package my.model; + +public interface Func_1 { + public abstract T_2 eval(final T_1 param_1); +} + +########## From 60e7a1660f491ab2e0084d685749c314edcffc1d Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Thu, 12 Mar 2015 19:42:16 +0100 Subject: [PATCH 284/323] Minor flaw in the test execution system: The traces runtime library part cannot yet be imported --- .../org/overture/codegen/tests/utils/ExecutableTestHandler.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/codegen/javagen/src/test/java/org/overture/codegen/tests/utils/ExecutableTestHandler.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/utils/ExecutableTestHandler.java index 4d4904f732..0d1af87b1a 100644 --- a/core/codegen/javagen/src/test/java/org/overture/codegen/tests/utils/ExecutableTestHandler.java +++ b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/utils/ExecutableTestHandler.java @@ -70,7 +70,7 @@ public String getMainClass() + "import java.io.FileOutputStream;\n" + "import java.io.ObjectOutputStream;\n" + "import org.overture.codegen.runtime.*;\n" - + "import org.overture.codegen.runtime.traces.*;\n" +// + "import org.overture.codegen.runtime.traces.*;\n" + "import java.util.*;\n\n" + "public class Exp {\n" + " public static Object exp()\n" From 7b06344721f7384bda4e288a7fdd6664fd8d57f5 Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Thu, 12 Mar 2015 20:02:17 +0100 Subject: [PATCH 285/323] Update README.md --- README.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index 9831a9090f..53717b73b4 100644 --- a/README.md +++ b/README.md @@ -10,10 +10,10 @@ Before you download and try to use the code provided in this open-source reposit This directory contains several subdirectories: -* The core Overture libraries are found in `code`, and are pure Java with no Eclipse dependencies -* The Overture IDE, based on Eclipse, are found in `ide` -* Documentation for VDM and Overture is in `documentation` -* Auxiliary code that supports the build process are found in `tools` +* The core Overture libraries are found in `core`, and are pure Java with no Eclipse dependencies +* The Overture IDE, based on Eclipse, is found in `ide` +* Technical Documentation for Overture is in `documentation` +* Auxiliary code that supports the build process is found in `tools` From 9d8b3e4840d7c5f0713feecb1e27000ce502d8f7 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Thu, 12 Mar 2015 22:12:45 +0100 Subject: [PATCH 286/323] Use sets to store renamings --- .../analysis/vdm/JavaIdentifierNormaliser.java | 8 ++++---- .../codegen/analysis/vdm/RenameAnalysis.java | 6 +++--- .../overture/codegen/analysis/vdm/VarRenamer.java | 7 ++++--- .../analysis/vdm/VarShadowingRenameCollector.java | 12 ++++-------- .../org/overture/codegen/vdm2java/JavaCodeGen.java | 6 +++--- .../overture/codegen/tests/VarShadowingTestCase.java | 5 +++-- 6 files changed, 21 insertions(+), 23 deletions(-) diff --git a/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/JavaIdentifierNormaliser.java b/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/JavaIdentifierNormaliser.java index 0fb454db17..eb718117bc 100644 --- a/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/JavaIdentifierNormaliser.java +++ b/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/JavaIdentifierNormaliser.java @@ -1,7 +1,7 @@ package org.overture.codegen.analysis.vdm; import java.util.HashMap; -import java.util.LinkedList; +import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Set; @@ -18,14 +18,14 @@ public class JavaIdentifierNormaliser extends DepthFirstAnalysisAdaptor private Set allNames; private Map renamingsSoFar; private ITempVarGen nameGen; - private List renamings; + private Set renamings; public JavaIdentifierNormaliser(Set allNames, ITempVarGen nameGen) { this.allNames = allNames; this.renamingsSoFar = new HashMap(); this.nameGen = nameGen; - this.renamings = new LinkedList(); + this.renamings = new HashSet(); } @Override @@ -61,7 +61,7 @@ private boolean contains(ILexLocation loc) return false; } - public List getRenamings() + public Set getRenamings() { return renamings; } diff --git a/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/RenameAnalysis.java b/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/RenameAnalysis.java index c756c1e1a0..aaf15d4eac 100644 --- a/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/RenameAnalysis.java +++ b/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/RenameAnalysis.java @@ -1,6 +1,6 @@ package org.overture.codegen.analysis.vdm; -import java.util.List; +import java.util.Set; import org.overture.ast.analysis.AnalysisException; import org.overture.ast.analysis.DepthFirstAnalysisAdaptor; @@ -11,9 +11,9 @@ class RenameAnalysis extends DepthFirstAnalysisAdaptor { - private List renamings; + private Set renamings; - public RenameAnalysis(List renamings) + public RenameAnalysis(Set renamings) { this.renamings = renamings; } diff --git a/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/VarRenamer.java b/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/VarRenamer.java index e2cecbcd36..7c21e1d001 100644 --- a/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/VarRenamer.java +++ b/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/VarRenamer.java @@ -2,6 +2,7 @@ import java.util.List; import java.util.Map; +import java.util.Set; import org.overture.ast.analysis.AnalysisException; import org.overture.ast.definitions.PDefinition; @@ -11,13 +12,13 @@ public class VarRenamer { - public void rename(SClassDefinition clazz, List renamings) + public void rename(SClassDefinition clazz, Set renamings) throws AnalysisException { clazz.apply(new RenameAnalysis(renamings)); } - public List computeRenamings(List classes, + public Set computeRenamings(List classes, ITypeCheckerAssistantFactory af, Map idDefs) throws AnalysisException { VarShadowingRenameCollector renamer = new VarShadowingRenameCollector(af, idDefs); @@ -31,7 +32,7 @@ public List computeRenamings(List classes, return renamer.getRenamings(); } - public List computeRenamings(SClassDefinition clazz, + public Set computeRenamings(SClassDefinition clazz, VarShadowingRenameCollector collector) throws AnalysisException { collector.init(true); diff --git a/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/VarShadowingRenameCollector.java b/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/VarShadowingRenameCollector.java index cd8a7514ea..f47ef23dda 100644 --- a/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/VarShadowingRenameCollector.java +++ b/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/VarShadowingRenameCollector.java @@ -1,6 +1,5 @@ package org.overture.codegen.analysis.vdm; -import java.util.Collections; import java.util.HashSet; import java.util.LinkedList; import java.util.List; @@ -79,7 +78,7 @@ public class VarShadowingRenameCollector extends DepthFirstAnalysisAdaptor private Stack localDefsInScope; private int enclosingCounter; - private List renamings; + private Set renamings; private Set namesToAvoid; private TempVarNameGen nameGen; @@ -92,7 +91,7 @@ public VarShadowingRenameCollector(ITypeCheckerAssistantFactory af, Map(); this.enclosingCounter = 0; - this.renamings = new LinkedList(); + this.renamings = new HashSet(); this.namesToAvoid = new HashSet(); this.nameGen = new TempVarNameGen(); } @@ -721,12 +720,9 @@ public void init(boolean clearRenamings) } } - public List getRenamings() + public Set getRenamings() { - LinkedList renameCopies = new LinkedList(renamings); - Collections.sort(renameCopies); - - return renameCopies; + return renamings; } private List getParamDefs(AExplicitFunctionDefinition node) diff --git a/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java index 4aee31a0f2..bf94ad2430 100644 --- a/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java +++ b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java @@ -413,17 +413,17 @@ private List normaliseIdentifiers( Set allNames = collector.namesToAvoid(); - JavaIdentifierNormaliser normaliser = new JavaIdentifierNormaliser(allNames, getInfo().getTempVarNameGen()); + List renamings = new LinkedList(); for (SClassDefinition clazz : userClasses) { + JavaIdentifierNormaliser normaliser = new JavaIdentifierNormaliser(clazz, allNames, getInfo().getTempVarNameGen()); + renamings.addAll(normaliser.getRenamings()); clazz.apply(normaliser); } VarRenamer renamer = new VarRenamer(); - List renamings = normaliser.getRenamings(); - for (SClassDefinition clazz : userClasses) { renamer.rename(clazz, renamings); diff --git a/core/codegen/javagen/src/test/java/org/overture/codegen/tests/VarShadowingTestCase.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/VarShadowingTestCase.java index 5b20bdfe89..245d1e9302 100644 --- a/core/codegen/javagen/src/test/java/org/overture/codegen/tests/VarShadowingTestCase.java +++ b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/VarShadowingTestCase.java @@ -4,6 +4,7 @@ import java.util.LinkedList; import java.util.List; import java.util.Map; +import java.util.Set; import org.junit.Assert; import org.overture.ast.definitions.PDefinition; @@ -74,7 +75,7 @@ public void test() throws Exception Value orgSpecResult = evalSpec(originalSpecTcResult.result); - List renamings = new VarRenamer().computeRenamings(originalSpecTcResult.result, af, idDefs); + Set renamings = new VarRenamer().computeRenamings(originalSpecTcResult.result, af, idDefs); StringBuilder sb = GeneralUtils.readLines(file, "\n"); @@ -107,7 +108,7 @@ public void test() throws Exception } } - private void rename(List renamings, StringBuilder sb) + private void rename(Set renamings, StringBuilder sb) { for (Renaming r : renamings) { From 0f23d14eaef375961f384bdb92323f319466040f Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Thu, 12 Mar 2015 22:14:44 +0100 Subject: [PATCH 287/323] Added filtering of renaming --- .../codegen/vdm2java/JavaCodeGen.java | 26 ++++++++++++++----- 1 file changed, 19 insertions(+), 7 deletions(-) diff --git a/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java index bf94ad2430..0dade9f90c 100644 --- a/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java +++ b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java @@ -23,6 +23,7 @@ import java.io.File; import java.io.StringWriter; +import java.util.Collections; import java.util.HashSet; import java.util.LinkedList; import java.util.List; @@ -413,23 +414,32 @@ private List normaliseIdentifiers( Set allNames = collector.namesToAvoid(); - - List renamings = new LinkedList(); + JavaIdentifierNormaliser normaliser = new JavaIdentifierNormaliser(allNames, getInfo().getTempVarNameGen()); + for (SClassDefinition clazz : userClasses) { - JavaIdentifierNormaliser normaliser = new JavaIdentifierNormaliser(clazz, allNames, getInfo().getTempVarNameGen()); - renamings.addAll(normaliser.getRenamings()); clazz.apply(normaliser); } VarRenamer renamer = new VarRenamer(); + + Set filteredRenamings = new HashSet(); + + for(Renaming r : normaliser.getRenamings()) + { + if(!getInfo().getDeclAssistant().isLibraryName(r.getLoc().getModule())) + { + filteredRenamings.add(r); + } + } + for (SClassDefinition clazz : userClasses) { - renamer.rename(clazz, renamings); + renamer.rename(clazz, filteredRenamings); } - return renamings; + return new LinkedList(filteredRenamings); } private void computeDefTable(List mergedParseLists) @@ -472,7 +482,7 @@ private List performRenaming( for (SClassDefinition classDef : mergedParseLists) { - List classRenamings = renamer.computeRenamings(classDef, renamingsCollector); + Set classRenamings = renamer.computeRenamings(classDef, renamingsCollector); if (!classRenamings.isEmpty()) { @@ -481,6 +491,8 @@ private List performRenaming( } } + Collections.sort(allRenamings); + return allRenamings; } From 85d6cce8be3a62cb011aac0f4545daeccc5d4992 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Thu, 12 Mar 2015 22:22:16 +0100 Subject: [PATCH 288/323] Taking the module into account when sorting renamings --- .../overture/codegen/analysis/vdm/Renaming.java | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/Renaming.java b/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/Renaming.java index 1a3d0477c1..cc8fbcd94d 100644 --- a/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/Renaming.java +++ b/core/codegen/javagen/src/main/java/org/overture/codegen/analysis/vdm/Renaming.java @@ -76,8 +76,18 @@ public boolean equals(Object obj) } @Override - public int compareTo(Renaming arg0) + public int compareTo(Renaming other) { - return arg0.getLoc().getStartOffset() - loc.getStartOffset(); + if(loc.getModule() != null && other.loc.getModule() != null) + { + if(!loc.getModule().equals(other.loc.getModule())) + { + return other.loc.getModule().compareTo(loc.getModule()); + } + } + + ILexLocation otherLoc = other.getLoc(); + + return otherLoc.getStartOffset() - loc.getStartOffset(); } } From 4c6836833749a7471b8528fe3e558b2b9935bee9 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Thu, 12 Mar 2015 22:37:32 +0100 Subject: [PATCH 289/323] Corrected problem with one of the renaming tests It is very important that renamings are performed from the bottom, right to left, in order not to mess up the location of the names!! --- .../overture/codegen/tests/VarShadowingTestCase.java | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/core/codegen/javagen/src/test/java/org/overture/codegen/tests/VarShadowingTestCase.java b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/VarShadowingTestCase.java index 245d1e9302..7f01ab64a0 100644 --- a/core/codegen/javagen/src/test/java/org/overture/codegen/tests/VarShadowingTestCase.java +++ b/core/codegen/javagen/src/test/java/org/overture/codegen/tests/VarShadowingTestCase.java @@ -1,10 +1,10 @@ package org.overture.codegen.tests; import java.io.File; +import java.util.Collections; import java.util.LinkedList; import java.util.List; import java.util.Map; -import java.util.Set; import org.junit.Assert; import org.overture.ast.definitions.PDefinition; @@ -75,7 +75,12 @@ public void test() throws Exception Value orgSpecResult = evalSpec(originalSpecTcResult.result); - Set renamings = new VarRenamer().computeRenamings(originalSpecTcResult.result, af, idDefs); + List renamings = new LinkedList(new VarRenamer().computeRenamings(originalSpecTcResult.result, af, idDefs)); + + // It is very important that renamings are performed from the bottom, right to left, in order + // not to mess up the location of the names!! + Collections.sort(renamings); + StringBuilder sb = GeneralUtils.readLines(file, "\n"); @@ -108,7 +113,7 @@ public void test() throws Exception } } - private void rename(Set renamings, StringBuilder sb) + private void rename(List renamings, StringBuilder sb) { for (Renaming r : renamings) { From a8553bcba779716e7425727f55ed7ac54b6584ad Mon Sep 17 00:00:00 2001 From: Nick Battle Date: Mon, 16 Mar 2015 13:16:22 +0000 Subject: [PATCH 290/323] Subset and psubsets should give TC error if the types do not match, fixes #432 --- .../CORE/expr/binaryexpr/binary-04.vdm.result | 2 +- .../propersubset/propersubset-06.vdm.result | 2 +- .../propersubset/propersubset-07.vdm.result | 2 +- .../propersubset/propersubset-08.vdm.result | 2 +- .../binaryexpr/subset/subset-06.vdm.result | 2 +- .../binaryexpr/subset/subset-07.vdm.result | 2 +- .../binaryexpr/subset/subset-08.vdm.result | 2 +- .../visitor/TypeCheckerExpVisitor.java | 18 ++++++ .../PP/extexplopdef/extexplopdef.vpp.result | 2 +- .../fulltest/PP/fundefpp/fundefpp.vpp.result | 2 +- .../PP/stmtpp/casesstmt/casesstmt.vpp.result | 2 +- .../stmtpp/rectrapstmt/rectrapstmt.vpp.result | 2 +- .../VICE/extension/extension-06.vpp.result | 2 +- .../VICE/extension/extension-08.vpp.result | 2 +- .../propersubset/propersubset-06.vdm.result | 1 + .../propersubset/propersubset-07.vdm.result | 1 + .../propersubset/propersubset-08.vdm.result | 1 + .../binaryexpr/subset/subset-06.vdm.result | 1 + .../binaryexpr/subset/subset-07.vdm.result | 1 + .../binaryexpr/subset/subset-08.vdm.result | 1 + .../expr/casesexpr/casesexpr-03.vdm.result | 2 +- .../stmt/casesstmt/casesstmt-03.vdm.result | 2 +- .../CORE/stmt/letbestmt/letbestmt.vdm.result | 2 +- .../SL/modules06/modules06.vdm.result | 2 +- .../fulltest/SL/opdef/opdef.vdm.result | 2 +- .../stmtsl/rectrapstmt/rectrapstmt.vdm.result | 2 +- .../src/test/resources/modules/looseSL.result | 2 +- .../test/resources/modules/newspeakSL.result | 56 +++++++++---------- .../test/resources/modules/simulatorSL.result | 6 +- .../test/resources/modules/trafficSL.result | 2 +- 30 files changed, 76 insertions(+), 52 deletions(-) diff --git a/core/testing/tests/src/test/resources/external/cgip/sltest/CORE/expr/binaryexpr/binary-04.vdm.result b/core/testing/tests/src/test/resources/external/cgip/sltest/CORE/expr/binaryexpr/binary-04.vdm.result index a4f071e324..64f3b81e94 100644 --- a/core/testing/tests/src/test/resources/external/cgip/sltest/CORE/expr/binaryexpr/binary-04.vdm.result +++ b/core/testing/tests/src/test/resources/external/cgip/sltest/CORE/expr/binaryexpr/binary-04.vdm.result @@ -1 +1 @@ -["binary-04.vdmparses and type checks"] \ No newline at end of file +["Error 3335: binary-04.vdm at 112:41 Subset will only be true if the LHS set is empty","Error 3335: binary-04.vdm at 138:26 Subset will only be true if the LHS set is empty","Error 3335: binary-04.vdm at 145:9 Subset will only be true if the LHS set is empty"] \ No newline at end of file diff --git a/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/binaryexpr/propersubset/propersubset-06.vdm.result b/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/binaryexpr/propersubset/propersubset-06.vdm.result index 15ce5f14ba..e5b681a863 100644 --- a/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/binaryexpr/propersubset/propersubset-06.vdm.result +++ b/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/binaryexpr/propersubset/propersubset-06.vdm.result @@ -1 +1 @@ -["propersubset-06.vdmparses and type checks"] \ No newline at end of file +["Error 3335: propersubset-06.vdm at 14:17 Subset will only be true if the LHS set is empty"] \ No newline at end of file diff --git a/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/binaryexpr/propersubset/propersubset-07.vdm.result b/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/binaryexpr/propersubset/propersubset-07.vdm.result index 2f660ace0f..3c79fd6334 100644 --- a/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/binaryexpr/propersubset/propersubset-07.vdm.result +++ b/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/binaryexpr/propersubset/propersubset-07.vdm.result @@ -1 +1 @@ -["propersubset-07.vdmparses and type checks"] \ No newline at end of file +["Error 3335: propersubset-07.vdm at 14:17 Subset will only be true if the LHS set is empty"] \ No newline at end of file diff --git a/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/binaryexpr/propersubset/propersubset-08.vdm.result b/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/binaryexpr/propersubset/propersubset-08.vdm.result index fc8008bad9..97e77f67f9 100644 --- a/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/binaryexpr/propersubset/propersubset-08.vdm.result +++ b/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/binaryexpr/propersubset/propersubset-08.vdm.result @@ -1 +1 @@ -["propersubset-08.vdmparses and type checks"] \ No newline at end of file +["Error 3335: propersubset-08.vdm at 22:14 Subset will only be true if the LHS set is empty"] \ No newline at end of file diff --git a/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/binaryexpr/subset/subset-06.vdm.result b/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/binaryexpr/subset/subset-06.vdm.result index 4d93053c1c..9c8d2fcebb 100644 --- a/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/binaryexpr/subset/subset-06.vdm.result +++ b/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/binaryexpr/subset/subset-06.vdm.result @@ -1 +1 @@ -["subset-06.vdmparses and type checks"] \ No newline at end of file +["Error 3335: subset-06.vdm at 14:17 Subset will only be true if the LHS set is empty"] \ No newline at end of file diff --git a/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/binaryexpr/subset/subset-07.vdm.result b/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/binaryexpr/subset/subset-07.vdm.result index 61a68eb878..35c37fa5ba 100644 --- a/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/binaryexpr/subset/subset-07.vdm.result +++ b/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/binaryexpr/subset/subset-07.vdm.result @@ -1 +1 @@ -["subset-07.vdmparses and type checks"] \ No newline at end of file +["Error 3335: subset-07.vdm at 14:17 Subset will only be true if the LHS set is empty"] \ No newline at end of file diff --git a/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/binaryexpr/subset/subset-08.vdm.result b/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/binaryexpr/subset/subset-08.vdm.result index ae52c3c99a..9b49413962 100644 --- a/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/binaryexpr/subset/subset-08.vdm.result +++ b/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/binaryexpr/subset/subset-08.vdm.result @@ -1 +1 @@ -["subset-08.vdmparses and type checks"] \ No newline at end of file +["Error 3335: subset-08.vdm at 22:14 Subset will only be true if the LHS set is empty"] \ No newline at end of file diff --git a/core/typechecker/src/main/java/org/overture/typechecker/visitor/TypeCheckerExpVisitor.java b/core/typechecker/src/main/java/org/overture/typechecker/visitor/TypeCheckerExpVisitor.java index 32302b0b1b..78a2b17f04 100644 --- a/core/typechecker/src/main/java/org/overture/typechecker/visitor/TypeCheckerExpVisitor.java +++ b/core/typechecker/src/main/java/org/overture/typechecker/visitor/TypeCheckerExpVisitor.java @@ -770,6 +770,15 @@ public PType caseAProperSubsetBinaryExp(AProperSubsetBinaryExp node, PType ltype = node.getLeft().getType(); PType rtype = node.getRight().getType(); + if (question.assistantFactory.createPTypeAssistant().isSet(ltype) && + question.assistantFactory.createPTypeAssistant().isSet(rtype) && + !question.assistantFactory.getTypeComparator().compatible(ltype, rtype)) + { + TypeCheckerErrors.report(3335, "Subset will only be true if the LHS set is empty", node.getLocation(), node); + TypeCheckerErrors.detail("Left", ltype); + TypeCheckerErrors.detail("Right", rtype); + } + if (!question.assistantFactory.createPTypeAssistant().isSet(ltype)) { TypeCheckerErrors.report(3146, "Left hand of " + node.getOp() @@ -1084,6 +1093,15 @@ public PType caseASubsetBinaryExp(ASubsetBinaryExp node, PType ltype = node.getLeft().getType(); PType rtype = node.getRight().getType(); + if (question.assistantFactory.createPTypeAssistant().isSet(ltype) && + question.assistantFactory.createPTypeAssistant().isSet(rtype) && + !question.assistantFactory.getTypeComparator().compatible(ltype, rtype)) + { + TypeCheckerErrors.report(3335, "Subset will only be true if the LHS set is empty", node.getLocation(), node); + TypeCheckerErrors.detail("Left", ltype); + TypeCheckerErrors.detail("Right", rtype); + } + if (!question.assistantFactory.createPTypeAssistant().isSet(ltype)) { TypeCheckerErrors.report(3177, "Left hand of " + node.getOp() diff --git a/core/typechecker/src/test/resources/Type_Check_PP_Classes_TestSuite_External/fulltest/PP/extexplopdef/extexplopdef.vpp.result b/core/typechecker/src/test/resources/Type_Check_PP_Classes_TestSuite_External/fulltest/PP/extexplopdef/extexplopdef.vpp.result index fd8b63d5e2..6727e995b8 100644 --- a/core/typechecker/src/test/resources/Type_Check_PP_Classes_TestSuite_External/fulltest/PP/extexplopdef/extexplopdef.vpp.result +++ b/core/typechecker/src/test/resources/Type_Check_PP_Classes_TestSuite_External/fulltest/PP/extexplopdef/extexplopdef.vpp.result @@ -1,8 +1,8 @@ - + diff --git a/core/typechecker/src/test/resources/Type_Check_PP_Classes_TestSuite_External/fulltest/PP/fundefpp/fundefpp.vpp.result b/core/typechecker/src/test/resources/Type_Check_PP_Classes_TestSuite_External/fulltest/PP/fundefpp/fundefpp.vpp.result index e2b9fbb2db..ca19dc2124 100644 --- a/core/typechecker/src/test/resources/Type_Check_PP_Classes_TestSuite_External/fulltest/PP/fundefpp/fundefpp.vpp.result +++ b/core/typechecker/src/test/resources/Type_Check_PP_Classes_TestSuite_External/fulltest/PP/fundefpp/fundefpp.vpp.result @@ -1,7 +1,7 @@ - + diff --git a/core/typechecker/src/test/resources/Type_Check_PP_Classes_TestSuite_External/fulltest/PP/stmtpp/casesstmt/casesstmt.vpp.result b/core/typechecker/src/test/resources/Type_Check_PP_Classes_TestSuite_External/fulltest/PP/stmtpp/casesstmt/casesstmt.vpp.result index 927769675c..6fa559fb0a 100644 --- a/core/typechecker/src/test/resources/Type_Check_PP_Classes_TestSuite_External/fulltest/PP/stmtpp/casesstmt/casesstmt.vpp.result +++ b/core/typechecker/src/test/resources/Type_Check_PP_Classes_TestSuite_External/fulltest/PP/stmtpp/casesstmt/casesstmt.vpp.result @@ -7,8 +7,8 @@ - + diff --git a/core/typechecker/src/test/resources/Type_Check_PP_Classes_TestSuite_External/fulltest/PP/stmtpp/rectrapstmt/rectrapstmt.vpp.result b/core/typechecker/src/test/resources/Type_Check_PP_Classes_TestSuite_External/fulltest/PP/stmtpp/rectrapstmt/rectrapstmt.vpp.result index f8390134ad..af8d924179 100644 --- a/core/typechecker/src/test/resources/Type_Check_PP_Classes_TestSuite_External/fulltest/PP/stmtpp/rectrapstmt/rectrapstmt.vpp.result +++ b/core/typechecker/src/test/resources/Type_Check_PP_Classes_TestSuite_External/fulltest/PP/stmtpp/rectrapstmt/rectrapstmt.vpp.result @@ -8,8 +8,8 @@ - + diff --git a/core/typechecker/src/test/resources/Type_Check_RT_Classes_TestSuite_External/VICE/extension/extension-06.vpp.result b/core/typechecker/src/test/resources/Type_Check_RT_Classes_TestSuite_External/VICE/extension/extension-06.vpp.result index 646bf3cd2f..049151bf8b 100644 --- a/core/typechecker/src/test/resources/Type_Check_RT_Classes_TestSuite_External/VICE/extension/extension-06.vpp.result +++ b/core/typechecker/src/test/resources/Type_Check_RT_Classes_TestSuite_External/VICE/extension/extension-06.vpp.result @@ -1,6 +1,6 @@ - + diff --git a/core/typechecker/src/test/resources/Type_Check_RT_Classes_TestSuite_External/VICE/extension/extension-08.vpp.result b/core/typechecker/src/test/resources/Type_Check_RT_Classes_TestSuite_External/VICE/extension/extension-08.vpp.result index fe56f679c1..ef50b33d23 100644 --- a/core/typechecker/src/test/resources/Type_Check_RT_Classes_TestSuite_External/VICE/extension/extension-08.vpp.result +++ b/core/typechecker/src/test/resources/Type_Check_RT_Classes_TestSuite_External/VICE/extension/extension-08.vpp.result @@ -1,7 +1,7 @@ - + diff --git a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/binaryexpr/propersubset/propersubset-06.vdm.result b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/binaryexpr/propersubset/propersubset-06.vdm.result index e868ad08c8..26260069f2 100644 --- a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/binaryexpr/propersubset/propersubset-06.vdm.result +++ b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/binaryexpr/propersubset/propersubset-06.vdm.result @@ -1,4 +1,5 @@ + diff --git a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/binaryexpr/propersubset/propersubset-07.vdm.result b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/binaryexpr/propersubset/propersubset-07.vdm.result index e868ad08c8..e855ae0ad9 100644 --- a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/binaryexpr/propersubset/propersubset-07.vdm.result +++ b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/binaryexpr/propersubset/propersubset-07.vdm.result @@ -1,4 +1,5 @@ + diff --git a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/binaryexpr/propersubset/propersubset-08.vdm.result b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/binaryexpr/propersubset/propersubset-08.vdm.result index e868ad08c8..2d3a49d33a 100644 --- a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/binaryexpr/propersubset/propersubset-08.vdm.result +++ b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/binaryexpr/propersubset/propersubset-08.vdm.result @@ -1,4 +1,5 @@ + diff --git a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/binaryexpr/subset/subset-06.vdm.result b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/binaryexpr/subset/subset-06.vdm.result index e868ad08c8..a3da07362f 100644 --- a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/binaryexpr/subset/subset-06.vdm.result +++ b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/binaryexpr/subset/subset-06.vdm.result @@ -1,4 +1,5 @@ + diff --git a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/binaryexpr/subset/subset-07.vdm.result b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/binaryexpr/subset/subset-07.vdm.result index e868ad08c8..c871493fac 100644 --- a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/binaryexpr/subset/subset-07.vdm.result +++ b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/binaryexpr/subset/subset-07.vdm.result @@ -1,4 +1,5 @@ + diff --git a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/binaryexpr/subset/subset-08.vdm.result b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/binaryexpr/subset/subset-08.vdm.result index e868ad08c8..79641ec1de 100644 --- a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/binaryexpr/subset/subset-08.vdm.result +++ b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/binaryexpr/subset/subset-08.vdm.result @@ -1,4 +1,5 @@ + diff --git a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/casesexpr/casesexpr-03.vdm.result b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/casesexpr/casesexpr-03.vdm.result index 77d4f4891c..93f5623800 100644 --- a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/casesexpr/casesexpr-03.vdm.result +++ b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/casesexpr/casesexpr-03.vdm.result @@ -1,7 +1,7 @@ - + diff --git a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/fulltest/CORE/stmt/casesstmt/casesstmt-03.vdm.result b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/fulltest/CORE/stmt/casesstmt/casesstmt-03.vdm.result index 6ce890778d..890d9f2fd5 100644 --- a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/fulltest/CORE/stmt/casesstmt/casesstmt-03.vdm.result +++ b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/fulltest/CORE/stmt/casesstmt/casesstmt-03.vdm.result @@ -1,8 +1,8 @@ - + diff --git a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/fulltest/CORE/stmt/letbestmt/letbestmt.vdm.result b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/fulltest/CORE/stmt/letbestmt/letbestmt.vdm.result index 014e15d67a..cf2b5998c6 100644 --- a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/fulltest/CORE/stmt/letbestmt/letbestmt.vdm.result +++ b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/fulltest/CORE/stmt/letbestmt/letbestmt.vdm.result @@ -1,7 +1,7 @@ - + diff --git a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/fulltest/SL/modules06/modules06.vdm.result b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/fulltest/SL/modules06/modules06.vdm.result index de0fac8f72..70df24e1d3 100644 --- a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/fulltest/SL/modules06/modules06.vdm.result +++ b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/fulltest/SL/modules06/modules06.vdm.result @@ -1,7 +1,7 @@ - + diff --git a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/fulltest/SL/opdef/opdef.vdm.result b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/fulltest/SL/opdef/opdef.vdm.result index 870e59d0e9..7d855e0d72 100644 --- a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/fulltest/SL/opdef/opdef.vdm.result +++ b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/fulltest/SL/opdef/opdef.vdm.result @@ -4,8 +4,8 @@ - + diff --git a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/fulltest/SL/stmtsl/rectrapstmt/rectrapstmt.vdm.result b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/fulltest/SL/stmtsl/rectrapstmt/rectrapstmt.vdm.result index 2985d5baa9..b11319d604 100644 --- a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/fulltest/SL/stmtsl/rectrapstmt/rectrapstmt.vdm.result +++ b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/fulltest/SL/stmtsl/rectrapstmt/rectrapstmt.vdm.result @@ -8,8 +8,8 @@ - + diff --git a/core/typechecker/src/test/resources/modules/looseSL.result b/core/typechecker/src/test/resources/modules/looseSL.result index f42ecf26ab..e326b75a66 100644 --- a/core/typechecker/src/test/resources/modules/looseSL.result +++ b/core/typechecker/src/test/resources/modules/looseSL.result @@ -4,8 +4,8 @@ - + diff --git a/core/typechecker/src/test/resources/modules/newspeakSL.result b/core/typechecker/src/test/resources/modules/newspeakSL.result index a0d76c0f05..6ae2d9c74b 100644 --- a/core/typechecker/src/test/resources/modules/newspeakSL.result +++ b/core/typechecker/src/test/resources/modules/newspeakSL.result @@ -41,8 +41,8 @@ - + @@ -56,30 +56,30 @@ - - - + + + - + - + - + @@ -91,18 +91,18 @@ - + - + - + @@ -112,16 +112,16 @@ - + - + - - + + @@ -130,8 +130,8 @@ - + @@ -142,16 +142,16 @@ - - + + - + @@ -163,40 +163,40 @@ - + - - + + - + - + - - + + - + - + - + diff --git a/core/typechecker/src/test/resources/modules/simulatorSL.result b/core/typechecker/src/test/resources/modules/simulatorSL.result index 34db7adb6c..b13f37eadd 100644 --- a/core/typechecker/src/test/resources/modules/simulatorSL.result +++ b/core/typechecker/src/test/resources/modules/simulatorSL.result @@ -4,14 +4,14 @@ - - + + - + diff --git a/core/typechecker/src/test/resources/modules/trafficSL.result b/core/typechecker/src/test/resources/modules/trafficSL.result index 01e7a87641..6bc7d07e78 100644 --- a/core/typechecker/src/test/resources/modules/trafficSL.result +++ b/core/typechecker/src/test/resources/modules/trafficSL.result @@ -6,8 +6,8 @@ - + From 2e1cbe926f86632a06f4feb3a2260251542bf491 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Peter=20Tran-J=C3=B8rgensen?= Date: Tue, 17 Mar 2015 23:44:37 +0100 Subject: [PATCH 291/323] Issue with codegen-maven-plugin pom --- core/codegen/codegen-maven-plugin/pom.xml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/core/codegen/codegen-maven-plugin/pom.xml b/core/codegen/codegen-maven-plugin/pom.xml index e708aaa49c..c1fbc2ea12 100644 --- a/core/codegen/codegen-maven-plugin/pom.xml +++ b/core/codegen/codegen-maven-plugin/pom.xml @@ -2,8 +2,8 @@ 4.0.0 - org.overturetool - core + org.overturetool.core + codegen 2.2.3-SNAPSHOT ../pom.xml From 4471022d13f71bc5078467fa66454bfb75ef99af Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Peter=20Tran-J=C3=B8rgensen?= Date: Wed, 18 Mar 2015 18:38:16 +0100 Subject: [PATCH 292/323] Updates to test results related to code generation of the abs, floor and power operators --- .../resources/complex_expressions/AbsNumberDereference.result | 2 +- .../concurrency_classics_specs/POP3_LogBased_Test1.result | 2 +- .../javagen/src/test/resources/expressions/AbsInTuple.result | 2 +- .../javagen/src/test/resources/expressions/AbsOperator.result | 2 +- .../src/test/resources/expressions/FloorExpression.result | 2 +- .../codegen/javagen/src/test/resources/expressions/Power.result | 2 +- .../src/test/resources/specifications/FloorAssignment.result | 2 +- 7 files changed, 7 insertions(+), 7 deletions(-) diff --git a/core/codegen/javagen/src/test/resources/complex_expressions/AbsNumberDereference.result b/core/codegen/javagen/src/test/resources/complex_expressions/AbsNumberDereference.result index fd672d42f0..e8470539ac 100644 --- a/core/codegen/javagen/src/test/resources/complex_expressions/AbsNumberDereference.result +++ b/core/codegen/javagen/src/test/resources/complex_expressions/AbsNumberDereference.result @@ -10,7 +10,7 @@ public class Entry { public static Object Run() { Number x0 = -1.1; - return Math.abs(x0.doubleValue()); + return Utils.abs(x0.doubleValue()); } public String toString() { diff --git a/core/codegen/javagen/src/test/resources/concurrency_classics_specs/POP3_LogBased_Test1.result b/core/codegen/javagen/src/test/resources/concurrency_classics_specs/POP3_LogBased_Test1.result index 4991902e69..4273e2c591 100644 --- a/core/codegen/javagen/src/test/resources/concurrency_classics_specs/POP3_LogBased_Test1.result +++ b/core/codegen/javagen/src/test/resources/concurrency_classics_specs/POP3_LogBased_Test1.result @@ -1061,7 +1061,7 @@ public class POP3ClientHandler extends VDMThread implements EvaluatePP { } private static Number Abs(final Number i) { - return Math.abs(i.longValue()); + return Utils.abs(i.longValue()); } private static String int2stringR(final Number n) { diff --git a/core/codegen/javagen/src/test/resources/expressions/AbsInTuple.result b/core/codegen/javagen/src/test/resources/expressions/AbsInTuple.result index c9f4c103e6..b08c636cfd 100644 --- a/core/codegen/javagen/src/test/resources/expressions/AbsInTuple.result +++ b/core/codegen/javagen/src/test/resources/expressions/AbsInTuple.result @@ -1 +1 @@ -Tuple.mk_(Math.abs( -2L), Math.abs( -2.5)) \ No newline at end of file +Tuple.mk_(Utils.abs(-2L) , Utils.abs(-2.5) ) \ No newline at end of file diff --git a/core/codegen/javagen/src/test/resources/expressions/AbsOperator.result b/core/codegen/javagen/src/test/resources/expressions/AbsOperator.result index cee2caabaa..f70ac9299f 100644 --- a/core/codegen/javagen/src/test/resources/expressions/AbsOperator.result +++ b/core/codegen/javagen/src/test/resources/expressions/AbsOperator.result @@ -1 +1 @@ -Math.abs( -2.1) \ No newline at end of file +Utils.abs(-2.1) \ No newline at end of file diff --git a/core/codegen/javagen/src/test/resources/expressions/FloorExpression.result b/core/codegen/javagen/src/test/resources/expressions/FloorExpression.result index b3145bd2d2..1cfe7095f2 100644 --- a/core/codegen/javagen/src/test/resources/expressions/FloorExpression.result +++ b/core/codegen/javagen/src/test/resources/expressions/FloorExpression.result @@ -1 +1 @@ -Math.round(Math.floor( -1.5)) \ No newline at end of file +Math.round(Utils.floor(-1.5)) \ No newline at end of file diff --git a/core/codegen/javagen/src/test/resources/expressions/Power.result b/core/codegen/javagen/src/test/resources/expressions/Power.result index d380f9873b..68a44cbd5c 100644 --- a/core/codegen/javagen/src/test/resources/expressions/Power.result +++ b/core/codegen/javagen/src/test/resources/expressions/Power.result @@ -1 +1 @@ -Math.pow(2.1, 4.1) \ No newline at end of file +Utils.pow(2.1, 4.1) \ No newline at end of file diff --git a/core/codegen/javagen/src/test/resources/specifications/FloorAssignment.result b/core/codegen/javagen/src/test/resources/specifications/FloorAssignment.result index 47ee05c286..8d6b91557f 100644 --- a/core/codegen/javagen/src/test/resources/specifications/FloorAssignment.result +++ b/core/codegen/javagen/src/test/resources/specifications/FloorAssignment.result @@ -4,7 +4,7 @@ import java.util.*; public class A { - public static final Number x = Math.round(Math.floor(-1.5)) - 3L; + public static final Number x = Math.round(Utils.floor(-1.5)) - 3L; public A() { } From ec2038524a89669343b517a046cd21ce051e99b6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Peter=20Tran-J=C3=B8rgensen?= Date: Wed, 18 Mar 2015 18:39:58 +0100 Subject: [PATCH 293/323] The abs, floor and power operators is now handled by the code generation runtime library --- .../org/overture/codegen/runtime/Utils.java | 30 +++++++++++++++++++ .../Expressions/Binary/Numeric/Power.vm | 2 +- .../JavaTemplates/Expressions/Unary/Abs.vm | 7 +---- .../JavaTemplates/Expressions/Unary/Floor.vm | 2 +- 4 files changed, 33 insertions(+), 8 deletions(-) diff --git a/core/codegen/codegen-runtime/src/main/java/org/overture/codegen/runtime/Utils.java b/core/codegen/codegen-runtime/src/main/java/org/overture/codegen/runtime/Utils.java index 3b735ac80e..9d5dfadec4 100644 --- a/core/codegen/codegen-runtime/src/main/java/org/overture/codegen/runtime/Utils.java +++ b/core/codegen/codegen-runtime/src/main/java/org/overture/codegen/runtime/Utils.java @@ -344,4 +344,34 @@ private static Double getDoubleValue(Object value) return doubleValue; } + + public static double floor(Number n) + { + if(n == null) + { + throw new IllegalArgumentException("The 'floor' operator only works for numbers. Got null"); + } + + return Math.floor(n.doubleValue()); + } + + public static double abs(Number n) + { + if(n == null) + { + throw new IllegalArgumentException("The 'abs' operator only works for numbers. Got null"); + } + + return Math.abs(n.doubleValue()); + } + + public static double pow(Number a, Number b) + { + if(a == null || b == null) + { + throw new IllegalArgumentException("The power operator only works for numbers. Got arguments: '" + a + "' and '" + b + "'"); + } + + return Math.pow(a.doubleValue(), b.doubleValue()); + } } diff --git a/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Power.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Power.vm index d3e58ebf70..fe30b85ea1 100644 --- a/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Power.vm +++ b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Binary/Numeric/Power.vm @@ -1 +1 @@ -Math.pow($JavaFormat.format($node.getLeft()), $JavaFormat.format($node.getRight())) \ No newline at end of file +Utils.pow($JavaFormat.format($node.getLeft()), $JavaFormat.format($node.getRight())) \ No newline at end of file diff --git a/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/Abs.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/Abs.vm index 78b4e3ecc5..16a09a1c48 100644 --- a/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/Abs.vm +++ b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/Abs.vm @@ -1,6 +1 @@ -## -## Java has overloads for Math.abs that both take/return the same type. -## Therefore this template will adapt accordingly to how numbers are -## represented in the OO AST. -## -Math.abs( $JavaFormat.format($node.getExp())) \ No newline at end of file +Utils.abs($JavaFormat.format($node.getExp())) \ No newline at end of file diff --git a/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/Floor.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/Floor.vm index 70dfb2fcd8..58e7635ede 100644 --- a/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/Floor.vm +++ b/core/codegen/javagen/src/main/resources/JavaTemplates/Expressions/Unary/Floor.vm @@ -1 +1 @@ -Math.round(Math.floor( $JavaFormat.format($node.getExp()))) \ No newline at end of file +Math.round(Utils.floor($JavaFormat.format($node.getExp()))) \ No newline at end of file From a691fe98c170f5eba06236395b81e9a5293d989f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Peter=20Tran-J=C3=B8rgensen?= Date: Wed, 18 Mar 2015 18:44:01 +0100 Subject: [PATCH 294/323] Minor update to result file related to code generation of the 'abs' operator --- .../javagen/src/test/resources/expressions/AbsInTuple.result | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/codegen/javagen/src/test/resources/expressions/AbsInTuple.result b/core/codegen/javagen/src/test/resources/expressions/AbsInTuple.result index b08c636cfd..ff0e192c88 100644 --- a/core/codegen/javagen/src/test/resources/expressions/AbsInTuple.result +++ b/core/codegen/javagen/src/test/resources/expressions/AbsInTuple.result @@ -1 +1 @@ -Tuple.mk_(Utils.abs(-2L) , Utils.abs(-2.5) ) \ No newline at end of file +Tuple.mk_(Utils.abs(-2L), Utils.abs(-2.5)) \ No newline at end of file From 60c960751bf8d742c860b2f9f8268a24cf5ab8b9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Peter=20Tran-J=C3=B8rgensen?= Date: Wed, 18 Mar 2015 19:51:34 +0100 Subject: [PATCH 295/323] Added test revealing problem with code generation of the 'floor' operator --- .../complex_expressions/MathAbsFloorPower | 17 ++++++++++++ .../MathAbsFloorPower.result | 26 +++++++++++++++++++ 2 files changed, 43 insertions(+) create mode 100644 core/codegen/javagen/src/test/resources/complex_expressions/MathAbsFloorPower create mode 100644 core/codegen/javagen/src/test/resources/complex_expressions/MathAbsFloorPower.result diff --git a/core/codegen/javagen/src/test/resources/complex_expressions/MathAbsFloorPower b/core/codegen/javagen/src/test/resources/complex_expressions/MathAbsFloorPower new file mode 100644 index 0000000000..d23315678a --- /dev/null +++ b/core/codegen/javagen/src/test/resources/complex_expressions/MathAbsFloorPower @@ -0,0 +1,17 @@ +class Entry + +operations + +public static Run : () ==> ? +Run () == +let a1 = 1.5, + a2 = floor a1, + a3 = -9, + a4 = abs a3, + a5 = 2.5, + a6 = a5 ** a1 + +in + return floor a2 + a4 + a6; + +end Entry diff --git a/core/codegen/javagen/src/test/resources/complex_expressions/MathAbsFloorPower.result b/core/codegen/javagen/src/test/resources/complex_expressions/MathAbsFloorPower.result new file mode 100644 index 0000000000..92703511fd --- /dev/null +++ b/core/codegen/javagen/src/test/resources/complex_expressions/MathAbsFloorPower.result @@ -0,0 +1,26 @@ +import org.overture.codegen.runtime.*; + +import java.util.*; + + +public class Entry { + public Entry() { + } + + public static Object Run() { + Number a1 = 1.5; + Number a2 = Math.round(Utils.floor(a1)); + Number a3 = -9L; + Number a4 = Utils.abs(a3.longValue()); + Number a5 = 2.5; + Number a6 = Utils.pow(a5.doubleValue(), a1.doubleValue()); + + return Math.round(Utils.floor(a2)) + a4.longValue() + a6.doubleValue(); + } + + public String toString() { + return "Entry{}"; + } +} + +########## From ed0f1fe396d912e338f56830e061fa3eb4abd463 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Peter=20Tran-J=C3=B8rgensen?= Date: Wed, 18 Mar 2015 21:30:47 +0100 Subject: [PATCH 296/323] Updated the toString representation of code generated quotes to match that of VDM --- .../overture/codegen/vdm2java/JavaCodeGen.java | 2 +- .../vdm2java/JavaQuoteValueCreator.java | 18 +++++++++--------- 2 files changed, 10 insertions(+), 10 deletions(-) diff --git a/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java index 0dade9f90c..8f2c517d8e 100644 --- a/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java +++ b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGen.java @@ -171,7 +171,7 @@ public List generateJavaFromVdmQuotes() for (String quoteNameVdm : quoteValues) { AClassDeclCG quoteDecl = quoteValueCreator.consQuoteValue(quoteNameVdm - + JAVA_QUOTE_NAME_SUFFIX, getJavaSettings().getJavaRootPackage()); + + JAVA_QUOTE_NAME_SUFFIX, quoteNameVdm, getJavaSettings().getJavaRootPackage()); StringWriter writer = new StringWriter(); quoteDecl.apply(javaFormat.getMergeVisitor(), writer); diff --git a/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaQuoteValueCreator.java b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaQuoteValueCreator.java index 427d7cf69d..159793811e 100644 --- a/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaQuoteValueCreator.java +++ b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaQuoteValueCreator.java @@ -46,12 +46,12 @@ public JavaQuoteValueCreator(IRInfo info, TransAssistantCG transformationAssista this.transformationAssistant = transformationAssistant; } - public AClassDeclCG consQuoteValue(String name, String userCodePackage) + public AClassDeclCG consQuoteValue(String quoteClassName, String quoteName, String userCodePackage) { AClassDeclCG decl = new AClassDeclCG(); decl.setAbstract(false); decl.setAccess(JavaFormat.JAVA_PUBLIC); - decl.setName(name); + decl.setName(quoteClassName); decl.setStatic(false); // The package where the quotes are put is userCode.quotes @@ -66,13 +66,13 @@ public AClassDeclCG consQuoteValue(String name, String userCodePackage) } decl.getFields().add(consHashcodeField()); - decl.getFields().add(consInstanceField(name)); + decl.getFields().add(consInstanceField(quoteClassName)); - decl.getMethods().add(consQuoteCtor(name)); - decl.getMethods().add(consGetInstanceMethod(name)); - decl.getMethods().add(consHashcodeMethod(name)); - decl.getMethods().add(consEqualsMethod(name)); - decl.getMethods().add(consToStringMethod(name)); + decl.getMethods().add(consQuoteCtor(quoteClassName)); + decl.getMethods().add(consGetInstanceMethod(quoteClassName)); + decl.getMethods().add(consHashcodeMethod()); + decl.getMethods().add(consEqualsMethod(quoteClassName)); + decl.getMethods().add(consToStringMethod(quoteName)); return decl; } @@ -210,7 +210,7 @@ private AMethodDeclCG consGetInstanceMethod(String name) return getInstanceMethod; } - private AMethodDeclCG consHashcodeMethod(String name) + private AMethodDeclCG consHashcodeMethod() { AIdentifierVarExpCG hashCodeVar = transformationAssistant.consIdentifierVar(HASHCODE_FIELD, consFieldType()); From 66a01e76b3e751ee1be094a350dde23d953c4ce2 Mon Sep 17 00:00:00 2001 From: Nick Battle Date: Thu, 19 Mar 2015 14:13:50 +0000 Subject: [PATCH 297/323] Incorrect type check of "++" operator, fixes #433 --- .../modifiers/polyfuncs/polyfun-20.vpp.result | 2 +- .../modifiers/polyfuncs/polyfun-23.vpp.result | 2 +- .../modifiers/polyfuncs/polyfun-24.vpp.result | 2 +- .../modifiers/polyfuncs/polyfun-25.vpp.result | 2 +- .../modifiers/polyfuncs/polyfun-27.vpp.result | 2 +- .../seqmodifymapoverrideexpr-17.vdm.result | 2 +- .../seqmodifymapoverrideexpr-18.vdm.result | 2 +- .../expr/casesexpr/casesexpr-46.vdm.result | 2 +- .../expr/casesexpr/casesexpr-48.vdm.result | 2 +- .../expr/casesexpr/casesexpr-66.vdm.result | 2 +- .../expr/casesexpr/casesexpr-68.vdm.result | 2 +- .../CORE/expr/ifexpr/ifexpr-46.vdm.result | 2 +- .../CORE/expr/ifexpr/ifexpr-48.vdm.result | 2 +- .../CORE/expr/ifexpr/ifexpr-66.vdm.result | 2 +- .../CORE/expr/ifexpr/ifexpr-68.vdm.result | 2 +- .../seqmodifymapoverrideexpr-16.vdm.result | 2 +- .../seqmodifymapoverrideexpr-17.vdm.result | 2 +- .../seqmodifymapoverrideexpr-18.vdm.result | 2 +- .../visitor/TypeCheckerExpVisitor.java | 33 +++++++++++---- .../PP/access-types/access-types.vpp.result | 2 +- .../PP/extexplopdef/extexplopdef.vpp.result | 2 +- .../fulltest/PP/fundefpp/fundefpp.vpp.result | 2 +- .../PP/stmtpp/casesstmt/casesstmt.vpp.result | 2 +- .../PP/stmtpp/trapstmt/trapstmt.vpp.result | 2 +- .../VICE/basicext/basicext-04.vpp.result | 2 +- .../VICE/extension/extension-08.vpp.result | 2 +- .../expr/casesexpr/casesexpr-46.vdm.result | 4 ++ .../expr/casesexpr/casesexpr-48.vdm.result | 6 +++ .../expr/casesexpr/casesexpr-66.vdm.result | 3 ++ .../expr/casesexpr/casesexpr-68.vdm.result | 8 ++++ .../CORE/expr/ifexpr/ifexpr-46.vdm.result | 4 ++ .../CORE/expr/ifexpr/ifexpr-48.vdm.result | 6 +++ .../CORE/expr/ifexpr/ifexpr-66.vdm.result | 3 ++ .../CORE/expr/ifexpr/ifexpr-68.vdm.result | 8 ++++ .../seqmodifymapoverrideexpr-16.vdm.result | 3 ++ .../seqmodifymapoverrideexpr-17.vdm.result | 2 + .../seqmodifymapoverrideexpr-18.vdm.result | 2 + .../stmt/casesstmt/casesstmt-01.vdm.result | 2 +- .../SL/modules06/modules06.vdm.result | 2 +- .../fulltest/SL/opdef/opdef.vdm.result | 2 +- .../SL/stmtsl/trapstmt/trapstmt.vdm.result | 2 +- .../src/test/resources/modules/looseSL.result | 4 +- .../src/test/resources/modules/metroSL.result | 2 +- .../test/resources/modules/newspeakSL.result | 42 +++++++++---------- .../test/resources/modules/simulatorSL.result | 6 +-- .../test/resources/modules/trafficSL.result | 6 +-- 46 files changed, 134 insertions(+), 66 deletions(-) diff --git a/core/testing/tests/src/test/resources/external/cgip/pptest/PP/modifiers/polyfuncs/polyfun-20.vpp.result b/core/testing/tests/src/test/resources/external/cgip/pptest/PP/modifiers/polyfuncs/polyfun-20.vpp.result index bffca10776..98a42a58eb 100644 --- a/core/testing/tests/src/test/resources/external/cgip/pptest/PP/modifiers/polyfuncs/polyfun-20.vpp.result +++ b/core/testing/tests/src/test/resources/external/cgip/pptest/PP/modifiers/polyfuncs/polyfun-20.vpp.result @@ -1 +1 @@ -["Error 3142: polyfun-20.vpp at 6:15 Right hand of \u0027++\u0027 is not a map","Error 3182: polyfun-20.vpp at 17:10 Name \u0027post_f(seq1 of (nat1), seq1 of (nat1))\u0027 is not in scope"] \ No newline at end of file +["Error 3327: polyfun-20.vpp at 6:18 Value is not of the right type","Error 3142: polyfun-20.vpp at 6:15 Right hand of \u0027++\u0027 is not a map","Error 3182: polyfun-20.vpp at 17:10 Name \u0027post_f(seq1 of (nat1), seq1 of (nat1))\u0027 is not in scope"] \ No newline at end of file diff --git a/core/testing/tests/src/test/resources/external/cgip/pptest/PP/modifiers/polyfuncs/polyfun-23.vpp.result b/core/testing/tests/src/test/resources/external/cgip/pptest/PP/modifiers/polyfuncs/polyfun-23.vpp.result index 649ccc9436..b51fa4eb19 100644 --- a/core/testing/tests/src/test/resources/external/cgip/pptest/PP/modifiers/polyfuncs/polyfun-23.vpp.result +++ b/core/testing/tests/src/test/resources/external/cgip/pptest/PP/modifiers/polyfuncs/polyfun-23.vpp.result @@ -1 +1 @@ -["Error 3142: polyfun-23.vpp at 6:15 Right hand of \u0027++\u0027 is not a map","Error 3182: polyfun-23.vpp at 17:10 Name \u0027post_f(seq1 of (nat1), seq1 of (nat1))\u0027 is not in scope"] \ No newline at end of file +["Error 3327: polyfun-23.vpp at 6:18 Value is not of the right type","Error 3142: polyfun-23.vpp at 6:15 Right hand of \u0027++\u0027 is not a map","Error 3182: polyfun-23.vpp at 17:10 Name \u0027post_f(seq1 of (nat1), seq1 of (nat1))\u0027 is not in scope"] \ No newline at end of file diff --git a/core/testing/tests/src/test/resources/external/cgip/pptest/PP/modifiers/polyfuncs/polyfun-24.vpp.result b/core/testing/tests/src/test/resources/external/cgip/pptest/PP/modifiers/polyfuncs/polyfun-24.vpp.result index ade31c8402..6996f18969 100644 --- a/core/testing/tests/src/test/resources/external/cgip/pptest/PP/modifiers/polyfuncs/polyfun-24.vpp.result +++ b/core/testing/tests/src/test/resources/external/cgip/pptest/PP/modifiers/polyfuncs/polyfun-24.vpp.result @@ -1 +1 @@ -["Error 3142: polyfun-24.vpp at 6:15 Right hand of \u0027++\u0027 is not a map","Error 3092: polyfun-24.vpp at 17:18 Inaccessible member post_f(seq1 of (nat1), seq1 of (nat1)) of class A"] \ No newline at end of file +["Error 3327: polyfun-24.vpp at 6:18 Value is not of the right type","Error 3142: polyfun-24.vpp at 6:15 Right hand of \u0027++\u0027 is not a map","Error 3092: polyfun-24.vpp at 17:18 Inaccessible member post_f(seq1 of (nat1), seq1 of (nat1)) of class A"] \ No newline at end of file diff --git a/core/testing/tests/src/test/resources/external/cgip/pptest/PP/modifiers/polyfuncs/polyfun-25.vpp.result b/core/testing/tests/src/test/resources/external/cgip/pptest/PP/modifiers/polyfuncs/polyfun-25.vpp.result index 19aa487de2..f21ff204b3 100644 --- a/core/testing/tests/src/test/resources/external/cgip/pptest/PP/modifiers/polyfuncs/polyfun-25.vpp.result +++ b/core/testing/tests/src/test/resources/external/cgip/pptest/PP/modifiers/polyfuncs/polyfun-25.vpp.result @@ -1 +1 @@ -["Error 3142: polyfun-25.vpp at 6:15 Right hand of \u0027++\u0027 is not a map","Error 3092: polyfun-25.vpp at 17:18 Inaccessible member post_f(seq1 of (nat1), seq1 of (nat1)) of class A"] \ No newline at end of file +["Error 3327: polyfun-25.vpp at 6:18 Value is not of the right type","Error 3142: polyfun-25.vpp at 6:15 Right hand of \u0027++\u0027 is not a map","Error 3092: polyfun-25.vpp at 17:18 Inaccessible member post_f(seq1 of (nat1), seq1 of (nat1)) of class A"] \ No newline at end of file diff --git a/core/testing/tests/src/test/resources/external/cgip/pptest/PP/modifiers/polyfuncs/polyfun-27.vpp.result b/core/testing/tests/src/test/resources/external/cgip/pptest/PP/modifiers/polyfuncs/polyfun-27.vpp.result index 07537bcd48..fab87e56d4 100644 --- a/core/testing/tests/src/test/resources/external/cgip/pptest/PP/modifiers/polyfuncs/polyfun-27.vpp.result +++ b/core/testing/tests/src/test/resources/external/cgip/pptest/PP/modifiers/polyfuncs/polyfun-27.vpp.result @@ -1 +1 @@ -["Error 3142: polyfun-27.vpp at 6:15 Right hand of \u0027++\u0027 is not a map","Error 3092: polyfun-27.vpp at 17:18 Inaccessible member post_f(seq1 of (nat1), seq1 of (nat1)) of class A"] \ No newline at end of file +["Error 3327: polyfun-27.vpp at 6:18 Value is not of the right type","Error 3142: polyfun-27.vpp at 6:15 Right hand of \u0027++\u0027 is not a map","Error 3092: polyfun-27.vpp at 17:18 Inaccessible member post_f(seq1 of (nat1), seq1 of (nat1)) of class A"] \ No newline at end of file diff --git a/core/testing/tests/src/test/resources/external/pog/sltest/exprtest/CORE/expr/seqmodifymapoverrideexpr/seqmodifymapoverrideexpr-17.vdm.result b/core/testing/tests/src/test/resources/external/pog/sltest/exprtest/CORE/expr/seqmodifymapoverrideexpr/seqmodifymapoverrideexpr-17.vdm.result index 64a9953b64..39e5b2d0cd 100644 --- a/core/testing/tests/src/test/resources/external/pog/sltest/exprtest/CORE/expr/seqmodifymapoverrideexpr/seqmodifymapoverrideexpr-17.vdm.result +++ b/core/testing/tests/src/test/resources/external/pog/sltest/exprtest/CORE/expr/seqmodifymapoverrideexpr/seqmodifymapoverrideexpr-17.vdm.result @@ -1 +1 @@ -["seqmodifymapoverrideexpr-17.vdmparses and type checks"] \ No newline at end of file +["Error 3327: seqmodifymapoverrideexpr-17.vdm at 32:29 Value is not of the right type","Error 3327: seqmodifymapoverrideexpr-17.vdm at 32:37 Value is not of the right type"] \ No newline at end of file diff --git a/core/testing/tests/src/test/resources/external/pog/sltest/exprtest/CORE/expr/seqmodifymapoverrideexpr/seqmodifymapoverrideexpr-18.vdm.result b/core/testing/tests/src/test/resources/external/pog/sltest/exprtest/CORE/expr/seqmodifymapoverrideexpr/seqmodifymapoverrideexpr-18.vdm.result index 42e919f95c..f3c1a93725 100644 --- a/core/testing/tests/src/test/resources/external/pog/sltest/exprtest/CORE/expr/seqmodifymapoverrideexpr/seqmodifymapoverrideexpr-18.vdm.result +++ b/core/testing/tests/src/test/resources/external/pog/sltest/exprtest/CORE/expr/seqmodifymapoverrideexpr/seqmodifymapoverrideexpr-18.vdm.result @@ -1 +1 @@ -["seqmodifymapoverrideexpr-18.vdmparses and type checks"] \ No newline at end of file +["Error 3327: seqmodifymapoverrideexpr-18.vdm at 35:34 Value is not of the right type","Error 3327: seqmodifymapoverrideexpr-18.vdm at 35:43 Value is not of the right type"] \ No newline at end of file diff --git a/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/casesexpr/casesexpr-46.vdm.result b/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/casesexpr/casesexpr-46.vdm.result index cb36f4f057..a4021ecfc3 100644 --- a/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/casesexpr/casesexpr-46.vdm.result +++ b/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/casesexpr/casesexpr-46.vdm.result @@ -1 +1 @@ -["Error 3327: casesexpr-46.vdm at 35:11 Value is not of the right type","Error 3327: casesexpr-46.vdm at 38:12 Value is not of the right type","Error 3327: casesexpr-46.vdm at 38:25 Value is not of the right type","Error 3327: casesexpr-46.vdm at 38:31 Value is not of the right type","Error 3327: casesexpr-46.vdm at 41:12 Value is not of the right type","Error 3327: casesexpr-46.vdm at 41:25 Value is not of the right type","Error 3327: casesexpr-46.vdm at 41:31 Value is not of the right type","Error 3327: casesexpr-46.vdm at 41:52 Value is not of the right type","Error 3327: casesexpr-46.vdm at 41:58 Value is not of the right type","Error 3327: casesexpr-46.vdm at 47:12 Value is not of the right type","Error 3327: casesexpr-46.vdm at 47:14 Value is not of the right type","Error 3327: casesexpr-46.vdm at 47:21 Value is not of the right type","Error 3327: casesexpr-46.vdm at 47:34 Value is not of the right type","Error 3327: casesexpr-46.vdm at 47:40 Value is not of the right type","Error 3327: casesexpr-46.vdm at 50:12 Value is not of the right type","Error 3327: casesexpr-46.vdm at 50:14 Value is not of the right type","Error 3327: casesexpr-46.vdm at 50:22 Value is not of the right type","Error 3327: casesexpr-46.vdm at 50:35 Value is not of the right type","Error 3327: casesexpr-46.vdm at 50:41 Value is not of the right type","Error 3327: casesexpr-46.vdm at 53:12 Value is not of the right type","Error 3327: casesexpr-46.vdm at 53:25 Value is not of the right type","Error 3327: casesexpr-46.vdm at 53:31 Value is not of the right type","Error 3327: casesexpr-46.vdm at 53:48 Value is not of the right type","Error 3327: casesexpr-46.vdm at 53:50 Value is not of the right type","Error 3153: casesexpr-46.vdm at 53:44 Restriction of map should be set of ((nat1 * bool) | seq1 of (char))","Error 3327: casesexpr-46.vdm at 56:12 Value is not of the right type","Error 3327: casesexpr-46.vdm at 56:25 Value is not of the right type","Error 3327: casesexpr-46.vdm at 56:31 Value is not of the right type","Error 3327: casesexpr-46.vdm at 56:49 Value is not of the right type","Error 3327: casesexpr-46.vdm at 56:51 Value is not of the right type","Error 3150: casesexpr-46.vdm at 56:44 Restriction of map should be set of ((nat1 * bool) | seq1 of (char))","Error 3327: casesexpr-46.vdm at 59:12 Value is not of the right type","Error 3327: casesexpr-46.vdm at 59:18 Value is not of the right type","Error 3327: casesexpr-46.vdm at 59:30 Value is not of the right type","Error 3327: casesexpr-46.vdm at 59:39 Value is not of the right type","Error 3327: casesexpr-46.vdm at 59:44 Value is not of the right type","Error 3327: casesexpr-46.vdm at 59:52 Value is not of the right type","Error 3327: casesexpr-46.vdm at 61:20 Value is not of the right type","Error 3051: casesexpr-46.vdm at 32:15 Expression does not match declared type"] \ No newline at end of file +["Error 3327: casesexpr-46.vdm at 35:11 Value is not of the right type","Error 3327: casesexpr-46.vdm at 38:12 Value is not of the right type","Error 3327: casesexpr-46.vdm at 38:25 Value is not of the right type","Error 3327: casesexpr-46.vdm at 38:31 Value is not of the right type","Error 3327: casesexpr-46.vdm at 41:12 Value is not of the right type","Error 3327: casesexpr-46.vdm at 41:25 Value is not of the right type","Error 3327: casesexpr-46.vdm at 41:31 Value is not of the right type","Error 3327: casesexpr-46.vdm at 41:52 Value is not of the right type","Error 3327: casesexpr-46.vdm at 41:58 Value is not of the right type","Error 3327: casesexpr-46.vdm at 44:12 Value is not of the right type","Error 3327: casesexpr-46.vdm at 44:25 Value is not of the right type","Error 3327: casesexpr-46.vdm at 44:31 Value is not of the right type","Error 3327: casesexpr-46.vdm at 44:54 Value is not of the right type","Error 3327: casesexpr-46.vdm at 47:12 Value is not of the right type","Error 3327: casesexpr-46.vdm at 47:14 Value is not of the right type","Error 3327: casesexpr-46.vdm at 47:21 Value is not of the right type","Error 3327: casesexpr-46.vdm at 47:34 Value is not of the right type","Error 3327: casesexpr-46.vdm at 47:40 Value is not of the right type","Error 3327: casesexpr-46.vdm at 50:12 Value is not of the right type","Error 3327: casesexpr-46.vdm at 50:14 Value is not of the right type","Error 3327: casesexpr-46.vdm at 50:22 Value is not of the right type","Error 3327: casesexpr-46.vdm at 50:35 Value is not of the right type","Error 3327: casesexpr-46.vdm at 50:41 Value is not of the right type","Error 3327: casesexpr-46.vdm at 53:12 Value is not of the right type","Error 3327: casesexpr-46.vdm at 53:25 Value is not of the right type","Error 3327: casesexpr-46.vdm at 53:31 Value is not of the right type","Error 3327: casesexpr-46.vdm at 53:48 Value is not of the right type","Error 3327: casesexpr-46.vdm at 53:50 Value is not of the right type","Error 3153: casesexpr-46.vdm at 53:44 Restriction of map should be set of ((nat1 * bool) | seq1 of (char))","Error 3327: casesexpr-46.vdm at 56:12 Value is not of the right type","Error 3327: casesexpr-46.vdm at 56:25 Value is not of the right type","Error 3327: casesexpr-46.vdm at 56:31 Value is not of the right type","Error 3327: casesexpr-46.vdm at 56:49 Value is not of the right type","Error 3327: casesexpr-46.vdm at 56:51 Value is not of the right type","Error 3150: casesexpr-46.vdm at 56:44 Restriction of map should be set of ((nat1 * bool) | seq1 of (char))","Error 3327: casesexpr-46.vdm at 59:12 Value is not of the right type","Error 3327: casesexpr-46.vdm at 59:18 Value is not of the right type","Error 3327: casesexpr-46.vdm at 59:30 Value is not of the right type","Error 3327: casesexpr-46.vdm at 59:39 Value is not of the right type","Error 3327: casesexpr-46.vdm at 59:44 Value is not of the right type","Error 3327: casesexpr-46.vdm at 59:52 Value is not of the right type","Error 3327: casesexpr-46.vdm at 61:20 Value is not of the right type","Error 3051: casesexpr-46.vdm at 32:15 Expression does not match declared type"] \ No newline at end of file diff --git a/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/casesexpr/casesexpr-48.vdm.result b/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/casesexpr/casesexpr-48.vdm.result index 73371851a2..a0837a805e 100644 --- a/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/casesexpr/casesexpr-48.vdm.result +++ b/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/casesexpr/casesexpr-48.vdm.result @@ -1 +1 @@ -["Error 3327: casesexpr-48.vdm at 38:11 Value is not of the right type","Error 3327: casesexpr-48.vdm at 47:11 Value is not of the right type","Error 3327: casesexpr-48.vdm at 50:11 Value is not of the right type","Error 3327: casesexpr-48.vdm at 53:11 Value is not of the right type","Error 3059: casesexpr-48.vdm at 56:11 Too many arguments","Error 3327: casesexpr-48.vdm at 56:11 Value is not of the right type","Error 3327: casesexpr-48.vdm at 65:12 Value is not of the right type","Error 3327: casesexpr-48.vdm at 65:18 Value is not of the right type","Error 3327: casesexpr-48.vdm at 65:30 Value is not of the right type","Error 3327: casesexpr-48.vdm at 65:39 Value is not of the right type","Error 3327: casesexpr-48.vdm at 65:44 Value is not of the right type","Error 3327: casesexpr-48.vdm at 65:52 Value is not of the right type","Error 3327: casesexpr-48.vdm at 68:13 Value is not of the right type","Error 3327: casesexpr-48.vdm at 71:11 Value is not of the right type","Error 3327: casesexpr-48.vdm at 73:20 Value is not of the right type","Error 3051: casesexpr-48.vdm at 35:15 Expression does not match declared type"] \ No newline at end of file +["Error 3327: casesexpr-48.vdm at 38:11 Value is not of the right type","Error 3327: casesexpr-48.vdm at 47:11 Value is not of the right type","Error 3327: casesexpr-48.vdm at 50:11 Value is not of the right type","Error 3327: casesexpr-48.vdm at 53:11 Value is not of the right type","Error 3059: casesexpr-48.vdm at 56:11 Too many arguments","Error 3327: casesexpr-48.vdm at 56:11 Value is not of the right type","Error 3327: casesexpr-48.vdm at 59:31 Value is not of the right type","Error 3327: casesexpr-48.vdm at 62:12 Value is not of the right type","Error 3327: casesexpr-48.vdm at 62:18 Value is not of the right type","Error 3327: casesexpr-48.vdm at 62:24 Value is not of the right type","Error 3327: casesexpr-48.vdm at 62:30 Value is not of the right type","Error 3327: casesexpr-48.vdm at 62:45 Value is not of the right type","Error 3327: casesexpr-48.vdm at 65:12 Value is not of the right type","Error 3327: casesexpr-48.vdm at 65:18 Value is not of the right type","Error 3327: casesexpr-48.vdm at 65:30 Value is not of the right type","Error 3327: casesexpr-48.vdm at 65:39 Value is not of the right type","Error 3327: casesexpr-48.vdm at 65:44 Value is not of the right type","Error 3327: casesexpr-48.vdm at 65:52 Value is not of the right type","Error 3327: casesexpr-48.vdm at 68:13 Value is not of the right type","Error 3327: casesexpr-48.vdm at 71:11 Value is not of the right type","Error 3327: casesexpr-48.vdm at 73:20 Value is not of the right type","Error 3051: casesexpr-48.vdm at 35:15 Expression does not match declared type"] \ No newline at end of file diff --git a/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/casesexpr/casesexpr-66.vdm.result b/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/casesexpr/casesexpr-66.vdm.result index 6bd5749c68..37b2c45053 100644 --- a/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/casesexpr/casesexpr-66.vdm.result +++ b/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/casesexpr/casesexpr-66.vdm.result @@ -1 +1 @@ -["Error 3327: casesexpr-66.vdm at 38:11 Value is not of the right type","Error 3327: casesexpr-66.vdm at 41:12 Value is not of the right type","Error 3327: casesexpr-66.vdm at 41:20 Value is not of the right type","Error 3327: casesexpr-66.vdm at 41:25 Value is not of the right type","Error 3327: casesexpr-66.vdm at 41:33 Value is not of the right type","Error 3327: casesexpr-66.vdm at 44:12 Value is not of the right type","Error 3327: casesexpr-66.vdm at 44:20 Value is not of the right type","Error 3327: casesexpr-66.vdm at 44:25 Value is not of the right type","Error 3327: casesexpr-66.vdm at 44:33 Value is not of the right type","Error 3327: casesexpr-66.vdm at 44:54 Value is not of the right type","Error 3327: casesexpr-66.vdm at 50:12 Value is not of the right type","Error 3327: casesexpr-66.vdm at 50:16 Value is not of the right type","Error 3327: casesexpr-66.vdm at 50:25 Value is not of the right type","Error 3327: casesexpr-66.vdm at 50:33 Value is not of the right type","Error 3327: casesexpr-66.vdm at 50:38 Value is not of the right type","Error 3327: casesexpr-66.vdm at 50:46 Value is not of the right type","Error 3327: casesexpr-66.vdm at 53:12 Value is not of the right type","Error 3327: casesexpr-66.vdm at 53:14 Value is not of the right type","Error 3327: casesexpr-66.vdm at 53:22 Value is not of the right type","Error 3327: casesexpr-66.vdm at 53:30 Value is not of the right type","Error 3327: casesexpr-66.vdm at 53:35 Value is not of the right type","Error 3327: casesexpr-66.vdm at 53:43 Value is not of the right type","Error 3327: casesexpr-66.vdm at 56:12 Value is not of the right type","Error 3327: casesexpr-66.vdm at 56:20 Value is not of the right type","Error 3327: casesexpr-66.vdm at 56:25 Value is not of the right type","Error 3327: casesexpr-66.vdm at 56:33 Value is not of the right type","Error 3153: casesexpr-66.vdm at 56:46 Restriction of map should be set of ((nat1 * bool) | seq1 of (char))","Error 3327: casesexpr-66.vdm at 59:12 Value is not of the right type","Error 3327: casesexpr-66.vdm at 59:20 Value is not of the right type","Error 3327: casesexpr-66.vdm at 59:25 Value is not of the right type","Error 3327: casesexpr-66.vdm at 59:33 Value is not of the right type","Error 3150: casesexpr-66.vdm at 59:46 Restriction of map should be set of ((nat1 * bool) | seq1 of (char))","Error 3327: casesexpr-66.vdm at 62:12 Value is not of the right type","Error 3327: casesexpr-66.vdm at 62:20 Value is not of the right type","Error 3327: casesexpr-66.vdm at 62:32 Value is not of the right type","Error 3327: casesexpr-66.vdm at 62:43 Value is not of the right type","Error 3327: casesexpr-66.vdm at 64:20 Value is not of the right type"] \ No newline at end of file +["Error 3327: casesexpr-66.vdm at 38:11 Value is not of the right type","Error 3327: casesexpr-66.vdm at 41:12 Value is not of the right type","Error 3327: casesexpr-66.vdm at 41:20 Value is not of the right type","Error 3327: casesexpr-66.vdm at 41:25 Value is not of the right type","Error 3327: casesexpr-66.vdm at 41:33 Value is not of the right type","Error 3327: casesexpr-66.vdm at 44:12 Value is not of the right type","Error 3327: casesexpr-66.vdm at 44:20 Value is not of the right type","Error 3327: casesexpr-66.vdm at 44:25 Value is not of the right type","Error 3327: casesexpr-66.vdm at 44:33 Value is not of the right type","Error 3327: casesexpr-66.vdm at 44:54 Value is not of the right type","Error 3327: casesexpr-66.vdm at 47:12 Value is not of the right type","Error 3327: casesexpr-66.vdm at 47:25 Value is not of the right type","Error 3327: casesexpr-66.vdm at 47:50 Value is not of the right type","Error 3327: casesexpr-66.vdm at 50:12 Value is not of the right type","Error 3327: casesexpr-66.vdm at 50:16 Value is not of the right type","Error 3327: casesexpr-66.vdm at 50:25 Value is not of the right type","Error 3327: casesexpr-66.vdm at 50:33 Value is not of the right type","Error 3327: casesexpr-66.vdm at 50:38 Value is not of the right type","Error 3327: casesexpr-66.vdm at 50:46 Value is not of the right type","Error 3327: casesexpr-66.vdm at 53:12 Value is not of the right type","Error 3327: casesexpr-66.vdm at 53:14 Value is not of the right type","Error 3327: casesexpr-66.vdm at 53:22 Value is not of the right type","Error 3327: casesexpr-66.vdm at 53:30 Value is not of the right type","Error 3327: casesexpr-66.vdm at 53:35 Value is not of the right type","Error 3327: casesexpr-66.vdm at 53:43 Value is not of the right type","Error 3327: casesexpr-66.vdm at 56:12 Value is not of the right type","Error 3327: casesexpr-66.vdm at 56:20 Value is not of the right type","Error 3327: casesexpr-66.vdm at 56:25 Value is not of the right type","Error 3327: casesexpr-66.vdm at 56:33 Value is not of the right type","Error 3153: casesexpr-66.vdm at 56:46 Restriction of map should be set of ((nat1 * bool) | seq1 of (char))","Error 3327: casesexpr-66.vdm at 59:12 Value is not of the right type","Error 3327: casesexpr-66.vdm at 59:20 Value is not of the right type","Error 3327: casesexpr-66.vdm at 59:25 Value is not of the right type","Error 3327: casesexpr-66.vdm at 59:33 Value is not of the right type","Error 3150: casesexpr-66.vdm at 59:46 Restriction of map should be set of ((nat1 * bool) | seq1 of (char))","Error 3327: casesexpr-66.vdm at 62:12 Value is not of the right type","Error 3327: casesexpr-66.vdm at 62:20 Value is not of the right type","Error 3327: casesexpr-66.vdm at 62:32 Value is not of the right type","Error 3327: casesexpr-66.vdm at 62:43 Value is not of the right type","Error 3327: casesexpr-66.vdm at 64:20 Value is not of the right type"] \ No newline at end of file diff --git a/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/casesexpr/casesexpr-68.vdm.result b/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/casesexpr/casesexpr-68.vdm.result index cc1ff75960..0d8433ac2b 100644 --- a/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/casesexpr/casesexpr-68.vdm.result +++ b/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/casesexpr/casesexpr-68.vdm.result @@ -1 +1 @@ -["Error 3327: casesexpr-68.vdm at 39:11 Value is not of the right type","Error 3327: casesexpr-68.vdm at 48:11 Value is not of the right type","Error 3327: casesexpr-68.vdm at 51:11 Value is not of the right type","Error 3327: casesexpr-68.vdm at 54:11 Value is not of the right type","Error 3059: casesexpr-68.vdm at 57:11 Too many arguments","Error 3327: casesexpr-68.vdm at 57:11 Value is not of the right type","Error 3327: casesexpr-68.vdm at 66:12 Value is not of the right type","Error 3327: casesexpr-68.vdm at 66:20 Value is not of the right type","Error 3327: casesexpr-68.vdm at 66:32 Value is not of the right type","Error 3327: casesexpr-68.vdm at 66:44 Value is not of the right type","Error 3327: casesexpr-68.vdm at 69:13 Value is not of the right type","Error 3327: casesexpr-68.vdm at 72:11 Value is not of the right type","Error 3327: casesexpr-68.vdm at 74:20 Value is not of the right type","Error 3051: casesexpr-68.vdm at 36:15 Expression does not match declared type"] \ No newline at end of file +["Error 3327: casesexpr-68.vdm at 39:11 Value is not of the right type","Error 3327: casesexpr-68.vdm at 48:11 Value is not of the right type","Error 3327: casesexpr-68.vdm at 51:11 Value is not of the right type","Error 3327: casesexpr-68.vdm at 54:11 Value is not of the right type","Error 3059: casesexpr-68.vdm at 57:11 Too many arguments","Error 3327: casesexpr-68.vdm at 57:11 Value is not of the right type","Error 3327: casesexpr-68.vdm at 60:12 Value is not of the right type","Error 3327: casesexpr-68.vdm at 60:14 Value is not of the right type","Error 3327: casesexpr-68.vdm at 60:19 Value is not of the right type","Error 3327: casesexpr-68.vdm at 60:26 Value is not of the right type","Error 3327: casesexpr-68.vdm at 60:34 Value is not of the right type","Error 3327: casesexpr-68.vdm at 63:12 Value is not of the right type","Error 3327: casesexpr-68.vdm at 63:23 Value is not of the right type","Error 3327: casesexpr-68.vdm at 63:36 Value is not of the right type","Error 3327: casesexpr-68.vdm at 66:12 Value is not of the right type","Error 3327: casesexpr-68.vdm at 66:20 Value is not of the right type","Error 3327: casesexpr-68.vdm at 66:32 Value is not of the right type","Error 3327: casesexpr-68.vdm at 66:44 Value is not of the right type","Error 3327: casesexpr-68.vdm at 69:13 Value is not of the right type","Error 3327: casesexpr-68.vdm at 72:11 Value is not of the right type","Error 3327: casesexpr-68.vdm at 74:20 Value is not of the right type","Error 3051: casesexpr-68.vdm at 36:15 Expression does not match declared type"] \ No newline at end of file diff --git a/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/ifexpr/ifexpr-46.vdm.result b/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/ifexpr/ifexpr-46.vdm.result index 203ea89255..82b0b373c6 100644 --- a/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/ifexpr/ifexpr-46.vdm.result +++ b/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/ifexpr/ifexpr-46.vdm.result @@ -1 +1 @@ -["Error 3327: ifexpr-46.vdm at 34:10 Value is not of the right type","Error 3327: ifexpr-46.vdm at 36:11 Value is not of the right type","Error 3327: ifexpr-46.vdm at 36:24 Value is not of the right type","Error 3327: ifexpr-46.vdm at 36:30 Value is not of the right type","Error 3327: ifexpr-46.vdm at 38:11 Value is not of the right type","Error 3327: ifexpr-46.vdm at 38:24 Value is not of the right type","Error 3327: ifexpr-46.vdm at 38:30 Value is not of the right type","Error 3327: ifexpr-46.vdm at 38:51 Value is not of the right type","Error 3327: ifexpr-46.vdm at 38:57 Value is not of the right type","Error 3327: ifexpr-46.vdm at 42:11 Value is not of the right type","Error 3327: ifexpr-46.vdm at 42:13 Value is not of the right type","Error 3327: ifexpr-46.vdm at 42:20 Value is not of the right type","Error 3327: ifexpr-46.vdm at 42:33 Value is not of the right type","Error 3327: ifexpr-46.vdm at 42:39 Value is not of the right type","Error 3327: ifexpr-46.vdm at 44:11 Value is not of the right type","Error 3327: ifexpr-46.vdm at 44:13 Value is not of the right type","Error 3327: ifexpr-46.vdm at 44:21 Value is not of the right type","Error 3327: ifexpr-46.vdm at 44:34 Value is not of the right type","Error 3327: ifexpr-46.vdm at 44:40 Value is not of the right type","Error 3327: ifexpr-46.vdm at 46:11 Value is not of the right type","Error 3327: ifexpr-46.vdm at 46:24 Value is not of the right type","Error 3327: ifexpr-46.vdm at 46:30 Value is not of the right type","Error 3327: ifexpr-46.vdm at 46:47 Value is not of the right type","Error 3327: ifexpr-46.vdm at 46:49 Value is not of the right type","Error 3153: ifexpr-46.vdm at 46:43 Restriction of map should be set of ((nat1 * bool) | seq1 of (char))","Error 3327: ifexpr-46.vdm at 48:11 Value is not of the right type","Error 3327: ifexpr-46.vdm at 48:24 Value is not of the right type","Error 3327: ifexpr-46.vdm at 48:30 Value is not of the right type","Error 3327: ifexpr-46.vdm at 48:48 Value is not of the right type","Error 3327: ifexpr-46.vdm at 48:50 Value is not of the right type","Error 3150: ifexpr-46.vdm at 48:43 Restriction of map should be set of ((nat1 * bool) | seq1 of (char))","Error 3327: ifexpr-46.vdm at 50:11 Value is not of the right type","Error 3327: ifexpr-46.vdm at 50:17 Value is not of the right type","Error 3327: ifexpr-46.vdm at 50:29 Value is not of the right type","Error 3327: ifexpr-46.vdm at 50:38 Value is not of the right type","Error 3327: ifexpr-46.vdm at 50:43 Value is not of the right type","Error 3327: ifexpr-46.vdm at 50:51 Value is not of the right type","Error 3327: ifexpr-46.vdm at 51:10 Value is not of the right type","Error 3051: ifexpr-46.vdm at 32:14 Expression does not match declared type"] \ No newline at end of file +["Error 3327: ifexpr-46.vdm at 34:10 Value is not of the right type","Error 3327: ifexpr-46.vdm at 36:11 Value is not of the right type","Error 3327: ifexpr-46.vdm at 36:24 Value is not of the right type","Error 3327: ifexpr-46.vdm at 36:30 Value is not of the right type","Error 3327: ifexpr-46.vdm at 38:11 Value is not of the right type","Error 3327: ifexpr-46.vdm at 38:24 Value is not of the right type","Error 3327: ifexpr-46.vdm at 38:30 Value is not of the right type","Error 3327: ifexpr-46.vdm at 38:51 Value is not of the right type","Error 3327: ifexpr-46.vdm at 38:57 Value is not of the right type","Error 3327: ifexpr-46.vdm at 40:11 Value is not of the right type","Error 3327: ifexpr-46.vdm at 40:24 Value is not of the right type","Error 3327: ifexpr-46.vdm at 40:30 Value is not of the right type","Error 3327: ifexpr-46.vdm at 40:53 Value is not of the right type","Error 3327: ifexpr-46.vdm at 42:11 Value is not of the right type","Error 3327: ifexpr-46.vdm at 42:13 Value is not of the right type","Error 3327: ifexpr-46.vdm at 42:20 Value is not of the right type","Error 3327: ifexpr-46.vdm at 42:33 Value is not of the right type","Error 3327: ifexpr-46.vdm at 42:39 Value is not of the right type","Error 3327: ifexpr-46.vdm at 44:11 Value is not of the right type","Error 3327: ifexpr-46.vdm at 44:13 Value is not of the right type","Error 3327: ifexpr-46.vdm at 44:21 Value is not of the right type","Error 3327: ifexpr-46.vdm at 44:34 Value is not of the right type","Error 3327: ifexpr-46.vdm at 44:40 Value is not of the right type","Error 3327: ifexpr-46.vdm at 46:11 Value is not of the right type","Error 3327: ifexpr-46.vdm at 46:24 Value is not of the right type","Error 3327: ifexpr-46.vdm at 46:30 Value is not of the right type","Error 3327: ifexpr-46.vdm at 46:47 Value is not of the right type","Error 3327: ifexpr-46.vdm at 46:49 Value is not of the right type","Error 3153: ifexpr-46.vdm at 46:43 Restriction of map should be set of ((nat1 * bool) | seq1 of (char))","Error 3327: ifexpr-46.vdm at 48:11 Value is not of the right type","Error 3327: ifexpr-46.vdm at 48:24 Value is not of the right type","Error 3327: ifexpr-46.vdm at 48:30 Value is not of the right type","Error 3327: ifexpr-46.vdm at 48:48 Value is not of the right type","Error 3327: ifexpr-46.vdm at 48:50 Value is not of the right type","Error 3150: ifexpr-46.vdm at 48:43 Restriction of map should be set of ((nat1 * bool) | seq1 of (char))","Error 3327: ifexpr-46.vdm at 50:11 Value is not of the right type","Error 3327: ifexpr-46.vdm at 50:17 Value is not of the right type","Error 3327: ifexpr-46.vdm at 50:29 Value is not of the right type","Error 3327: ifexpr-46.vdm at 50:38 Value is not of the right type","Error 3327: ifexpr-46.vdm at 50:43 Value is not of the right type","Error 3327: ifexpr-46.vdm at 50:51 Value is not of the right type","Error 3327: ifexpr-46.vdm at 51:10 Value is not of the right type","Error 3051: ifexpr-46.vdm at 32:14 Expression does not match declared type"] \ No newline at end of file diff --git a/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/ifexpr/ifexpr-48.vdm.result b/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/ifexpr/ifexpr-48.vdm.result index bded1a4f95..35463c4314 100644 --- a/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/ifexpr/ifexpr-48.vdm.result +++ b/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/ifexpr/ifexpr-48.vdm.result @@ -1 +1 @@ -["Error 3327: ifexpr-48.vdm at 37:10 Value is not of the right type","Error 3327: ifexpr-48.vdm at 43:10 Value is not of the right type","Error 3327: ifexpr-48.vdm at 45:10 Value is not of the right type","Error 3327: ifexpr-48.vdm at 47:10 Value is not of the right type","Error 3059: ifexpr-48.vdm at 49:10 Too many arguments","Error 3327: ifexpr-48.vdm at 49:10 Value is not of the right type","Error 3327: ifexpr-48.vdm at 55:11 Value is not of the right type","Error 3327: ifexpr-48.vdm at 55:17 Value is not of the right type","Error 3327: ifexpr-48.vdm at 55:29 Value is not of the right type","Error 3327: ifexpr-48.vdm at 55:38 Value is not of the right type","Error 3327: ifexpr-48.vdm at 55:43 Value is not of the right type","Error 3327: ifexpr-48.vdm at 55:51 Value is not of the right type","Error 3327: ifexpr-48.vdm at 57:12 Value is not of the right type","Error 3327: ifexpr-48.vdm at 59:10 Value is not of the right type","Error 3327: ifexpr-48.vdm at 60:10 Value is not of the right type","Error 3051: ifexpr-48.vdm at 35:14 Expression does not match declared type"] \ No newline at end of file +["Error 3327: ifexpr-48.vdm at 37:10 Value is not of the right type","Error 3327: ifexpr-48.vdm at 43:10 Value is not of the right type","Error 3327: ifexpr-48.vdm at 45:10 Value is not of the right type","Error 3327: ifexpr-48.vdm at 47:10 Value is not of the right type","Error 3059: ifexpr-48.vdm at 49:10 Too many arguments","Error 3327: ifexpr-48.vdm at 49:10 Value is not of the right type","Error 3327: ifexpr-48.vdm at 51:30 Value is not of the right type","Error 3327: ifexpr-48.vdm at 53:11 Value is not of the right type","Error 3327: ifexpr-48.vdm at 53:17 Value is not of the right type","Error 3327: ifexpr-48.vdm at 53:23 Value is not of the right type","Error 3327: ifexpr-48.vdm at 53:29 Value is not of the right type","Error 3327: ifexpr-48.vdm at 53:44 Value is not of the right type","Error 3327: ifexpr-48.vdm at 55:11 Value is not of the right type","Error 3327: ifexpr-48.vdm at 55:17 Value is not of the right type","Error 3327: ifexpr-48.vdm at 55:29 Value is not of the right type","Error 3327: ifexpr-48.vdm at 55:38 Value is not of the right type","Error 3327: ifexpr-48.vdm at 55:43 Value is not of the right type","Error 3327: ifexpr-48.vdm at 55:51 Value is not of the right type","Error 3327: ifexpr-48.vdm at 57:12 Value is not of the right type","Error 3327: ifexpr-48.vdm at 59:10 Value is not of the right type","Error 3327: ifexpr-48.vdm at 60:10 Value is not of the right type","Error 3051: ifexpr-48.vdm at 35:14 Expression does not match declared type"] \ No newline at end of file diff --git a/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/ifexpr/ifexpr-66.vdm.result b/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/ifexpr/ifexpr-66.vdm.result index 18c29813fe..0abf04cf55 100644 --- a/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/ifexpr/ifexpr-66.vdm.result +++ b/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/ifexpr/ifexpr-66.vdm.result @@ -1 +1 @@ -["Error 3327: ifexpr-66.vdm at 37:10 Value is not of the right type","Error 3327: ifexpr-66.vdm at 39:11 Value is not of the right type","Error 3327: ifexpr-66.vdm at 39:19 Value is not of the right type","Error 3327: ifexpr-66.vdm at 39:24 Value is not of the right type","Error 3327: ifexpr-66.vdm at 39:32 Value is not of the right type","Error 3327: ifexpr-66.vdm at 41:11 Value is not of the right type","Error 3327: ifexpr-66.vdm at 41:19 Value is not of the right type","Error 3327: ifexpr-66.vdm at 41:24 Value is not of the right type","Error 3327: ifexpr-66.vdm at 41:32 Value is not of the right type","Error 3327: ifexpr-66.vdm at 41:53 Value is not of the right type","Error 3327: ifexpr-66.vdm at 45:11 Value is not of the right type","Error 3327: ifexpr-66.vdm at 45:13 Value is not of the right type","Error 3327: ifexpr-66.vdm at 45:20 Value is not of the right type","Error 3327: ifexpr-66.vdm at 45:28 Value is not of the right type","Error 3327: ifexpr-66.vdm at 45:33 Value is not of the right type","Error 3327: ifexpr-66.vdm at 45:41 Value is not of the right type","Error 3327: ifexpr-66.vdm at 47:11 Value is not of the right type","Error 3327: ifexpr-66.vdm at 47:13 Value is not of the right type","Error 3327: ifexpr-66.vdm at 47:21 Value is not of the right type","Error 3327: ifexpr-66.vdm at 47:29 Value is not of the right type","Error 3327: ifexpr-66.vdm at 47:34 Value is not of the right type","Error 3327: ifexpr-66.vdm at 47:42 Value is not of the right type","Error 3327: ifexpr-66.vdm at 49:11 Value is not of the right type","Error 3327: ifexpr-66.vdm at 49:19 Value is not of the right type","Error 3327: ifexpr-66.vdm at 49:24 Value is not of the right type","Error 3327: ifexpr-66.vdm at 49:32 Value is not of the right type","Error 3153: ifexpr-66.vdm at 49:45 Restriction of map should be set of ((nat1 * bool) | seq1 of (char))","Error 3327: ifexpr-66.vdm at 51:11 Value is not of the right type","Error 3327: ifexpr-66.vdm at 51:19 Value is not of the right type","Error 3327: ifexpr-66.vdm at 51:24 Value is not of the right type","Error 3327: ifexpr-66.vdm at 51:32 Value is not of the right type","Error 3150: ifexpr-66.vdm at 51:45 Restriction of map should be set of ((nat1 * bool) | seq1 of (char))","Error 3327: ifexpr-66.vdm at 53:11 Value is not of the right type","Error 3327: ifexpr-66.vdm at 53:19 Value is not of the right type","Error 3327: ifexpr-66.vdm at 53:31 Value is not of the right type","Error 3327: ifexpr-66.vdm at 53:43 Value is not of the right type","Error 3327: ifexpr-66.vdm at 54:10 Value is not of the right type"] \ No newline at end of file +["Error 3327: ifexpr-66.vdm at 37:10 Value is not of the right type","Error 3327: ifexpr-66.vdm at 39:11 Value is not of the right type","Error 3327: ifexpr-66.vdm at 39:19 Value is not of the right type","Error 3327: ifexpr-66.vdm at 39:24 Value is not of the right type","Error 3327: ifexpr-66.vdm at 39:32 Value is not of the right type","Error 3327: ifexpr-66.vdm at 41:11 Value is not of the right type","Error 3327: ifexpr-66.vdm at 41:19 Value is not of the right type","Error 3327: ifexpr-66.vdm at 41:24 Value is not of the right type","Error 3327: ifexpr-66.vdm at 41:32 Value is not of the right type","Error 3327: ifexpr-66.vdm at 41:53 Value is not of the right type","Error 3327: ifexpr-66.vdm at 43:11 Value is not of the right type","Error 3327: ifexpr-66.vdm at 43:24 Value is not of the right type","Error 3327: ifexpr-66.vdm at 43:49 Value is not of the right type","Error 3327: ifexpr-66.vdm at 45:11 Value is not of the right type","Error 3327: ifexpr-66.vdm at 45:13 Value is not of the right type","Error 3327: ifexpr-66.vdm at 45:20 Value is not of the right type","Error 3327: ifexpr-66.vdm at 45:28 Value is not of the right type","Error 3327: ifexpr-66.vdm at 45:33 Value is not of the right type","Error 3327: ifexpr-66.vdm at 45:41 Value is not of the right type","Error 3327: ifexpr-66.vdm at 47:11 Value is not of the right type","Error 3327: ifexpr-66.vdm at 47:13 Value is not of the right type","Error 3327: ifexpr-66.vdm at 47:21 Value is not of the right type","Error 3327: ifexpr-66.vdm at 47:29 Value is not of the right type","Error 3327: ifexpr-66.vdm at 47:34 Value is not of the right type","Error 3327: ifexpr-66.vdm at 47:42 Value is not of the right type","Error 3327: ifexpr-66.vdm at 49:11 Value is not of the right type","Error 3327: ifexpr-66.vdm at 49:19 Value is not of the right type","Error 3327: ifexpr-66.vdm at 49:24 Value is not of the right type","Error 3327: ifexpr-66.vdm at 49:32 Value is not of the right type","Error 3153: ifexpr-66.vdm at 49:45 Restriction of map should be set of ((nat1 * bool) | seq1 of (char))","Error 3327: ifexpr-66.vdm at 51:11 Value is not of the right type","Error 3327: ifexpr-66.vdm at 51:19 Value is not of the right type","Error 3327: ifexpr-66.vdm at 51:24 Value is not of the right type","Error 3327: ifexpr-66.vdm at 51:32 Value is not of the right type","Error 3150: ifexpr-66.vdm at 51:45 Restriction of map should be set of ((nat1 * bool) | seq1 of (char))","Error 3327: ifexpr-66.vdm at 53:11 Value is not of the right type","Error 3327: ifexpr-66.vdm at 53:19 Value is not of the right type","Error 3327: ifexpr-66.vdm at 53:31 Value is not of the right type","Error 3327: ifexpr-66.vdm at 53:43 Value is not of the right type","Error 3327: ifexpr-66.vdm at 54:10 Value is not of the right type"] \ No newline at end of file diff --git a/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/ifexpr/ifexpr-68.vdm.result b/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/ifexpr/ifexpr-68.vdm.result index a9b7b3d06b..739e9b2616 100644 --- a/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/ifexpr/ifexpr-68.vdm.result +++ b/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/ifexpr/ifexpr-68.vdm.result @@ -1 +1 @@ -["Error 3327: ifexpr-68.vdm at 37:10 Value is not of the right type","Error 3327: ifexpr-68.vdm at 43:10 Value is not of the right type","Error 3327: ifexpr-68.vdm at 45:10 Value is not of the right type","Error 3327: ifexpr-68.vdm at 47:10 Value is not of the right type","Error 3059: ifexpr-68.vdm at 49:10 Too many arguments","Error 3327: ifexpr-68.vdm at 49:10 Value is not of the right type","Error 3327: ifexpr-68.vdm at 55:11 Value is not of the right type","Error 3327: ifexpr-68.vdm at 55:19 Value is not of the right type","Error 3327: ifexpr-68.vdm at 55:31 Value is not of the right type","Error 3327: ifexpr-68.vdm at 55:41 Value is not of the right type","Error 3327: ifexpr-68.vdm at 57:12 Value is not of the right type","Error 3327: ifexpr-68.vdm at 59:10 Value is not of the right type","Error 3327: ifexpr-68.vdm at 60:10 Value is not of the right type","Error 3051: ifexpr-68.vdm at 35:14 Expression does not match declared type"] \ No newline at end of file +["Error 3327: ifexpr-68.vdm at 37:10 Value is not of the right type","Error 3327: ifexpr-68.vdm at 43:10 Value is not of the right type","Error 3327: ifexpr-68.vdm at 45:10 Value is not of the right type","Error 3327: ifexpr-68.vdm at 47:10 Value is not of the right type","Error 3059: ifexpr-68.vdm at 49:10 Too many arguments","Error 3327: ifexpr-68.vdm at 49:10 Value is not of the right type","Error 3327: ifexpr-68.vdm at 51:11 Value is not of the right type","Error 3327: ifexpr-68.vdm at 51:13 Value is not of the right type","Error 3327: ifexpr-68.vdm at 51:18 Value is not of the right type","Error 3327: ifexpr-68.vdm at 51:25 Value is not of the right type","Error 3327: ifexpr-68.vdm at 51:31 Value is not of the right type","Error 3327: ifexpr-68.vdm at 53:11 Value is not of the right type","Error 3327: ifexpr-68.vdm at 53:22 Value is not of the right type","Error 3327: ifexpr-68.vdm at 53:35 Value is not of the right type","Error 3327: ifexpr-68.vdm at 55:11 Value is not of the right type","Error 3327: ifexpr-68.vdm at 55:19 Value is not of the right type","Error 3327: ifexpr-68.vdm at 55:31 Value is not of the right type","Error 3327: ifexpr-68.vdm at 55:41 Value is not of the right type","Error 3327: ifexpr-68.vdm at 57:12 Value is not of the right type","Error 3327: ifexpr-68.vdm at 59:10 Value is not of the right type","Error 3327: ifexpr-68.vdm at 60:10 Value is not of the right type","Error 3051: ifexpr-68.vdm at 35:14 Expression does not match declared type"] \ No newline at end of file diff --git a/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/seqmodifymapoverrideexpr/seqmodifymapoverrideexpr-16.vdm.result b/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/seqmodifymapoverrideexpr/seqmodifymapoverrideexpr-16.vdm.result index fd578f04e3..a766a51ae5 100644 --- a/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/seqmodifymapoverrideexpr/seqmodifymapoverrideexpr-16.vdm.result +++ b/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/seqmodifymapoverrideexpr/seqmodifymapoverrideexpr-16.vdm.result @@ -1 +1 @@ -["seqmodifymapoverrideexpr-16.vdmparses and type checks"] \ No newline at end of file +["Error 3327: seqmodifymapoverrideexpr-16.vdm at 32:34 Value is not of the right type","Error 3327: seqmodifymapoverrideexpr-16.vdm at 33:34 Value is not of the right type","Error 3327: seqmodifymapoverrideexpr-16.vdm at 33:44 Value is not of the right type"] \ No newline at end of file diff --git a/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/seqmodifymapoverrideexpr/seqmodifymapoverrideexpr-17.vdm.result b/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/seqmodifymapoverrideexpr/seqmodifymapoverrideexpr-17.vdm.result index 64a9953b64..39e5b2d0cd 100644 --- a/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/seqmodifymapoverrideexpr/seqmodifymapoverrideexpr-17.vdm.result +++ b/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/seqmodifymapoverrideexpr/seqmodifymapoverrideexpr-17.vdm.result @@ -1 +1 @@ -["seqmodifymapoverrideexpr-17.vdmparses and type checks"] \ No newline at end of file +["Error 3327: seqmodifymapoverrideexpr-17.vdm at 32:29 Value is not of the right type","Error 3327: seqmodifymapoverrideexpr-17.vdm at 32:37 Value is not of the right type"] \ No newline at end of file diff --git a/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/seqmodifymapoverrideexpr/seqmodifymapoverrideexpr-18.vdm.result b/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/seqmodifymapoverrideexpr/seqmodifymapoverrideexpr-18.vdm.result index 42e919f95c..f3c1a93725 100644 --- a/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/seqmodifymapoverrideexpr/seqmodifymapoverrideexpr-18.vdm.result +++ b/core/testing/tests/src/test/resources/external/tc/sltest/exprtest/CORE/expr/seqmodifymapoverrideexpr/seqmodifymapoverrideexpr-18.vdm.result @@ -1 +1 @@ -["seqmodifymapoverrideexpr-18.vdmparses and type checks"] \ No newline at end of file +["Error 3327: seqmodifymapoverrideexpr-18.vdm at 35:34 Value is not of the right type","Error 3327: seqmodifymapoverrideexpr-18.vdm at 35:43 Value is not of the right type"] \ No newline at end of file diff --git a/core/typechecker/src/main/java/org/overture/typechecker/visitor/TypeCheckerExpVisitor.java b/core/typechecker/src/main/java/org/overture/typechecker/visitor/TypeCheckerExpVisitor.java index 78a2b17f04..e4544a7ed2 100644 --- a/core/typechecker/src/main/java/org/overture/typechecker/visitor/TypeCheckerExpVisitor.java +++ b/core/typechecker/src/main/java/org/overture/typechecker/visitor/TypeCheckerExpVisitor.java @@ -691,10 +691,26 @@ public PType caseATimesNumericBinaryExp(ATimesNumericBinaryExp node, public PType caseAPlusPlusBinaryExp(APlusPlusBinaryExp node, TypeCheckInfo question) throws AnalysisException { - TypeCheckInfo noConstraint = question.newConstraint(null); - - node.getLeft().apply(THIS, noConstraint); - node.getRight().apply(THIS, noConstraint); + TypeCheckInfo leftcons = question.newConstraint(null); + TypeCheckInfo mapcons = question.newConstraint(null); + + if (question.constraint != null && question.assistantFactory.createPTypeAssistant().isSeq(question.constraint)) + { + SSeqType st = question.assistantFactory.createPTypeAssistant().getSeq(question.constraint); + mapcons = question.newConstraint(AstFactory.newAMapMapType(node.getLocation(), + AstFactory.newANatOneNumericBasicType(node.getLocation()), st.getSeqof())); + leftcons = question.newConstraint(AstFactory.newASeqSeqType(node.getLocation())); + } + else if (question.constraint != null && question.assistantFactory.createPTypeAssistant().isMap(question.constraint)) + { + SMapType mt = question.assistantFactory.createPTypeAssistant().getMap(question.constraint); + mapcons = question.newConstraint(mt); + leftcons = question.newConstraint(AstFactory.newAMapMapType(node.getLocation(), + mt.getFrom(), AstFactory.newAUnknownType(node.getLocation()))); + } + + node.getLeft().apply(THIS, leftcons); + node.getRight().apply(THIS, mapcons); PTypeSet result = new PTypeSet(question.assistantFactory); @@ -733,7 +749,9 @@ public PType caseAPlusPlusBinaryExp(APlusPlusBinaryExp node, { TypeCheckerErrors.concern(unique, 3142, "Right hand of '++' is not a map", node.getLocation(), node); TypeCheckerErrors.detail(unique, "Type", node.getRight().getType()); - } else + result.add(st); + } + else { SMapType mr = question.assistantFactory.createPTypeAssistant().getMap(node.getRight().getType()); @@ -742,9 +760,10 @@ public PType caseAPlusPlusBinaryExp(APlusPlusBinaryExp node, TypeCheckerErrors.concern(unique, 3143, "Domain of right hand of '++' must be nat1", node.getLocation(), node); TypeCheckerErrors.detail(unique, "Type", mr.getFrom()); } + + result.add(AstFactory.newASeqSeqType(node.getLocation(), + AstFactory.newAUnionType(node.getLocation(), st.getSeqof(), mr.getTo()))); } - - result.add(st); } if (result.isEmpty()) diff --git a/core/typechecker/src/test/resources/Type_Check_PP_Classes_TestSuite_External/fulltest/PP/access-types/access-types.vpp.result b/core/typechecker/src/test/resources/Type_Check_PP_Classes_TestSuite_External/fulltest/PP/access-types/access-types.vpp.result index 4618ae6882..7062cec6a9 100644 --- a/core/typechecker/src/test/resources/Type_Check_PP_Classes_TestSuite_External/fulltest/PP/access-types/access-types.vpp.result +++ b/core/typechecker/src/test/resources/Type_Check_PP_Classes_TestSuite_External/fulltest/PP/access-types/access-types.vpp.result @@ -1,7 +1,7 @@ - + diff --git a/core/typechecker/src/test/resources/Type_Check_PP_Classes_TestSuite_External/fulltest/PP/extexplopdef/extexplopdef.vpp.result b/core/typechecker/src/test/resources/Type_Check_PP_Classes_TestSuite_External/fulltest/PP/extexplopdef/extexplopdef.vpp.result index 6727e995b8..fd8b63d5e2 100644 --- a/core/typechecker/src/test/resources/Type_Check_PP_Classes_TestSuite_External/fulltest/PP/extexplopdef/extexplopdef.vpp.result +++ b/core/typechecker/src/test/resources/Type_Check_PP_Classes_TestSuite_External/fulltest/PP/extexplopdef/extexplopdef.vpp.result @@ -1,8 +1,8 @@ - + diff --git a/core/typechecker/src/test/resources/Type_Check_PP_Classes_TestSuite_External/fulltest/PP/fundefpp/fundefpp.vpp.result b/core/typechecker/src/test/resources/Type_Check_PP_Classes_TestSuite_External/fulltest/PP/fundefpp/fundefpp.vpp.result index ca19dc2124..e2b9fbb2db 100644 --- a/core/typechecker/src/test/resources/Type_Check_PP_Classes_TestSuite_External/fulltest/PP/fundefpp/fundefpp.vpp.result +++ b/core/typechecker/src/test/resources/Type_Check_PP_Classes_TestSuite_External/fulltest/PP/fundefpp/fundefpp.vpp.result @@ -1,7 +1,7 @@ - + diff --git a/core/typechecker/src/test/resources/Type_Check_PP_Classes_TestSuite_External/fulltest/PP/stmtpp/casesstmt/casesstmt.vpp.result b/core/typechecker/src/test/resources/Type_Check_PP_Classes_TestSuite_External/fulltest/PP/stmtpp/casesstmt/casesstmt.vpp.result index 6fa559fb0a..927769675c 100644 --- a/core/typechecker/src/test/resources/Type_Check_PP_Classes_TestSuite_External/fulltest/PP/stmtpp/casesstmt/casesstmt.vpp.result +++ b/core/typechecker/src/test/resources/Type_Check_PP_Classes_TestSuite_External/fulltest/PP/stmtpp/casesstmt/casesstmt.vpp.result @@ -7,8 +7,8 @@ - + diff --git a/core/typechecker/src/test/resources/Type_Check_PP_Classes_TestSuite_External/fulltest/PP/stmtpp/trapstmt/trapstmt.vpp.result b/core/typechecker/src/test/resources/Type_Check_PP_Classes_TestSuite_External/fulltest/PP/stmtpp/trapstmt/trapstmt.vpp.result index c230a2b251..19801cc8f2 100644 --- a/core/typechecker/src/test/resources/Type_Check_PP_Classes_TestSuite_External/fulltest/PP/stmtpp/trapstmt/trapstmt.vpp.result +++ b/core/typechecker/src/test/resources/Type_Check_PP_Classes_TestSuite_External/fulltest/PP/stmtpp/trapstmt/trapstmt.vpp.result @@ -6,8 +6,8 @@ - + diff --git a/core/typechecker/src/test/resources/Type_Check_RT_Classes_TestSuite_External/VICE/basicext/basicext-04.vpp.result b/core/typechecker/src/test/resources/Type_Check_RT_Classes_TestSuite_External/VICE/basicext/basicext-04.vpp.result index 0d6cb38e41..84c567d193 100644 --- a/core/typechecker/src/test/resources/Type_Check_RT_Classes_TestSuite_External/VICE/basicext/basicext-04.vpp.result +++ b/core/typechecker/src/test/resources/Type_Check_RT_Classes_TestSuite_External/VICE/basicext/basicext-04.vpp.result @@ -1,8 +1,8 @@ - + diff --git a/core/typechecker/src/test/resources/Type_Check_RT_Classes_TestSuite_External/VICE/extension/extension-08.vpp.result b/core/typechecker/src/test/resources/Type_Check_RT_Classes_TestSuite_External/VICE/extension/extension-08.vpp.result index ef50b33d23..fe56f679c1 100644 --- a/core/typechecker/src/test/resources/Type_Check_RT_Classes_TestSuite_External/VICE/extension/extension-08.vpp.result +++ b/core/typechecker/src/test/resources/Type_Check_RT_Classes_TestSuite_External/VICE/extension/extension-08.vpp.result @@ -1,7 +1,7 @@ - + diff --git a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/casesexpr/casesexpr-46.vdm.result b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/casesexpr/casesexpr-46.vdm.result index d33d2fa1c1..eaf4be04e4 100644 --- a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/casesexpr/casesexpr-46.vdm.result +++ b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/casesexpr/casesexpr-46.vdm.result @@ -9,6 +9,10 @@ + + + + diff --git a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/casesexpr/casesexpr-48.vdm.result b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/casesexpr/casesexpr-48.vdm.result index c937849ab1..69cc539ba5 100644 --- a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/casesexpr/casesexpr-48.vdm.result +++ b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/casesexpr/casesexpr-48.vdm.result @@ -6,6 +6,12 @@ + + + + + + diff --git a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/casesexpr/casesexpr-66.vdm.result b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/casesexpr/casesexpr-66.vdm.result index 1d1a2473b3..01f0bb197a 100644 --- a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/casesexpr/casesexpr-66.vdm.result +++ b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/casesexpr/casesexpr-66.vdm.result @@ -10,6 +10,9 @@ + + + diff --git a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/casesexpr/casesexpr-68.vdm.result b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/casesexpr/casesexpr-68.vdm.result index 156ad0d35f..226d062d0d 100644 --- a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/casesexpr/casesexpr-68.vdm.result +++ b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/casesexpr/casesexpr-68.vdm.result @@ -6,6 +6,14 @@ + + + + + + + + diff --git a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/ifexpr/ifexpr-46.vdm.result b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/ifexpr/ifexpr-46.vdm.result index c5360e58fc..6379245ce1 100644 --- a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/ifexpr/ifexpr-46.vdm.result +++ b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/ifexpr/ifexpr-46.vdm.result @@ -9,6 +9,10 @@ + + + + diff --git a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/ifexpr/ifexpr-48.vdm.result b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/ifexpr/ifexpr-48.vdm.result index 3719c85c25..1c55d5337d 100644 --- a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/ifexpr/ifexpr-48.vdm.result +++ b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/ifexpr/ifexpr-48.vdm.result @@ -6,6 +6,12 @@ + + + + + + diff --git a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/ifexpr/ifexpr-66.vdm.result b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/ifexpr/ifexpr-66.vdm.result index fabfad392b..31a0e532d8 100644 --- a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/ifexpr/ifexpr-66.vdm.result +++ b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/ifexpr/ifexpr-66.vdm.result @@ -10,6 +10,9 @@ + + + diff --git a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/ifexpr/ifexpr-68.vdm.result b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/ifexpr/ifexpr-68.vdm.result index 89d8af8be7..c535f7a19b 100644 --- a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/ifexpr/ifexpr-68.vdm.result +++ b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/ifexpr/ifexpr-68.vdm.result @@ -6,6 +6,14 @@ + + + + + + + + diff --git a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/seqmodifymapoverrideexpr/seqmodifymapoverrideexpr-16.vdm.result b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/seqmodifymapoverrideexpr/seqmodifymapoverrideexpr-16.vdm.result index e868ad08c8..6b41af3a0c 100644 --- a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/seqmodifymapoverrideexpr/seqmodifymapoverrideexpr-16.vdm.result +++ b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/seqmodifymapoverrideexpr/seqmodifymapoverrideexpr-16.vdm.result @@ -1,4 +1,7 @@ + + + diff --git a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/seqmodifymapoverrideexpr/seqmodifymapoverrideexpr-17.vdm.result b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/seqmodifymapoverrideexpr/seqmodifymapoverrideexpr-17.vdm.result index e868ad08c8..5ce07ca64c 100644 --- a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/seqmodifymapoverrideexpr/seqmodifymapoverrideexpr-17.vdm.result +++ b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/seqmodifymapoverrideexpr/seqmodifymapoverrideexpr-17.vdm.result @@ -1,4 +1,6 @@ + + diff --git a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/seqmodifymapoverrideexpr/seqmodifymapoverrideexpr-18.vdm.result b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/seqmodifymapoverrideexpr/seqmodifymapoverrideexpr-18.vdm.result index e868ad08c8..d26382da49 100644 --- a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/seqmodifymapoverrideexpr/seqmodifymapoverrideexpr-18.vdm.result +++ b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/exprtest/CORE/expr/seqmodifymapoverrideexpr/seqmodifymapoverrideexpr-18.vdm.result @@ -1,4 +1,6 @@ + + diff --git a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/fulltest/CORE/stmt/casesstmt/casesstmt-01.vdm.result b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/fulltest/CORE/stmt/casesstmt/casesstmt-01.vdm.result index a11ec6ab26..81676f04ab 100644 --- a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/fulltest/CORE/stmt/casesstmt/casesstmt-01.vdm.result +++ b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/fulltest/CORE/stmt/casesstmt/casesstmt-01.vdm.result @@ -1,7 +1,7 @@ - + diff --git a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/fulltest/SL/modules06/modules06.vdm.result b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/fulltest/SL/modules06/modules06.vdm.result index 70df24e1d3..de0fac8f72 100644 --- a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/fulltest/SL/modules06/modules06.vdm.result +++ b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/fulltest/SL/modules06/modules06.vdm.result @@ -1,7 +1,7 @@ - + diff --git a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/fulltest/SL/opdef/opdef.vdm.result b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/fulltest/SL/opdef/opdef.vdm.result index 7d855e0d72..870e59d0e9 100644 --- a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/fulltest/SL/opdef/opdef.vdm.result +++ b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/fulltest/SL/opdef/opdef.vdm.result @@ -4,8 +4,8 @@ - + diff --git a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/fulltest/SL/stmtsl/trapstmt/trapstmt.vdm.result b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/fulltest/SL/stmtsl/trapstmt/trapstmt.vdm.result index 3047541ba8..18580e165f 100644 --- a/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/fulltest/SL/stmtsl/trapstmt/trapstmt.vdm.result +++ b/core/typechecker/src/test/resources/Type_Check_SL_Modules_TestSuite_External/fulltest/SL/stmtsl/trapstmt/trapstmt.vdm.result @@ -6,8 +6,8 @@ - + diff --git a/core/typechecker/src/test/resources/modules/looseSL.result b/core/typechecker/src/test/resources/modules/looseSL.result index e326b75a66..1b673f0190 100644 --- a/core/typechecker/src/test/resources/modules/looseSL.result +++ b/core/typechecker/src/test/resources/modules/looseSL.result @@ -4,13 +4,13 @@ - + - + diff --git a/core/typechecker/src/test/resources/modules/metroSL.result b/core/typechecker/src/test/resources/modules/metroSL.result index 0570d87d0b..bbee7471b8 100644 --- a/core/typechecker/src/test/resources/modules/metroSL.result +++ b/core/typechecker/src/test/resources/modules/metroSL.result @@ -1,8 +1,8 @@ - + diff --git a/core/typechecker/src/test/resources/modules/newspeakSL.result b/core/typechecker/src/test/resources/modules/newspeakSL.result index 6ae2d9c74b..e8968c4024 100644 --- a/core/typechecker/src/test/resources/modules/newspeakSL.result +++ b/core/typechecker/src/test/resources/modules/newspeakSL.result @@ -56,16 +56,16 @@ - - + + - + @@ -74,35 +74,35 @@ - - + + - + - + - + - + @@ -110,18 +110,18 @@ - + - + - - + + @@ -142,16 +142,16 @@ + - - + @@ -165,26 +165,26 @@ - + - + - + - + @@ -194,9 +194,9 @@ - - + + diff --git a/core/typechecker/src/test/resources/modules/simulatorSL.result b/core/typechecker/src/test/resources/modules/simulatorSL.result index b13f37eadd..6c8536b85b 100644 --- a/core/typechecker/src/test/resources/modules/simulatorSL.result +++ b/core/typechecker/src/test/resources/modules/simulatorSL.result @@ -4,14 +4,14 @@ - + + - + - diff --git a/core/typechecker/src/test/resources/modules/trafficSL.result b/core/typechecker/src/test/resources/modules/trafficSL.result index 6bc7d07e78..96b2c683cf 100644 --- a/core/typechecker/src/test/resources/modules/trafficSL.result +++ b/core/typechecker/src/test/resources/modules/trafficSL.result @@ -1,13 +1,13 @@ - + - - + + From 1358fe9322624f3d624e525c46cf9459d97c1827 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Peter=20Tran-J=C3=B8rgensen?= Date: Thu, 19 Mar 2015 17:20:11 +0100 Subject: [PATCH 298/323] Improved translation of union types for the case when there is only a single type --- .../codegen/visitor/TypeVisitorCG.java | 37 +++++++++++-------- 1 file changed, 22 insertions(+), 15 deletions(-) diff --git a/core/codegen/javagen/src/main/java/org/overture/codegen/visitor/TypeVisitorCG.java b/core/codegen/javagen/src/main/java/org/overture/codegen/visitor/TypeVisitorCG.java index 93ba95e9fc..2be0aa8c0d 100644 --- a/core/codegen/javagen/src/main/java/org/overture/codegen/visitor/TypeVisitorCG.java +++ b/core/codegen/javagen/src/main/java/org/overture/codegen/visitor/TypeVisitorCG.java @@ -22,6 +22,7 @@ package org.overture.codegen.visitor; import java.util.LinkedList; +import java.util.List; import org.overture.ast.analysis.AnalysisException; import org.overture.ast.intf.lex.ILexNameToken; @@ -84,7 +85,7 @@ public class TypeVisitorCG extends AbstractVisitorCG public STypeCG caseAUnionType(AUnionType node, IRInfo question) throws AnalysisException { - LinkedList types = node.getTypes(); + List types = node.getTypes(); PTypeAssistantTC typeAssistant = question.getTcFactory().createPTypeAssistant(); @@ -107,24 +108,30 @@ public STypeCG caseAUnionType(AUnionType node, IRInfo question) return mapType.apply(question.getTypeVisitor(), question); } else { - - AUnionTypeCG unionTypeCg = new AUnionTypeCG(); - - for (PType type : types) + if(types.size() <= 1) { - STypeCG typeCg = type.apply(question.getTypeVisitor(), question); - - if(typeCg != null) - { - unionTypeCg.getTypes().add(typeCg); - } - else + return types.get(0).apply(question.getTypeVisitor(), question); + } + else + { + AUnionTypeCG unionTypeCg = new AUnionTypeCG(); + + for (PType type : types) { - return null; + STypeCG typeCg = type.apply(question.getTypeVisitor(), question); + + if(typeCg != null) + { + unionTypeCg.getTypes().add(typeCg); + } + else + { + return null; + } } - } - return unionTypeCg; + return unionTypeCg; + } } } From 143a0cea53d1734100366e2945b6dce73ac54b3f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Peter=20Tran-J=C3=B8rgensen?= Date: Thu, 19 Mar 2015 17:21:22 +0100 Subject: [PATCH 299/323] Changed a test related to code generation of union types to prevent type filtering in the IR constructor --- .../resources/union_type_specs/FieldExpOfRecordArgToApplyExp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/core/codegen/javagen/src/test/resources/union_type_specs/FieldExpOfRecordArgToApplyExp b/core/codegen/javagen/src/test/resources/union_type_specs/FieldExpOfRecordArgToApplyExp index d0b21df3c0..2a85d79c29 100644 --- a/core/codegen/javagen/src/test/resources/union_type_specs/FieldExpOfRecordArgToApplyExp +++ b/core/codegen/javagen/src/test/resources/union_type_specs/FieldExpOfRecordArgToApplyExp @@ -13,8 +13,8 @@ operations public static Run : () ==> ? Run () == -let r : Rec | Rec = mk_Rec(8) +let r : Rec | nat = mk_Rec(8) in return id(r.x); -end Entry \ No newline at end of file +end Entry From fc122c13018a2c67bb62ed0e15a919ee91cd5bde Mon Sep 17 00:00:00 2001 From: Nick Battle Date: Thu, 19 Mar 2015 18:16:40 +0000 Subject: [PATCH 300/323] Fix for union type in ++ type checking --- .../overture/typechecker/visitor/TypeCheckerExpVisitor.java | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/core/typechecker/src/main/java/org/overture/typechecker/visitor/TypeCheckerExpVisitor.java b/core/typechecker/src/main/java/org/overture/typechecker/visitor/TypeCheckerExpVisitor.java index e4544a7ed2..b91848a55b 100644 --- a/core/typechecker/src/main/java/org/overture/typechecker/visitor/TypeCheckerExpVisitor.java +++ b/core/typechecker/src/main/java/org/overture/typechecker/visitor/TypeCheckerExpVisitor.java @@ -761,8 +761,10 @@ else if (question.constraint != null && question.assistantFactory.createPTypeAss TypeCheckerErrors.detail(unique, "Type", mr.getFrom()); } - result.add(AstFactory.newASeqSeqType(node.getLocation(), - AstFactory.newAUnionType(node.getLocation(), st.getSeqof(), mr.getTo()))); + PTypeSet type = new PTypeSet(question.assistantFactory); + type.add(st.getSeqof()); + type.add(mr.getTo()); + result.add(AstFactory.newASeqSeqType(node.getLocation(), type.getType(node.getLocation()))); } } From c9d52d4aa85ef29770d28eff51c4f644cb676161 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Fri, 20 Mar 2015 20:27:02 +0100 Subject: [PATCH 301/323] Updates to test results related to code generation of the atomic statement --- .../classic_specs/CashDispenserPP.result | 25 ++++++++++--------- .../cloning_specs/CashDispenserPP.result | 23 +++++++++-------- 2 files changed, 25 insertions(+), 23 deletions(-) diff --git a/core/codegen/javagen/src/test/resources/classic_specs/CashDispenserPP.result b/core/codegen/javagen/src/test/resources/classic_specs/CashDispenserPP.result index 66499af13e..36f08a18ea 100644 --- a/core/codegen/javagen/src/test/resources/classic_specs/CashDispenserPP.result +++ b/core/codegen/javagen/src/test/resources/classic_specs/CashDispenserPP.result @@ -407,21 +407,22 @@ public class CentralResource { } public void AddAccount(final Number accId, final Account acc) { - accounts = MapUtil.override(Utils.clone(accounts), - MapUtil.map(new Maplet(accId, acc))); + { /* Start of atomic statement */ + accounts = MapUtil.override(Utils.clone(accounts), + MapUtil.map(new Maplet(accId, acc))); - VDMMap mapCompResult_1 = MapUtil.map(); - VDMSet set_4 = acc.GetCardIds(); + VDMMap mapCompResult_1 = MapUtil.map(); + VDMSet set_4 = acc.GetCardIds(); - for (Iterator iterator_4 = set_4.iterator(); iterator_4.hasNext();) { - Number cId = ((Number) iterator_4.next()); - mapCompResult_1 = MapUtil.munion(Utils.clone(mapCompResult_1), - MapUtil.map(new Maplet(cId, 0L))); - } + for (Iterator iterator_4 = set_4.iterator(); iterator_4.hasNext();) { + Number cId = ((Number) iterator_4.next()); + mapCompResult_1 = MapUtil.munion(Utils.clone(mapCompResult_1), + MapUtil.map(new Maplet(cId, 0L))); + } - numberOfTries = MapUtil.override(Utils.clone(numberOfTries), - Utils.clone(mapCompResult_1)); - } + numberOfTries = MapUtil.override(Utils.clone(numberOfTries), + Utils.clone(mapCompResult_1)); + } /* End of atomic statement */} public void AddIllegalCard(final Number cId) { illegalCards = SetUtil.union(Utils.clone(illegalCards), SetUtil.set(cId)); diff --git a/core/codegen/javagen/src/test/resources/cloning_specs/CashDispenserPP.result b/core/codegen/javagen/src/test/resources/cloning_specs/CashDispenserPP.result index dd5d109023..4631174b51 100644 --- a/core/codegen/javagen/src/test/resources/cloning_specs/CashDispenserPP.result +++ b/core/codegen/javagen/src/test/resources/cloning_specs/CashDispenserPP.result @@ -402,20 +402,21 @@ public class CentralResource { } public void AddAccount(final Number accId, final Account acc) { - accounts = MapUtil.override(accounts, - MapUtil.map(new Maplet(accId, acc))); + { /* Start of atomic statement */ + accounts = MapUtil.override(accounts, + MapUtil.map(new Maplet(accId, acc))); - VDMMap mapCompResult_1 = MapUtil.map(); - VDMSet set_4 = acc.GetCardIds(); + VDMMap mapCompResult_1 = MapUtil.map(); + VDMSet set_4 = acc.GetCardIds(); - for (Iterator iterator_4 = set_4.iterator(); iterator_4.hasNext();) { - Number cId = ((Number) iterator_4.next()); - mapCompResult_1 = MapUtil.munion(mapCompResult_1, - MapUtil.map(new Maplet(cId, 0L))); - } + for (Iterator iterator_4 = set_4.iterator(); iterator_4.hasNext();) { + Number cId = ((Number) iterator_4.next()); + mapCompResult_1 = MapUtil.munion(mapCompResult_1, + MapUtil.map(new Maplet(cId, 0L))); + } - numberOfTries = MapUtil.override(numberOfTries, mapCompResult_1); - } + numberOfTries = MapUtil.override(numberOfTries, mapCompResult_1); + } /* End of atomic statement */} public void AddIllegalCard(final Number cId) { illegalCards = SetUtil.union(illegalCards, SetUtil.set(cId)); From c93d2982e866d243014e2c546a6746129ef7f96c Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Fri, 20 Mar 2015 20:30:22 +0100 Subject: [PATCH 302/323] Added ignore file for the javagen project --- core/codegen/javagen/.gitignore | 1 + 1 file changed, 1 insertion(+) create mode 100644 core/codegen/javagen/.gitignore diff --git a/core/codegen/javagen/.gitignore b/core/codegen/javagen/.gitignore new file mode 100644 index 0000000000..b83d22266a --- /dev/null +++ b/core/codegen/javagen/.gitignore @@ -0,0 +1 @@ +/target/ From 64548dcccae945cf70e5f38d9c836583cd3ef781 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Fri, 20 Mar 2015 20:35:46 +0100 Subject: [PATCH 303/323] Added atomic statement and class invariants to the IR description --- core/codegen/javagen/src/main/resources/cg.astv2 | 3 +++ 1 file changed, 3 insertions(+) diff --git a/core/codegen/javagen/src/main/resources/cg.astv2 b/core/codegen/javagen/src/main/resources/cg.astv2 index 04c5661ae1..16ea09b06c 100644 --- a/core/codegen/javagen/src/main/resources/cg.astv2 +++ b/core/codegen/javagen/src/main/resources/cg.astv2 @@ -120,6 +120,7 @@ CG {-> package='org.overture.codegen.cgast' [static]:java_Boolean [name]:java_String [fields]:field* + [invariant]:CG.#decl [methods]:CG.#decl.method* [functions]:CG.#decl.func* [traces]:CG.#decl.namedTrace* @@ -229,6 +230,8 @@ CG {-> package='org.overture.codegen.cgast' [name]:java_String [args]:CG.#exp* | {mapSeqUpdate} [col]:CG.#exp [index]:CG.#exp [value]:CG.#exp + | {invCheck} [subject]:CG.#exp + | {atomic} [statements]:CG.#stm* ; #call {-> package='org.overture.codegen.cgast.statements' From 6e23bd958cd0a38e363f5af8ff2e4c3a6d617a8d Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Fri, 20 Mar 2015 20:38:04 +0100 Subject: [PATCH 304/323] Added template for the atomic statement --- .../src/main/resources/JavaTemplates/Statements/Atomic.vm | 5 +++++ 1 file changed, 5 insertions(+) create mode 100644 core/codegen/javagen/src/main/resources/JavaTemplates/Statements/Atomic.vm diff --git a/core/codegen/javagen/src/main/resources/JavaTemplates/Statements/Atomic.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Statements/Atomic.vm new file mode 100644 index 0000000000..46caa8b3bc --- /dev/null +++ b/core/codegen/javagen/src/main/resources/JavaTemplates/Statements/Atomic.vm @@ -0,0 +1,5 @@ +{ /* Start of atomic statement */ +#foreach( $stm in $node.getStatements() ) +$JavaFormat.format($stm) +#end +} /* End of atomic statement */ \ No newline at end of file From 250bacfb7a477dc56a573d1ec1cabd205390432f Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Fri, 20 Mar 2015 20:43:36 +0100 Subject: [PATCH 305/323] Improved Java code generation of records. Now the Java backends adds the record methods to the IR record --- .../codegen/vdm2java/JavaRecordCreator.java | 20 +++++-------------- .../JavaTemplates/Declarations/Record.vm | 4 ++++ 2 files changed, 9 insertions(+), 15 deletions(-) diff --git a/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaRecordCreator.java b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaRecordCreator.java index a0b06268e2..461fdd87ae 100644 --- a/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaRecordCreator.java +++ b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaRecordCreator.java @@ -60,7 +60,7 @@ public JavaRecordCreator(JavaFormat javaFormat) this.javaFormat = javaFormat; } - public String formatRecordConstructor(ARecordDeclCG record) + public void formatRecordConstructor(ARecordDeclCG record) throws AnalysisException { // Since Java does not have records but the OO AST does a record is generated as a Java class. @@ -125,11 +125,9 @@ public String formatRecordConstructor(ARecordDeclCG record) } record.getMethods().add(constructor); - - return javaFormat.format(constructor); } - public String generateCloneMethod(ARecordDeclCG record) + public void generateCloneMethod(ARecordDeclCG record) throws AnalysisException { @@ -169,11 +167,9 @@ public String generateCloneMethod(ARecordDeclCG record) method.setBody(body); record.getMethods().add(method); - - return javaFormat.format(method); } - public String generateEqualsMethod(ARecordDeclCG record) + public void generateEqualsMethod(ARecordDeclCG record) throws AnalysisException { String paramName = "obj"; @@ -234,11 +230,9 @@ public String generateEqualsMethod(ARecordDeclCG record) equalsMethod.setBody(equalsMethodBody); record.getMethods().add(equalsMethod); - - return javaFormat.format(equalsMethod); } - public String generateHashcodeMethod(ARecordDeclCG record) + public void generateHashcodeMethod(ARecordDeclCG record) throws AnalysisException { AMethodDeclCG hashcodeMethod = consHashcodeMethodSignature(); @@ -259,11 +253,9 @@ public String generateHashcodeMethod(ARecordDeclCG record) hashcodeMethod.setBody(returnStm); record.getMethods().add(hashcodeMethod); - - return javaFormat.format(hashcodeMethod); } - public String generateToStringMethod(ARecordDeclCG record) + public void generateToStringMethod(ARecordDeclCG record) throws AnalysisException { AMethodDeclCG toStringMethod = consToStringSignature(); @@ -307,7 +299,5 @@ public String generateToStringMethod(ARecordDeclCG record) toStringMethod.setBody(returnStm); record.getMethods().add(toStringMethod); - - return javaFormat.format(toStringMethod); } } diff --git a/core/codegen/javagen/src/main/resources/JavaTemplates/Declarations/Record.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Declarations/Record.vm index f853db507b..b0b950de59 100644 --- a/core/codegen/javagen/src/main/resources/JavaTemplates/Declarations/Record.vm +++ b/core/codegen/javagen/src/main/resources/JavaTemplates/Declarations/Record.vm @@ -10,4 +10,8 @@ static class $node.getName() implements Record $RecordCreator.generateHashcodeMethod($node) $RecordCreator.generateCloneMethod($node) $RecordCreator.generateToStringMethod($node) + ## + #foreach( $method in $node.getMethods() ) + $JavaFormat.format($method) + #end } \ No newline at end of file From aeb7bb154d63dea424af6af174293f65a8faaf42 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Fri, 20 Mar 2015 20:45:35 +0100 Subject: [PATCH 306/323] Added utility functionality to check whether a statement is enclosed by an atomic statement --- .../java/org/overture/codegen/assistant/StmAssistantCG.java | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/core/codegen/javagen/src/main/java/org/overture/codegen/assistant/StmAssistantCG.java b/core/codegen/javagen/src/main/java/org/overture/codegen/assistant/StmAssistantCG.java index 3b9eeee598..d9ad654f39 100644 --- a/core/codegen/javagen/src/main/java/org/overture/codegen/assistant/StmAssistantCG.java +++ b/core/codegen/javagen/src/main/java/org/overture/codegen/assistant/StmAssistantCG.java @@ -41,6 +41,7 @@ import org.overture.codegen.cgast.declarations.AClassDeclCG; import org.overture.codegen.cgast.declarations.AMethodDeclCG; import org.overture.codegen.cgast.declarations.AVarDeclCG; +import org.overture.codegen.cgast.statements.AAtomicStmCG; import org.overture.codegen.cgast.statements.ABlockStmCG; import org.overture.codegen.cgast.statements.ACaseAltStmStmCG; import org.overture.codegen.cgast.statements.AElseIfStmCG; @@ -104,6 +105,11 @@ public void handleAlternativesCasesStm(IRInfo question, PExp exp, } } + public boolean inAtomic(SStmCG stm) + { + return stm.getAncestor(AAtomicStmCG.class) != null; + } + public String getSuperClassName(ASuperCallStmCG stm) { AClassDeclCG enclosingClass = stm.getAncestor(AClassDeclCG.class); From 4294063541f00e02e6ae2b586aaf453793654f9c Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Fri, 20 Mar 2015 20:50:26 +0100 Subject: [PATCH 307/323] Small tweak to the command-line version of the Java code generator --- .../java/org/overture/codegen/vdm2java/JavaCodeGenMain.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGenMain.java b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGenMain.java index 109f8cbfad..bd3c55ed3f 100644 --- a/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGenMain.java +++ b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaCodeGenMain.java @@ -190,7 +190,7 @@ else if(arg.equals(VDM_ENTRY_EXP)) usage("Input files are missing"); } - if(outputDir == null) + if(outputDir == null && !printClasses) { Logger.getLog().println("No output directory specified - printing code generated classes instead..\n"); printClasses = true; From 5a2844917e10a7af283c277bfc0882cd34d85cb2 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Fri, 20 Mar 2015 20:57:12 +0100 Subject: [PATCH 308/323] Added invariants to IR class construction --- .../java/org/overture/codegen/visitor/ClassVisitorCG.java | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/core/codegen/javagen/src/main/java/org/overture/codegen/visitor/ClassVisitorCG.java b/core/codegen/javagen/src/main/java/org/overture/codegen/visitor/ClassVisitorCG.java index 8814476881..5d23990edb 100644 --- a/core/codegen/javagen/src/main/java/org/overture/codegen/visitor/ClassVisitorCG.java +++ b/core/codegen/javagen/src/main/java/org/overture/codegen/visitor/ClassVisitorCG.java @@ -178,6 +178,12 @@ else if(decl instanceof ANamedTraceDeclCG) + name + ": " + def.getName().getName() + " at " + def.getLocation()); } } + + if(node.getInvariant() != null && question.getSettings().generateInvariantChecks()) + { + SDeclCG invCg = node.getInvariant().apply(question.getDeclVisitor(), question); + classCg.setInvariant(invCg); + } boolean defaultConstructorExplicit = false; for (AMethodDeclCG method : methods) From fed7ac928b7919b8c72cba61c9e0ac163dc51e2e Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Fri, 20 Mar 2015 21:03:24 +0100 Subject: [PATCH 309/323] Added an option to configure generation of invariant checks at the IR level --- .../main/java/org/overture/codegen/ir/IRSettings.java | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRSettings.java b/core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRSettings.java index a57a2789ee..9776bfa2e1 100644 --- a/core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRSettings.java +++ b/core/codegen/javagen/src/main/java/org/overture/codegen/ir/IRSettings.java @@ -30,6 +30,7 @@ public class IRSettings private boolean generatePostConds; private boolean generatePostCondChecks; private boolean generateTraces; + private boolean generateInvariantChecks; public IRSettings() { @@ -104,4 +105,14 @@ public void setGenerateTraces(boolean generateTraces) { this.generateTraces = generateTraces; } + + public boolean generateInvariantChecks() + { + return generateInvariantChecks; + } + + public void setGenerateInvariantChecks(boolean generateInvariantChecks) + { + this.generateInvariantChecks = generateInvariantChecks; + } } From 7fbb701a38f35f63df2afede7182dde62226686d Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Fri, 20 Mar 2015 21:06:12 +0100 Subject: [PATCH 310/323] Added generation of the class invariant method to the Java class template --- .../java/org/overture/codegen/vdm2java/JavaFormat.java | 10 ++++++++++ .../main/resources/JavaTemplates/Declarations/Class.vm | 4 ++++ 2 files changed, 14 insertions(+) diff --git a/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaFormat.java b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaFormat.java index f18333e708..91561cf398 100644 --- a/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaFormat.java +++ b/core/codegen/javagen/src/main/java/org/overture/codegen/vdm2java/JavaFormat.java @@ -940,4 +940,14 @@ public String getQuotePackagePrefix() return CodeGenBase.QUOTES + "."; } } + + public boolean genInvariant(AClassDeclCG clazz) + { + if(!info.getSettings().generateInvariantChecks()) + { + return false; + } + + return clazz.getInvariant() != null; + } } diff --git a/core/codegen/javagen/src/main/resources/JavaTemplates/Declarations/Class.vm b/core/codegen/javagen/src/main/resources/JavaTemplates/Declarations/Class.vm index 03634f763d..3cce79199c 100644 --- a/core/codegen/javagen/src/main/resources/JavaTemplates/Declarations/Class.vm +++ b/core/codegen/javagen/src/main/resources/JavaTemplates/Declarations/Class.vm @@ -49,6 +49,10 @@ $abstract $node.getAccess() $static class $node.getName() $JavaFormat.formatSupe #if ($JavaFormat.isMainClass($node)) $node.getTag().getMainMethod() #end + ## + #if ($JavaFormat.genInvariant($node)) + $JavaFormat.format($node.getInvariant()) + #end #foreach( $typeDecl in $node.getTypeDecls() ) #if (!$JavaFormat.isNamedTypeDecl($typeDecl)) From a64144f0fade3173f82cd8b7f70bd0ab10d77201 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Fri, 20 Mar 2015 21:26:57 +0100 Subject: [PATCH 311/323] Added IR construction of the class invariant statement and the atomic statement --- .../codegen/visitor/StmVisitorCG.java | 78 +++++++++++++++++-- 1 file changed, 70 insertions(+), 8 deletions(-) diff --git a/core/codegen/javagen/src/main/java/org/overture/codegen/visitor/StmVisitorCG.java b/core/codegen/javagen/src/main/java/org/overture/codegen/visitor/StmVisitorCG.java index 1805de0f5c..f083662192 100644 --- a/core/codegen/javagen/src/main/java/org/overture/codegen/visitor/StmVisitorCG.java +++ b/core/codegen/javagen/src/main/java/org/overture/codegen/visitor/StmVisitorCG.java @@ -26,6 +26,7 @@ import org.overture.ast.analysis.AnalysisException; import org.overture.ast.definitions.AAssignmentDefinition; +import org.overture.ast.definitions.AClassInvariantDefinition; import org.overture.ast.definitions.AExplicitOperationDefinition; import org.overture.ast.definitions.AInheritedDefinition; import org.overture.ast.definitions.PDefinition; @@ -43,6 +44,7 @@ import org.overture.ast.statements.ACallStm; import org.overture.ast.statements.ACaseAlternativeStm; import org.overture.ast.statements.ACasesStm; +import org.overture.ast.statements.AClassInvariantStm; import org.overture.ast.statements.AElseIfStm; import org.overture.ast.statements.AErrorStm; import org.overture.ast.statements.AForAllStm; @@ -71,11 +73,13 @@ import org.overture.codegen.cgast.SStmCG; import org.overture.codegen.cgast.STypeCG; import org.overture.codegen.cgast.declarations.AVarDeclCG; +import org.overture.codegen.cgast.expressions.AAndBoolBinaryExpCG; import org.overture.codegen.cgast.expressions.AReverseUnaryExpCG; import org.overture.codegen.cgast.expressions.AUndefinedExpCG; import org.overture.codegen.cgast.patterns.AIdentifierPatternCG; import org.overture.codegen.cgast.patterns.ASetMultipleBindCG; import org.overture.codegen.cgast.statements.AAssignmentStmCG; +import org.overture.codegen.cgast.statements.AAtomicStmCG; import org.overture.codegen.cgast.statements.ABlockStmCG; import org.overture.codegen.cgast.statements.ACallObjectStmCG; import org.overture.codegen.cgast.statements.ACaseAltStmStmCG; @@ -95,6 +99,7 @@ import org.overture.codegen.cgast.statements.AStartlistStmCG; import org.overture.codegen.cgast.statements.ASuperCallStmCG; import org.overture.codegen.cgast.statements.AWhileStmCG; +import org.overture.codegen.cgast.types.ABoolBasicTypeCG; import org.overture.codegen.cgast.types.AClassTypeCG; import org.overture.codegen.cgast.types.AVoidTypeCG; import org.overture.codegen.cgast.utils.AHeaderLetBeStCG; @@ -114,6 +119,66 @@ public SStmCG caseAErrorStm(AErrorStm node, IRInfo question) return new AErrorStmCG(); } + @Override + public SStmCG caseAClassInvariantStm(AClassInvariantStm node, + IRInfo question) throws AnalysisException + { + List exps = new LinkedList(); + + for (PDefinition d : node.getInvDefs()) + { + if(!(d instanceof AClassInvariantDefinition)) + { + Logger.getLog().printErrorln("Expected class invariant definition in '" + this.getClass().getName() + "'. Got: " + d); + return null; + } + + AClassInvariantDefinition invDef = (AClassInvariantDefinition) d; + exps.add(invDef.getExpression()); + } + + AReturnStmCG returnStmCg = new AReturnStmCG(); + + if(exps.isEmpty()) + { + // Should not really be necessary + returnStmCg.setExp(question.getExpAssistant().consBoolLiteral(true)); + } + else if(exps.size() == 1) + { + SExpCG expCg = exps.get(0).apply(question.getExpVisitor(), question); + returnStmCg.setExp(expCg); + } + else + { + // We have more than one expressions from which we will build an 'and chain' + AAndBoolBinaryExpCG andExpTopCg = new AAndBoolBinaryExpCG(); + andExpTopCg.setType(new ABoolBasicTypeCG()); + andExpTopCg.setLeft(exps.get(0).apply(question.getExpVisitor(), question)); + + AAndBoolBinaryExpCG previousAndExpCg = andExpTopCg; + + // The remaining ones except the last + for(int i = 1; i < exps.size() - 1; i++) + { + SExpCG nextExpCg = exps.get(i).apply(question.getExpVisitor(), question); + + AAndBoolBinaryExpCG nextAndExpCg = new AAndBoolBinaryExpCG(); + nextAndExpCg.setType(new ABoolBasicTypeCG()); + nextAndExpCg.setLeft(nextExpCg); + + previousAndExpCg.setRight(nextAndExpCg); + previousAndExpCg = nextAndExpCg; + } + + previousAndExpCg.setRight(exps.get(exps.size() - 1).apply(question.getExpVisitor(), question)); + + returnStmCg.setExp(andExpTopCg); + } + + return returnStmCg; + } + @Override public SStmCG caseAPeriodicStm(APeriodicStm node, IRInfo question) throws AnalysisException @@ -144,18 +209,15 @@ public SStmCG caseAPeriodicStm(APeriodicStm node, IRInfo question) public SStmCG caseAAtomicStm(AAtomicStm node, IRInfo question) throws AnalysisException { - LinkedList assignments = node.getAssignments(); - - ABlockStmCG stmBlock = new ABlockStmCG(); - LinkedList stmsCg = stmBlock.getStatements(); - - for (AAssignmentStm assignment : assignments) + AAtomicStmCG atomicBlock = new AAtomicStmCG(); + + for (AAssignmentStm assignment : node.getAssignments()) { SStmCG stmCg = assignment.apply(question.getStmVisitor(), question); if(stmCg != null) { - stmsCg.add(stmCg); + atomicBlock.getStatements().add(stmCg); } else { @@ -163,7 +225,7 @@ public SStmCG caseAAtomicStm(AAtomicStm node, IRInfo question) } } - return stmBlock; + return atomicBlock; } @Override From 930f5f77178e6ddfdfdeb78e06024d76ce1c49f1 Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Fri, 20 Mar 2015 21:37:05 +0100 Subject: [PATCH 312/323] Utility functionality in the expression assistant now takes the class invariant into account --- .../overture/codegen/assistant/ExpAssistantCG.java | 12 ++++++++---- .../org/overture/codegen/visitor/ExpVisitorCG.java | 8 ++++---- 2 files changed, 12 insertions(+), 8 deletions(-) diff --git a/core/codegen/javagen/src/main/java/org/overture/codegen/assistant/ExpAssistantCG.java b/core/codegen/javagen/src/main/java/org/overture/codegen/assistant/ExpAssistantCG.java index 81172c696a..fd0303559d 100644 --- a/core/codegen/javagen/src/main/java/org/overture/codegen/assistant/ExpAssistantCG.java +++ b/core/codegen/javagen/src/main/java/org/overture/codegen/assistant/ExpAssistantCG.java @@ -28,6 +28,7 @@ import org.overture.ast.analysis.AnalysisException; import org.overture.ast.definitions.AAssignmentDefinition; +import org.overture.ast.definitions.AClassInvariantDefinition; import org.overture.ast.definitions.AInstanceVariableDefinition; import org.overture.ast.definitions.ANamedTraceDefinition; import org.overture.ast.definitions.AValueDefinition; @@ -43,6 +44,7 @@ import org.overture.ast.patterns.ASetMultipleBind; import org.overture.ast.patterns.PMultipleBind; import org.overture.ast.statements.AAssignmentStm; +import org.overture.ast.statements.AClassInvariantStm; import org.overture.ast.types.AIntNumericBasicType; import org.overture.ast.types.ANatNumericBasicType; import org.overture.ast.types.ANatOneNumericBasicType; @@ -81,6 +83,7 @@ import org.overture.codegen.cgast.expressions.SIsExpCG; import org.overture.codegen.cgast.expressions.SQuantifierExpCG; import org.overture.codegen.cgast.expressions.SUnaryExpCG; +import org.overture.codegen.cgast.expressions.SVarExpCG; import org.overture.codegen.cgast.patterns.ASetMultipleBindCG; import org.overture.codegen.cgast.statements.AForLoopStmCG; import org.overture.codegen.cgast.statements.AIdentifierStateDesignatorCG; @@ -355,7 +358,7 @@ public AHeaderLetBeStCG consHeader(ASetMultipleBindCG binding, return header; } - public boolean existsOutsideMethodOrTrace(PExp exp) + public boolean outsideImperativeContext(PExp exp) { // The transformation of the 'and' and 'or' logical expressions also assumes that the // expressions exist within a statement. However, in case it does not, the transformation @@ -364,14 +367,15 @@ public boolean existsOutsideMethodOrTrace(PExp exp) return exp.getAncestor(SOperationDefinition.class) == null && exp.getAncestor(SFunctionDefinition.class) == null - && exp.getAncestor(ANamedTraceDefinition.class) == null; + && exp.getAncestor(ANamedTraceDefinition.class) == null + && exp.getAncestor(AClassInvariantDefinition.class) == null; } public SExpCG handleQuantifier(PExp node, List bindings, PExp predicate, SQuantifierExpCG quantifier, IRInfo question, String nodeStr) throws AnalysisException { - if (question.getExpAssistant().existsOutsideMethodOrTrace(node)) + if (question.getExpAssistant().outsideImperativeContext(node)) { question.addUnsupportedNode(node, String.format("Generation of a %s is only supported within operations/functions", nodeStr)); return null; @@ -562,7 +566,7 @@ public SExpCG consIsExpBasicType(SExpCG expCg, STypeCG checkedType) return basicIsExp; } - public SExpCG idStateDesignatorToExp(IRInfo info, TransAssistantCG transAssistant, List classes, AIdentifierStateDesignatorCG node) + public SVarExpCG idStateDesignatorToExp(IRInfo info, TransAssistantCG transAssistant, List classes, AIdentifierStateDesignatorCG node) { if(node.getExplicit()) { diff --git a/core/codegen/javagen/src/main/java/org/overture/codegen/visitor/ExpVisitorCG.java b/core/codegen/javagen/src/main/java/org/overture/codegen/visitor/ExpVisitorCG.java index 30cf4b54dd..3d275d7896 100644 --- a/core/codegen/javagen/src/main/java/org/overture/codegen/visitor/ExpVisitorCG.java +++ b/core/codegen/javagen/src/main/java/org/overture/codegen/visitor/ExpVisitorCG.java @@ -502,7 +502,7 @@ public SExpCG caseAExists1Exp(AExists1Exp node, IRInfo question) public SExpCG caseASetCompSetExp(ASetCompSetExp node, IRInfo question) throws AnalysisException { - if (question.getExpAssistant().existsOutsideMethodOrTrace(node)) + if (question.getExpAssistant().outsideImperativeContext(node)) { question.addUnsupportedNode(node, "Generation of a set comprehension is only supported within operations/functions"); return null; @@ -743,7 +743,7 @@ public SExpCG caseAFuncInstatiationExp(AFuncInstatiationExp node, public SExpCG caseALetBeStExp(ALetBeStExp node, IRInfo question) throws AnalysisException { - if (question.getExpAssistant().existsOutsideMethodOrTrace(node)) + if (question.getExpAssistant().outsideImperativeContext(node)) { question.addUnsupportedNode(node, "Generation of a let be st expression is only supported within operations/functions"); return null; @@ -962,7 +962,7 @@ public SExpCG caseADistConcatUnaryExp(ADistConcatUnaryExp node, public SExpCG caseASeqCompSeqExp(ASeqCompSeqExp node, IRInfo question) throws AnalysisException { - if (question.getExpAssistant().existsOutsideMethodOrTrace(node)) + if (question.getExpAssistant().outsideImperativeContext(node)) { question.addUnsupportedNode(node, "Generation of a sequence comprehension is only supported within operations/functions"); return null; @@ -1083,7 +1083,7 @@ public SExpCG caseAMapletExp(AMapletExp node, IRInfo question) public SExpCG caseAMapCompMapExp(AMapCompMapExp node, IRInfo question) throws AnalysisException { - if (question.getExpAssistant().existsOutsideMethodOrTrace(node)) + if (question.getExpAssistant().outsideImperativeContext(node)) { question.addUnsupportedNode(node, "Generation of a map comprehension is only supported within operations/functions"); return null; From a5c425b7f91ecfe93956ca5b281c50784d895f7e Mon Sep 17 00:00:00 2001 From: Peter Joergensen Date: Fri, 20 Mar 2015 21:40:39 +0100 Subject: [PATCH 313/323] Updated the template manager with the atomic statement and the class invariant temlate --- .../org/overture/codegen/merging/TemplateManager.java | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/core/codegen/javagen/src/main/java/org/overture/codegen/merging/TemplateManager.java b/core/codegen/javagen/src/main/java/org/overture/codegen/merging/TemplateManager.java index 1773d946b1..8e51ce6351 100644 --- a/core/codegen/javagen/src/main/java/org/overture/codegen/merging/TemplateManager.java +++ b/core/codegen/javagen/src/main/java/org/overture/codegen/merging/TemplateManager.java @@ -46,6 +46,7 @@ import org.overture.codegen.cgast.statements.AApplyObjectDesignatorCG; import org.overture.codegen.cgast.statements.AAssignToExpStmCG; import org.overture.codegen.cgast.statements.AAssignmentStmCG; +import org.overture.codegen.cgast.statements.AAtomicStmCG; import org.overture.codegen.cgast.statements.ABlockStmCG; import org.overture.codegen.cgast.statements.ABreakStmCG; import org.overture.codegen.cgast.statements.ACallObjectExpStmCG; @@ -62,6 +63,7 @@ import org.overture.codegen.cgast.statements.AIdentifierStateDesignatorCG; import org.overture.codegen.cgast.statements.AIfStmCG; import org.overture.codegen.cgast.statements.AIncrementStmCG; +import org.overture.codegen.cgast.statements.AInvCheckStmCG; import org.overture.codegen.cgast.statements.ALocalPatternAssignmentStmCG; import org.overture.codegen.cgast.statements.AMapSeqStateDesignatorCG; import org.overture.codegen.cgast.statements.AMapSeqUpdateStmCG; @@ -349,6 +351,13 @@ protected void initNodeTemplateFileNames() nodeTemplateFileNames.put(AMapSeqUpdateStmCG.class, templateStructure.STM_PATH + "MapSeqUpdate"); + nodeTemplateFileNames.put(AInvCheckStmCG.class, templateStructure.STM_PATH + + "InvCheck"); + + // The template used for the block statement also works here + nodeTemplateFileNames.put(AAtomicStmCG.class, templateStructure.STM_PATH + + "Atomic"); + // Expressions nodeTemplateFileNames.put(AApplyExpCG.class, templateStructure.EXP_PATH From 0534b7b9b404229cfe14167132d53f81ed55f78b Mon Sep 17 00:00:00 2001 From: Nick Battle Date: Tue, 24 Mar 2015 15:47:59 +0000 Subject: [PATCH 314/323] Typecheck problem with forward references, fixes #435 --- .../src/main/java/org/overture/ast/typechecker/Pass.java | 2 +- .../typechecker/visitor/TypeCheckerDefinitionVisitor.java | 7 +++++++ 2 files changed, 8 insertions(+), 1 deletion(-) diff --git a/core/ast/src/main/java/org/overture/ast/typechecker/Pass.java b/core/ast/src/main/java/org/overture/ast/typechecker/Pass.java index 2fd33cd696..9430756bff 100644 --- a/core/ast/src/main/java/org/overture/ast/typechecker/Pass.java +++ b/core/ast/src/main/java/org/overture/ast/typechecker/Pass.java @@ -31,5 +31,5 @@ public enum Pass implements Serializable { - TYPES, VALUES, DEFS + TYPES, VALUES, DEFS, FINAL } diff --git a/core/typechecker/src/main/java/org/overture/typechecker/visitor/TypeCheckerDefinitionVisitor.java b/core/typechecker/src/main/java/org/overture/typechecker/visitor/TypeCheckerDefinitionVisitor.java index 4eeed792d0..540ca9a343 100644 --- a/core/typechecker/src/main/java/org/overture/typechecker/visitor/TypeCheckerDefinitionVisitor.java +++ b/core/typechecker/src/main/java/org/overture/typechecker/visitor/TypeCheckerDefinitionVisitor.java @@ -77,6 +77,7 @@ import org.overture.ast.statements.ANotYetSpecifiedStm; import org.overture.ast.statements.ASubclassResponsibilityStm; import org.overture.ast.typechecker.NameScope; +import org.overture.ast.typechecker.Pass; import org.overture.ast.types.ABooleanBasicType; import org.overture.ast.types.AClassType; import org.overture.ast.types.AFieldField; @@ -1491,6 +1492,12 @@ public PType caseAValueDefinition(AValueDefinition node, ExcludedDefinitions.clearExcluded(); node.setExpType(expType); PType type = node.getType(); // PDefinitionAssistant.getType(node); + + if (expType instanceof AUnknownType) + { + node.setPass(Pass.FINAL); // Do it again later + } + if (expType instanceof AVoidType) { TypeCheckerErrors.report(3048, "Expression does not return a value", node.getExpression().getLocation(), node.getExpression()); From f9b22794369df4bb5ccee500fdb863911a27bd60 Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Tue, 24 Mar 2015 17:35:16 +0100 Subject: [PATCH 315/323] Add bug tracker link to welcome page. [Issue: close #434] --- ide/platform/html/root.html | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/ide/platform/html/root.html b/ide/platform/html/root.html index 1a5664d7de..c635a73496 100644 --- a/ide/platform/html/root.html +++ b/ide/platform/html/root.html @@ -26,10 +26,11 @@

Getting Started

  • See the help containing: the VDM Language Manual, the User Guide and a collection - of examples. Goto Help->Help Contents and look for Overture.
    • + of examples. Go to Help->Help Contents and look for Overture.
  • Visit the Overture website for general news about releases: OvertureTool.org
  • For help please use the "vdm++" tag on StackOverflow
    • +
  • Bugs should be reported on the GitHub tracker (registration required).
- - - - - - - - - - - - - - - - - - - diff --git a/ide/plugins/guibuilder/src/main/java/org/overture/guibuilder/launching/GuiBuilderRtLaunchConfigurationTabGroup.java b/ide/plugins/guibuilder/src/main/java/org/overture/guibuilder/launching/GuiBuilderRtLaunchConfigurationTabGroup.java deleted file mode 100644 index 1e63328da1..0000000000 --- a/ide/plugins/guibuilder/src/main/java/org/overture/guibuilder/launching/GuiBuilderRtLaunchConfigurationTabGroup.java +++ /dev/null @@ -1,17 +0,0 @@ -package org.overture.guibuilder.launching; - -import org.overture.ide.debug.ui.launching.AbstractVdmLaunchConfigurationTabGroup; -import org.overture.ide.debug.ui.launching.AbstractVdmMainLaunchConfigurationTab; - -public class GuiBuilderRtLaunchConfigurationTabGroup extends -AbstractVdmLaunchConfigurationTabGroup { - - @Override - protected AbstractVdmMainLaunchConfigurationTab getMainTab() { - return new RtBuilderMainLaunchConfigurationTab(); - } - - - - -} diff --git a/ide/plugins/guibuilder/src/main/java/org/overture/guibuilder/launching/RtBuilderMainLaunchConfigurationTab.java b/ide/plugins/guibuilder/src/main/java/org/overture/guibuilder/launching/RtBuilderMainLaunchConfigurationTab.java deleted file mode 100644 index bc5eaa7380..0000000000 --- a/ide/plugins/guibuilder/src/main/java/org/overture/guibuilder/launching/RtBuilderMainLaunchConfigurationTab.java +++ /dev/null @@ -1,128 +0,0 @@ -package org.overture.guibuilder.launching; - -import org.eclipse.core.resources.IResource; -import org.eclipse.core.resources.ResourcesPlugin; -import org.eclipse.core.runtime.CoreException; -import org.eclipse.debug.core.ILaunchConfiguration; -import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy; -import org.eclipse.swt.SWT; -import org.eclipse.swt.layout.GridLayout; -import org.eclipse.swt.widgets.Composite; -import org.overture.ide.debug.core.IDebugConstants; -import org.overture.ide.debug.core.VdmDebugPlugin; -import org.overture.ide.vdmsl.debug.ui.launching.VdmSlMainLaunchConfigurationTab; -import org.overture.parser.messages.Console; - -public class RtBuilderMainLaunchConfigurationTab extends - VdmSlMainLaunchConfigurationTab { - - - @Override - public void createControl(Composite parent) { - Composite comp = new Composite(parent, SWT.NONE); - - setControl(comp); - comp.setLayout(new GridLayout(1, true)); - comp.setFont(parent.getFont()); - - createProjectSelection(comp); - - createOtherOptions(comp); - - } - - @Override - public void setDefaults(ILaunchConfigurationWorkingCopy configuration) { - // TODO Auto-generated method stub - - } - - @Override - public void initializeFrom(ILaunchConfiguration configuration) { - try { - fProjectText.setText(configuration.getAttribute( - IDebugConstants.VDM_LAUNCH_CONFIG_PROJECT, "")); - - if (fProjectText.getText().length() == 0) { - String newLaunchConfigName = autoFillBaseSettings(); - if (newLaunchConfigName != null) { - ILaunchConfigurationWorkingCopy wConfig = configuration - .getWorkingCopy(); - wConfig.rename(newLaunchConfigName); - wConfig.doSave();// we do not need to handle to the new - // ILaunchConfiguration since no future - // access is needed - } - } - - } catch (CoreException e) { - if (VdmDebugPlugin.DEBUG) { - e.printStackTrace(); - } - } - - } - - @Override - public boolean isValid(ILaunchConfiguration config) { - // TODO Auto-generated method stub - setErrorMessage(null); - if (getProject() == null || !getProject().exists() - || !getProject().getName().equals(fProjectText.getText())) { - setErrorMessage("Project does not exist"); - return false; - } - - if (!getProject().isOpen()) { - setErrorMessage("Project is not open"); - return false; - } - - try { - Console.charset = getProject().getDefaultCharset(); - } catch (CoreException e) { - e.printStackTrace(); - } - - return true; - - } - - @Override - public void performApply(ILaunchConfigurationWorkingCopy configuration) { - configuration.setAttribute(IDebugConstants.VDM_LAUNCH_CONFIG_PROJECT, - fProjectText.getText()); - - configuration.setAttribute( - IDebugConstants.VDM_LAUNCH_CONFIG_REMOTE_CONTROL, - IGuiBuilderConstants.REMOTE_CONTROL_CLASS); - - configuration.setAttribute( - IDebugConstants.VDM_LAUNCH_CONFIG_CREATE_COVERAGE, - checkBoxGenerateLatexCoverage.getSelection()); - - configuration.setAttribute(IDebugConstants.VDM_LAUNCH_CONFIG_DEFAULT, - defaultModule); - - // System.out.println("Expression: " + expression); - configuration.setAttribute( - IDebugConstants.VDM_LAUNCH_CONFIG_EXPRESSION, expression); - - if (!fProjectText.getText().equals("")) { - IResource[] resources = new IResource[] { (IResource) ResourcesPlugin - .getWorkspace().getRoot() - .getProject(fProjectText.getText()) }; - - configuration.setMappedResources(resources); - } else { - configuration.setMappedResources(null); - } - } - - @Override - public String getName() { - return "GUIBuilder"; - } - - -} From ce87efdb56f4c517921b373230bef9a2e951cf18 Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Tue, 24 Mar 2015 18:04:23 +0100 Subject: [PATCH 317/323] Replace NotYetImplemented with ... in WhileLoop PO. [Issue: close #420] --- .../java/org/overture/pog/obligation/WhileLoopObligation.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/pog/src/main/java/org/overture/pog/obligation/WhileLoopObligation.java b/core/pog/src/main/java/org/overture/pog/obligation/WhileLoopObligation.java index 9cca2d06a6..5e45a726cb 100644 --- a/core/pog/src/main/java/org/overture/pog/obligation/WhileLoopObligation.java +++ b/core/pog/src/main/java/org/overture/pog/obligation/WhileLoopObligation.java @@ -44,7 +44,7 @@ public WhileLoopObligation(AWhileStm stmt, IPOContextStack ctxt, whileStmt.setExp(stmt.getExp().clone()); whileStmt.setStatement(new ASkipStm()); - AVariableExp nyexp = getVarExp(new LexNameToken("", "NotYetImplemented", null)); + AVariableExp nyexp = getVarExp(new LexNameToken("", "...", null)); valuetree.setPredicate(nyexp); // valuetree.setPredicate(whileStmt); From 2d4efb77da2f414405a923c06a50bba5739bf77a Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Tue, 24 Mar 2015 18:33:37 +0100 Subject: [PATCH 318/323] Improve context awareness of POG auto-refresh. Auto-refresh now only triggers if: * the PO perspective is open * the project being rebuilt matches the last manually pogged project. [Issue: ] --- .../ide/plugins/poviewer/PoGeneratorUtil.java | 13 ++++++++++++- .../poviewer/view/PoOverviewTableView.java | 15 +++++++++++---- 2 files changed, 23 insertions(+), 5 deletions(-) diff --git a/ide/plugins/poviewer/src/main/java/org/overture/ide/plugins/poviewer/PoGeneratorUtil.java b/ide/plugins/poviewer/src/main/java/org/overture/ide/plugins/poviewer/PoGeneratorUtil.java index da20ef1a6b..e780410943 100644 --- a/ide/plugins/poviewer/src/main/java/org/overture/ide/plugins/poviewer/PoGeneratorUtil.java +++ b/ide/plugins/poviewer/src/main/java/org/overture/ide/plugins/poviewer/PoGeneratorUtil.java @@ -60,6 +60,7 @@ public class PoGeneratorUtil private File selectedFile = null; private File libFolder = null; private File selectedFolder; + private static String lastPoggedProject = null; /** * Constructor for Action1. @@ -111,7 +112,7 @@ public void generate(IProject selectedProject) IVdmProject project = (IVdmProject) selectedProject.getAdapter(IVdmProject.class); libFolder = new File(selectedProject.getLocation().toFile(), "lib"); - + lastPoggedProject=project.getName(); viewPos(project); } catch (Exception e) @@ -326,4 +327,14 @@ public void run() }); } + + public boolean isPoggedModel(IVdmModel model) + { + IVdmProject vdmproject = (IVdmProject) model.getSourceUnits().get(0).getProject(); + if (vdmproject != null) + { + return vdmproject.getName().equals(lastPoggedProject); + } + return false; + } } diff --git a/ide/plugins/poviewer/src/main/java/org/overture/ide/plugins/poviewer/view/PoOverviewTableView.java b/ide/plugins/poviewer/src/main/java/org/overture/ide/plugins/poviewer/view/PoOverviewTableView.java index e83989d3eb..9210b6973d 100644 --- a/ide/plugins/poviewer/src/main/java/org/overture/ide/plugins/poviewer/view/PoOverviewTableView.java +++ b/ide/plugins/poviewer/src/main/java/org/overture/ide/plugins/poviewer/view/PoOverviewTableView.java @@ -193,13 +193,20 @@ public IStatus runInUIThread(IProgressMonitor monitor) { if (source instanceof IVdmModel) { IVdmModel castSource = (IVdmModel) source; - IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage(); + if (!page.getPerspective().getId().equals(IPoviewerConstants.ProofObligationPerspectiveId)) + { + return new Status(IStatus.OK, + "org.overture.ide.plugins.poviewer", "Ok"); + } PoGeneratorUtil util = new PoGeneratorUtil( display.getActiveShell(), page .getActivePart().getSite()); - + if (!util.isPoggedModel(castSource)){ + return new Status(IStatus.OK, + "org.overture.ide.plugins.poviewer", "Ok"); + } util.generate(castSource); System.out.println("built something"); @@ -241,13 +248,13 @@ public void run() { * The constructor. */ public PoOverviewTableView() { -// VdmCore.addElementChangedListener(vdmlistner); + VdmCore.addElementChangedListener(vdmlistner); } @Override public void dispose() { super.dispose(); - // VdmCore.removeElementChangedListener(vdmlistner); + VdmCore.removeElementChangedListener(vdmlistner); } /** From ee33afeb80846a2488fa72e898f987b56bbff366 Mon Sep 17 00:00:00 2001 From: Nick Battle Date: Tue, 24 Mar 2015 21:05:55 +0000 Subject: [PATCH 319/323] Small fix to value def type checking --- .../typechecker/visitor/TypeCheckerDefinitionVisitor.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/typechecker/src/main/java/org/overture/typechecker/visitor/TypeCheckerDefinitionVisitor.java b/core/typechecker/src/main/java/org/overture/typechecker/visitor/TypeCheckerDefinitionVisitor.java index 540ca9a343..2948ee7bf6 100644 --- a/core/typechecker/src/main/java/org/overture/typechecker/visitor/TypeCheckerDefinitionVisitor.java +++ b/core/typechecker/src/main/java/org/overture/typechecker/visitor/TypeCheckerDefinitionVisitor.java @@ -1501,7 +1501,7 @@ public PType caseAValueDefinition(AValueDefinition node, if (expType instanceof AVoidType) { TypeCheckerErrors.report(3048, "Expression does not return a value", node.getExpression().getLocation(), node.getExpression()); - } else if (type != null) + } else if (type != null && !(type instanceof AUnknownType)) { if (!question.assistantFactory.getTypeComparator().compatible(type, expType)) { From 16654555ecae35dd353c648173a0500b79990936 Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Fri, 27 Mar 2015 13:07:51 +0100 Subject: [PATCH 320/323] UPdate pog test results - while loop obligations. [Issue: ] --- core/pog/src/test/resources/examples/ADTSL.result | 2 +- .../src/test/resources/examples/AutomatedStockBrokerPP.result | 2 +- core/pog/src/test/resources/examples/BuslinesPP.result | 2 +- core/pog/src/test/resources/examples/BuslinesWithDBPP.result | 2 +- core/pog/src/test/resources/examples/CMConcPP.result | 2 +- core/pog/src/test/resources/examples/CMSeqPP.result | 2 +- core/pog/src/test/resources/examples/ChessWayRT.result | 2 +- core/pog/src/test/resources/examples/CodegenPP.result | 2 +- core/pog/src/test/resources/examples/CyberRailRT.result | 2 +- core/pog/src/test/resources/examples/DigraphSL.result | 2 +- core/pog/src/test/resources/examples/DiningPP.result | 2 +- .../pog/src/test/resources/examples/HomeAutomationConcPP.result | 2 +- core/pog/src/test/resources/examples/HomeautomationSeqPP.result | 2 +- core/pog/src/test/resources/examples/HubInSafeModePP.result | 2 +- core/pog/src/test/resources/examples/LUPSL.result | 2 +- core/pog/src/test/resources/examples/MSAWRT.result | 2 +- core/pog/src/test/resources/examples/MSAWconcurPP.result | 2 +- core/pog/src/test/resources/examples/MSAWseqPP.result | 2 +- core/pog/src/test/resources/examples/PacemakerConcPP.result | 2 +- core/pog/src/test/resources/examples/PacemakerRT.result | 2 +- core/pog/src/test/resources/examples/PacemakerSeqPP.result | 2 +- core/pog/src/test/resources/examples/ProductLinePP.result | 2 +- core/pog/src/test/resources/examples/RobotRT.result | 2 +- core/pog/src/test/resources/examples/SAFERSL.result | 2 +- core/pog/src/test/resources/examples/SSlibE2PP.result | 2 +- core/pog/src/test/resources/examples/STVSL.result | 2 +- core/pog/src/test/resources/examples/VDMRT.result | 2 +- core/pog/src/test/resources/examples/VeMoRT.result | 2 +- core/pog/src/test/resources/examples/librarySL.result | 2 +- core/pog/src/test/resources/examples/looseSL.result | 2 +- core/pog/src/test/resources/examples/realmSL.result | 2 +- core/pog/src/test/resources/examples/shmemSL.result | 2 +- core/pog/src/test/resources/examples/simulatorSL.result | 2 +- core/pog/src/test/resources/examples/trayallocationPP.result | 2 +- core/pog/src/test/resources/examples/treePP.result | 2 +- core/pog/src/test/resources/old/direct/pp/DiningPP.vdmpp.result | 2 +- .../resources/old/direct/pp/HomeAutomationConcPP.vdmpp.result | 2 +- core/pog/src/test/resources/old/direct/sl/LUPSLSL.vdmsl.result | 2 +- .../pog/src/test/resources/old/direct/sl/librarySL.vdmsl.result | 2 +- core/pog/src/test/resources/old/direct/sl/shmemSL.vdmsl.result | 2 +- 40 files changed, 40 insertions(+), 40 deletions(-) diff --git a/core/pog/src/test/resources/examples/ADTSL.result b/core/pog/src/test/resources/examples/ADTSL.result index 79f818c3f3..6b7f39bebe 100644 --- a/core/pog/src/test/resources/examples/ADTSL.result +++ b/core/pog/src/test/resources/examples/ADTSL.result @@ -1 +1 @@ -["value binding obligation:(forall node:Nodes_Node \u0026 ((is_(node, Nodes_SingleLink) or (is_(node, Nodes_DoubleLink) or is_(node, Nodes_BinaryTree))) \u003d\u003e ((not is_(node, Nodes_SingleLink)) \u003d\u003e ((not is_(node, Nodes_DoubleLink)) \u003d\u003e (exists mk_Nodes_BinaryTree(data, -, -, -):Nodes_Node \u0026 (mk_Nodes_BinaryTree(data, any1, any2, any3) \u003d node))))))","type compatibility obligation:(forall node:Nodes_Node \u0026 ((is_(node, Nodes_SingleLink) or (is_(node, Nodes_DoubleLink) or is_(node, Nodes_BinaryTree))) \u003d\u003e ((not is_(node, Nodes_SingleLink)) \u003d\u003e ((not is_(node, Nodes_DoubleLink)) \u003d\u003e is_(node, Nodes_BinaryTree)))))","value binding obligation:(forall node:Nodes_Node, data:Nodes_Data \u0026 ((is_(node, Nodes_SingleLink) or (is_(node, Nodes_DoubleLink) or is_(node, Nodes_BinaryTree))) \u003d\u003e ((not is_(node, Nodes_SingleLink)) \u003d\u003e ((not is_(node, Nodes_DoubleLink)) \u003d\u003e (exists mk_Nodes_BinaryTree(-, right, left, parent):Nodes_Node \u0026 (mk_Nodes_BinaryTree(any1, right, left, parent) \u003d node))))))","type compatibility obligation:(forall node:Nodes_Node, data:Nodes_Data \u0026 ((is_(node, Nodes_SingleLink) or (is_(node, Nodes_DoubleLink) or is_(node, Nodes_BinaryTree))) \u003d\u003e ((not is_(node, Nodes_SingleLink)) \u003d\u003e ((not is_(node, Nodes_DoubleLink)) \u003d\u003e is_(node, Nodes_BinaryTree)))))","value binding obligation:(forall node:Nodes_Node \u0026 ((is_(node, Nodes_SingleLink) or is_(node, Nodes_DoubleLink)) \u003d\u003e ((not is_(node, Nodes_SingleLink)) \u003d\u003e (exists mk_Nodes_DoubleLink(-, next, -):Nodes_Node \u0026 (mk_Nodes_DoubleLink(any1, next, any2) \u003d node)))))","type compatibility obligation:(forall node:Nodes_Node \u0026 ((is_(node, Nodes_SingleLink) or is_(node, Nodes_DoubleLink)) \u003d\u003e ((not is_(node, Nodes_SingleLink)) \u003d\u003e is_(node, Nodes_DoubleLink))))","value binding obligation:(forall node:Nodes_Node, next:Nodes_NodePtr \u0026 ((is_(node, Nodes_SingleLink) or is_(node, Nodes_DoubleLink)) \u003d\u003e ((not is_(node, Nodes_SingleLink)) \u003d\u003e (exists mk_Nodes_DoubleLink(data, -, prev):Nodes_Node \u0026 (mk_Nodes_DoubleLink(data, any1, prev) \u003d node)))))","type compatibility obligation:(forall node:Nodes_Node, next:Nodes_NodePtr \u0026 ((is_(node, Nodes_SingleLink) or is_(node, Nodes_DoubleLink)) \u003d\u003e ((not is_(node, Nodes_SingleLink)) \u003d\u003e is_(node, Nodes_DoubleLink))))","type invariant satisfiable obligation:(exists mk_Heaps_Location(d, a):Heaps_Location \u0026 ((a \u003d true) \u003c\u003d\u003e (d \u003c\u003e nil)))","type invariant satisfiable obligation:(exists mk_Heaps_Heap(s):Heaps_Heap \u0026 ((len s) \u003d Heaps_Size))","type compatibility obligation:(forall length:nat1 \u0026 ((length \u003e 1) \u003d\u003e inv_Heaps_Location(mk_Heaps_Location(nil, false))))","type compatibility obligation:(forall length:nat1 \u0026 ((length \u003e 1) \u003d\u003e ((length - 1) \u003e 0)))","type compatibility obligation:(forall length:nat1 \u0026 ((not (length \u003e 1)) \u003d\u003e inv_Heaps_Location(mk_Heaps_Location(nil, false))))","type compatibility obligation:inv_Heaps_Heap(mk_Heaps_Heap(Heaps_InitSequence(Heaps_Size)))","legal sequence application obligation:(forall heap:Heaps_Heap \u0026 let store:seq of (Heaps_Location) \u003d (heap.storage) in (forall i in set (inds store) \u0026 (((store(i).allocated) \u003d true) \u003d\u003e (i in set (inds store)))))","legal sequence application obligation:(forall heap:Heaps_Heap \u0026 let store:seq of (Heaps_Location) \u003d (heap.storage) in (forall i in set (inds store) \u0026 (i in set (inds store))))","sequence modification obligation:(forall heap:Heaps_Heap, address:ADDRESS, location:Heaps_Location \u0026 ((address in set (inds (heap.storage))) \u003d\u003e ((dom {address |-\u003e location}) subset (inds (heap.storage)))))","type compatibility obligation:(forall heap:Heaps_Heap, address:ADDRESS, location:Heaps_Location \u0026 ((address in set (inds (heap.storage))) \u003d\u003e inv_Heaps_Heap(mk_Heaps_Heap(((heap.storage) ++ {address |-\u003e location})))))","legal sequence application obligation:(forall heap:Heaps_Heap, address:ADDRESS, data:Heaps_Data \u0026 let store:seq of (Heaps_Location) \u003d (heap.storage) in ((address in set (inds store)) \u003d\u003e (address in set (inds store))))","legal function application obligation:(forall heap:Heaps_Heap, address:ADDRESS, data:Heaps_Data \u0026 (let store:seq of (Heaps_Location) \u003d (heap.storage) in ((address in set (inds store)) and ((store(address).allocated) \u003d true)) \u003d\u003e pre_Heaps_ModifyLoc(heap, address, mk_Heaps_Location(data, true))))","type compatibility obligation:(forall heap:Heaps_Heap, address:ADDRESS, data:Heaps_Data \u0026 (let store:seq of (Heaps_Location) \u003d (heap.storage) in ((address in set (inds store)) and ((store(address).allocated) \u003d true)) \u003d\u003e inv_Heaps_Location(mk_Heaps_Location(data, true))))","legal sequence application obligation:(forall heap:Heaps_Heap, address:ADDRESS \u0026 let store:seq of (Heaps_Location) \u003d (heap.storage) in ((address in set (inds store)) \u003d\u003e (address in set (inds store))))","legal sequence application obligation:(forall heap:Heaps_Heap, address:ADDRESS \u0026 (let store:seq of (Heaps_Location) \u003d (heap.storage) in ((address in set (inds store)) and ((store(address).allocated) \u003d true)) \u003d\u003e (address in set (inds (heap.storage)))))","legal sequence application obligation:(forall heap:Heaps_Heap \u0026 let store:seq of (Heaps_Location) \u003d (heap.storage) in (forall i in set (inds store) \u0026 (i in set (inds store))))","unique existence binding obligation:(forall heap:Heaps_Heap \u0026 (Heaps_Available(heap) \u003d\u003e (exists1 new in set Heaps_UnallocatedAddresses(heap) \u0026 (forall i in set Heaps_UnallocatedAddresses(heap) \u0026 (new \u003c\u003d i)))))","legal function application obligation:(forall data:Heaps_Data, oldstate:SystemState \u0026 (Heaps_Available(heap) \u003d\u003e pre_Heaps_UnallocatedAddress(heap)))","type compatibility obligation:(forall data:Heaps_Data, oldstate:SystemState \u0026 (Heaps_Available(heap) \u003d\u003e inv_Heaps_Location(mk_Heaps_Location(data, true))))","legal function application obligation:(forall data:Heaps_Data, oldstate:SystemState \u0026 (Heaps_Available(heap) \u003d\u003e pre_Heaps_ModifyLoc(heap, newAddress, newLoc)))","type compatibility obligation:(forall address:ADDRESS, oldstate:SystemState \u0026 (pre_Heaps_ModifyLoc(heap, address, mk_Heaps_Location(nil, false)) \u003d\u003e inv_Heaps_Location(mk_Heaps_Location(nil, false))))","legal function application obligation:(forall address:ADDRESS, oldstate:SystemState \u0026 (pre_Heaps_ModifyLoc(heap, address, mk_Heaps_Location(nil, false)) \u003d\u003e pre_Heaps_ModifyLoc(heap, address, mk_Heaps_Location(nil, false))))","type compatibility obligation:(forall address:ADDRESS, oldstate:SystemState \u0026 (pre_Heaps_ModifyLoc(heap, address, mk_Heaps_Location(nil, false)) \u003d\u003e inv_Heaps_Location(mk_Heaps_Location(nil, false))))","legal function application obligation:(forall ptr:ADDRESS, data:Data, oldstate:SystemState \u0026 pre_Heaps_Modify(heap, ptr, Nodes_SetData(Heaps_Retrieve(heap, ptr), data)))","legal function application obligation:(forall ptr:ADDRESS, data:Data, oldstate:SystemState \u0026 pre_Nodes_SetData(Heaps_Retrieve(heap, ptr), data))","type compatibility obligation:(forall ptr:ADDRESS, data:Data, oldstate:SystemState \u0026 ((is_(Heaps_Retrieve(heap, ptr), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, ptr), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, ptr), Nodes_SingleLink)))","legal function application obligation:(forall ptr:ADDRESS, data:Data, oldstate:SystemState \u0026 pre_Heaps_Retrieve(heap, ptr))","legal function application obligation:(forall ptr:ADDRESS, next:ADDRESS, oldstate:SystemState \u0026 pre_Heaps_Modify(heap, ptr, Nodes_SetNext(Heaps_Retrieve(heap, ptr), next)))","legal function application obligation:(forall ptr:ADDRESS, next:ADDRESS, oldstate:SystemState \u0026 pre_Nodes_SetNext(Heaps_Retrieve(heap, ptr), next))","type compatibility obligation:(forall ptr:ADDRESS, next:ADDRESS, oldstate:SystemState \u0026 ((is_(Heaps_Retrieve(heap, ptr), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, ptr), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, ptr), Nodes_SingleLink)))","legal function application obligation:(forall ptr:ADDRESS, next:ADDRESS, oldstate:SystemState \u0026 pre_Heaps_Retrieve(heap, ptr))","legal function application obligation:(forall ptr:ADDRESS, left:ADDRESS, oldstate:SystemState \u0026 pre_Heaps_Modify(heap, ptr, Nodes_SetLeft(Heaps_Retrieve(heap, ptr), left)))","legal function application obligation:(forall ptr:ADDRESS, left:ADDRESS, oldstate:SystemState \u0026 pre_Nodes_SetLeft(Heaps_Retrieve(heap, ptr), left))","type compatibility obligation:(forall ptr:ADDRESS, left:ADDRESS, oldstate:SystemState \u0026 ((is_(Heaps_Retrieve(heap, ptr), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, ptr), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, ptr), Nodes_SingleLink)))","legal function application obligation:(forall ptr:ADDRESS, left:ADDRESS, oldstate:SystemState \u0026 pre_Heaps_Retrieve(heap, ptr))","legal function application obligation:(forall ptr:ADDRESS, right:ADDRESS, oldstate:SystemState \u0026 pre_Heaps_Modify(heap, ptr, Nodes_SetRight(Heaps_Retrieve(heap, ptr), right)))","legal function application obligation:(forall ptr:ADDRESS, right:ADDRESS, oldstate:SystemState \u0026 pre_Nodes_SetRight(Heaps_Retrieve(heap, ptr), right))","type compatibility obligation:(forall ptr:ADDRESS, right:ADDRESS, oldstate:SystemState \u0026 ((is_(Heaps_Retrieve(heap, ptr), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, ptr), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, ptr), Nodes_SingleLink)))","legal function application obligation:(forall ptr:ADDRESS, right:ADDRESS, oldstate:SystemState \u0026 pre_Heaps_Retrieve(heap, ptr))","legal function application obligation:(forall ptr:ADDRESS, prev:ADDRESS, oldstate:SystemState \u0026 pre_Heaps_Modify(heap, ptr, Nodes_SetPrev(Heaps_Retrieve(heap, ptr), prev)))","legal function application obligation:(forall ptr:ADDRESS, prev:ADDRESS, oldstate:SystemState \u0026 pre_Nodes_SetPrev(Heaps_Retrieve(heap, ptr), prev))","type compatibility obligation:(forall ptr:ADDRESS, prev:ADDRESS, oldstate:SystemState \u0026 ((is_(Heaps_Retrieve(heap, ptr), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, ptr), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, ptr), Nodes_SingleLink)))","legal function application obligation:(forall ptr:ADDRESS, prev:ADDRESS, oldstate:SystemState \u0026 pre_Heaps_Retrieve(heap, ptr))","legal function application obligation:(forall ptr:ADDRESS, parent:ADDRESS, oldstate:SystemState \u0026 pre_Heaps_Modify(heap, ptr, Nodes_SetParent(Heaps_Retrieve(heap, ptr), parent)))","legal function application obligation:(forall ptr:ADDRESS, parent:ADDRESS, oldstate:SystemState \u0026 pre_Nodes_SetParent(Heaps_Retrieve(heap, ptr), parent))","type compatibility obligation:(forall ptr:ADDRESS, parent:ADDRESS, oldstate:SystemState \u0026 ((is_(Heaps_Retrieve(heap, ptr), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, ptr), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, ptr), Nodes_SingleLink)))","legal function application obligation:(forall ptr:ADDRESS, parent:ADDRESS, oldstate:SystemState \u0026 pre_Heaps_Retrieve(heap, ptr))","legal function application obligation:(forall ptr:ADDRESS, oldstate:SystemState \u0026 pre_Nodes_GetData(Heaps_Retrieve(heap, ptr)))","type compatibility obligation:(forall ptr:ADDRESS, oldstate:SystemState \u0026 ((is_(Heaps_Retrieve(heap, ptr), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, ptr), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, ptr), Nodes_SingleLink)))","legal function application obligation:(forall ptr:ADDRESS, oldstate:SystemState \u0026 pre_Heaps_Retrieve(heap, ptr))","legal function application obligation:(forall ptr:ADDRESS, oldstate:SystemState \u0026 pre_Nodes_GetNext(Heaps_Retrieve(heap, ptr)))","type compatibility obligation:(forall ptr:ADDRESS, oldstate:SystemState \u0026 ((is_(Heaps_Retrieve(heap, ptr), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, ptr), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, ptr), Nodes_SingleLink)))","legal function application obligation:(forall ptr:ADDRESS, oldstate:SystemState \u0026 pre_Heaps_Retrieve(heap, ptr))","legal function application obligation:(forall ptr:ADDRESS, oldstate:SystemState \u0026 pre_Nodes_GetLeft(Heaps_Retrieve(heap, ptr)))","type compatibility obligation:(forall ptr:ADDRESS, oldstate:SystemState \u0026 ((is_(Heaps_Retrieve(heap, ptr), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, ptr), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, ptr), Nodes_SingleLink)))","legal function application obligation:(forall ptr:ADDRESS, oldstate:SystemState \u0026 pre_Heaps_Retrieve(heap, ptr))","legal function application obligation:(forall ptr:ADDRESS, oldstate:SystemState \u0026 pre_Nodes_GetRight(Heaps_Retrieve(heap, ptr)))","type compatibility obligation:(forall ptr:ADDRESS, oldstate:SystemState \u0026 ((is_(Heaps_Retrieve(heap, ptr), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, ptr), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, ptr), Nodes_SingleLink)))","legal function application obligation:(forall ptr:ADDRESS, oldstate:SystemState \u0026 pre_Heaps_Retrieve(heap, ptr))","legal function application obligation:(forall ptr:ADDRESS, oldstate:SystemState \u0026 pre_Nodes_GetParent(Heaps_Retrieve(heap, ptr)))","type compatibility obligation:(forall ptr:ADDRESS, oldstate:SystemState \u0026 ((is_(Heaps_Retrieve(heap, ptr), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, ptr), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, ptr), Nodes_SingleLink)))","legal function application obligation:(forall ptr:ADDRESS, oldstate:SystemState \u0026 pre_Heaps_Retrieve(heap, ptr))","legal function application obligation:(forall heap:Heaps_Heap, list:SList_List \u0026 ((not SList_IsEmpty(list)) \u003d\u003e pre_Heaps_Retrieve(heap, list)))","legal function application obligation:(forall heap:Heaps_Heap, list:SList_List \u0026 ((not SList_IsEmpty(list)) \u003d\u003e let node:[Heaps_Data] \u003d Heaps_Retrieve(heap, list) in pre_Nodes_GetData(node)))","type compatibility obligation:(forall heap:Heaps_Heap, list:SList_List \u0026 ((not SList_IsEmpty(list)) \u003d\u003e let node:[Heaps_Data] \u003d Heaps_Retrieve(heap, list) in ((is_(node, Nodes_BinaryTree) or is_(node, Nodes_DoubleLink)) or is_(node, Nodes_SingleLink))))","legal function application obligation:(forall heap:Heaps_Heap, list:SList_List \u0026 ((not SList_IsEmpty(list)) \u003d\u003e let node:[Heaps_Data] \u003d Heaps_Retrieve(heap, list) in let data:Nodes_Data \u003d Nodes_GetData(node) in pre_Nodes_GetNext(node)))","type compatibility obligation:(forall heap:Heaps_Heap, list:SList_List \u0026 ((not SList_IsEmpty(list)) \u003d\u003e let node:[Heaps_Data] \u003d Heaps_Retrieve(heap, list) in let data:Nodes_Data \u003d Nodes_GetData(node) in ((is_(node, Nodes_BinaryTree) or is_(node, Nodes_DoubleLink)) or is_(node, Nodes_SingleLink))))","function establishes postcondition obligation:(forall heap:Heaps_Heap, list:SList_List \u0026 post_SList_Lengthf(heap, list, (if (not SList_IsEmpty(list))\nthen let tail:Nodes_NodePtr \u003d Nodes_GetNext(Heaps_Retrieve(heap, list)) in (1 + SList_Lengthf(heap, tail))\nelse 0)))","legal function application obligation:(forall heap:Heaps_Heap, list:SList_List \u0026 ((not SList_IsEmpty(list)) \u003d\u003e pre_Nodes_GetNext(Heaps_Retrieve(heap, list))))","type compatibility obligation:(forall heap:Heaps_Heap, list:SList_List \u0026 ((not SList_IsEmpty(list)) \u003d\u003e ((is_(Heaps_Retrieve(heap, list), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, list), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, list), Nodes_SingleLink))))","legal function application obligation:(forall heap:Heaps_Heap, list:SList_List \u0026 ((not SList_IsEmpty(list)) \u003d\u003e pre_Heaps_Retrieve(heap, list)))","function establishes postcondition obligation:(forall heap:Heaps_Heap, list:SList_List, position:nat1 \u0026 (pre_SList_PtrToNode(heap, list, position) \u003d\u003e post_SList_PtrToNode(heap, list, position, let tail:Nodes_NodePtr \u003d Nodes_GetNext(Heaps_Retrieve(heap, list)) in (if (position \u003e 1)\nthen SList_PtrToNode(heap, tail, (position - 1))\nelse list))))","legal function application obligation:(forall heap:Heaps_Heap, list:SList_List, position:nat1 \u0026 ((position \u003c\u003d SList_Lengthf(heap, list)) \u003d\u003e let RESULT \u003d let tail:Nodes_NodePtr \u003d Nodes_GetNext(Heaps_Retrieve(heap, list)) in (if (position \u003e 1)\nthen SList_PtrToNode(heap, tail, (position - 1))\nelse list) in pre_Nodes_GetData(Heaps_Retrieve(heap, RESULT))))","type compatibility obligation:(forall heap:Heaps_Heap, list:SList_List, position:nat1 \u0026 ((position \u003c\u003d SList_Lengthf(heap, list)) \u003d\u003e let RESULT \u003d let tail:Nodes_NodePtr \u003d Nodes_GetNext(Heaps_Retrieve(heap, list)) in (if (position \u003e 1)\nthen SList_PtrToNode(heap, tail, (position - 1))\nelse list) in ((is_(Heaps_Retrieve(heap, RESULT), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, RESULT), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, RESULT), Nodes_SingleLink))))","legal function application obligation:(forall heap:Heaps_Heap, list:SList_List, position:nat1 \u0026 ((position \u003c\u003d SList_Lengthf(heap, list)) \u003d\u003e let RESULT \u003d let tail:Nodes_NodePtr \u003d Nodes_GetNext(Heaps_Retrieve(heap, list)) in (if (position \u003e 1)\nthen SList_PtrToNode(heap, tail, (position - 1))\nelse list) in pre_Heaps_Retrieve(heap, RESULT)))","legal sequence application obligation:(forall heap:Heaps_Heap, list:SList_List, position:nat1 \u0026 ((position \u003c\u003d SList_Lengthf(heap, list)) \u003d\u003e let RESULT \u003d let tail:Nodes_NodePtr \u003d Nodes_GetNext(Heaps_Retrieve(heap, list)) in (if (position \u003e 1)\nthen SList_PtrToNode(heap, tail, (position - 1))\nelse list) in let data:Nodes_Data \u003d Nodes_GetData(Heaps_Retrieve(heap, RESULT)), listSeq:seq of (SList_Data) \u003d SList_Seq(heap, list) in (position in set (inds listSeq))))","legal function application obligation:(forall heap:Heaps_Heap, list:SList_List, position:nat1 \u0026 ((position \u003c\u003d SList_Lengthf(heap, list)) \u003d\u003e pre_Nodes_GetNext(Heaps_Retrieve(heap, list))))","type compatibility obligation:(forall heap:Heaps_Heap, list:SList_List, position:nat1 \u0026 ((position \u003c\u003d SList_Lengthf(heap, list)) \u003d\u003e ((is_(Heaps_Retrieve(heap, list), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, list), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, list), Nodes_SingleLink))))","legal function application obligation:(forall heap:Heaps_Heap, list:SList_List, position:nat1 \u0026 ((position \u003c\u003d SList_Lengthf(heap, list)) \u003d\u003e pre_Heaps_Retrieve(heap, list)))","legal function application obligation:(forall heap:Heaps_Heap, list:SList_List, position:nat1 \u0026 ((position \u003c\u003d SList_Lengthf(heap, list)) \u003d\u003e let tail:Nodes_NodePtr \u003d Nodes_GetNext(Heaps_Retrieve(heap, list)) in ((position \u003e 1) \u003d\u003e pre_SList_PtrToNode(heap, tail, (position - 1)))))","type compatibility obligation:(forall heap:Heaps_Heap, list:SList_List, position:nat1 \u0026 ((position \u003c\u003d SList_Lengthf(heap, list)) \u003d\u003e let tail:Nodes_NodePtr \u003d Nodes_GetNext(Heaps_Retrieve(heap, list)) in ((position \u003e 1) \u003d\u003e ((position - 1) \u003e 0))))","operation establishes postcondition obligation:(forall list:SList_List, data:SList_Data, oldstate:SystemState \u0026 (([data] ^ SList_Seq(heap~, list)) \u003d SList_Seq(heap, RESULT)))","legal sequence application obligation:(forall list:SList_List, ptr:Nodes_NodePtr, data:SList_Data, oldstate:SystemState \u0026 (true \u003d\u003e let old:seq of (SList_Data) \u003d SList_Seq(heap~, ptr) in (1 in set (inds old))))","non-empty sequence obligation:(forall list:SList_List, ptr:Nodes_NodePtr, data:SList_Data, oldstate:SystemState \u0026 (true \u003d\u003e let old:seq of (SList_Data) \u003d SList_Seq(heap~, ptr) in (old \u003c\u003e [])))","operation establishes postcondition obligation:(forall list:SList_List, ptr:Nodes_NodePtr, data:SList_Data, oldstate:SystemState \u0026 (true \u003d\u003e let old:seq of (SList_Data) \u003d SList_Seq(heap~, ptr) in ((([old(1)] ^ [data]) ^ (tl old)) \u003d SList_Seq(heap, ptr))))","legal function application obligation:(forall list:SList_List, data:SList_Data, position:nat1, oldstate:SystemState \u0026 (((position \u003c\u003d (SList_Lengthf(heap, list) + 1)) and Heaps_Available(heap)) \u003d\u003e pre_SList_PtrToNode(heap, list, (position - 1))))","type compatibility obligation:(forall list:SList_List, data:SList_Data, position:nat1, oldstate:SystemState \u0026 (((position \u003c\u003d (SList_Lengthf(heap, list) + 1)) and Heaps_Available(heap)) \u003d\u003e ((position - 1) \u003e 0)))","legal sequence application obligation:(forall list:SList_List, data:SList_Data, position:nat1, oldstate:SystemState \u0026 (((position \u003c\u003d (SList_Lengthf(heap, list) + 1)) and Heaps_Available(heap)) \u003d\u003e let new:seq of (SList_Data) \u003d SList_Seq(heap, RESULT) in (forall i in set (inds new) \u0026 ((i \u003c\u003e position) \u003d\u003e (i in set (inds new))))))","legal sequence application obligation:(forall list:SList_List, data:SList_Data, position:nat1, oldstate:SystemState \u0026 (((position \u003c\u003d (SList_Lengthf(heap, list) + 1)) and Heaps_Available(heap)) \u003d\u003e let new:seq of (SList_Data) \u003d SList_Seq(heap, RESULT) in ((SList_Seq(heap~, list) \u003d [new(i) | i in set (inds new) \u0026 (i \u003c\u003e position)]) \u003d\u003e (position in set (inds new)))))","operation establishes postcondition obligation:(forall list:SList_List, data:SList_Data, position:nat1, oldstate:SystemState \u0026 (((position \u003c\u003d (SList_Lengthf(heap, list) + 1)) and Heaps_Available(heap)) \u003d\u003e let new:seq of (SList_Data) \u003d SList_Seq(heap, RESULT) in ((SList_Seq(heap~, list) \u003d [new(i) | i in set (inds new) \u0026 (i \u003c\u003e position)]) and ((new(position) \u003d data) and ((Heaps_AmountUsed(heap~) + 1) \u003d Heaps_AmountUsed(heap))))))","while loop termination obligation:NotYetImplemented","operation establishes postcondition obligation:(forall list:SList_List, data:SList_Data, oldstate:SystemState \u0026 (Heaps_Available(heap) \u003d\u003e (((SList_Seq(heap~, list) ^ [data]) \u003d SList_Seq(heap, RESULT)) and ((Heaps_AmountUsed(heap~) + 1) \u003d Heaps_AmountUsed(heap)))))","legal function application obligation:(forall list:SList_List, data:SList_Data, position:nat1, oldstate:SystemState \u0026 ((position \u003c\u003d SList_Lengthf(heap, list)) \u003d\u003e pre_SList_PtrToNode(heap, list, position)))","sequence modification obligation:(forall list:SList_List, data:SList_Data, position:nat1, oldstate:SystemState \u0026 ((position \u003c\u003d SList_Lengthf(heap, list)) \u003d\u003e (true \u003d\u003e ((dom {position |-\u003e data}) subset (inds SList_Seq(heap~, list))))))","operation establishes postcondition obligation:(forall list:SList_List, data:SList_Data, position:nat1, oldstate:SystemState \u0026 ((position \u003c\u003d SList_Lengthf(heap, list)) \u003d\u003e (true \u003d\u003e (((SList_Seq(heap~, list) ++ {position |-\u003e data}) \u003d SList_Seq(heap, RESULT)) and (Heaps_AmountUsed(heap~) \u003d Heaps_AmountUsed(heap))))))","operation call obligation:(forall list:SList_List, oldstate:SystemState \u0026 pre_Heaps_ModifyLoc(heap, address, mk_Heaps_Location(nil, false)))","non-empty sequence obligation:(forall list:SList_List, oldstate:SystemState \u0026 (true \u003d\u003e (SList_Seq(heap~, list) \u003c\u003e [])))","operation establishes postcondition obligation:(forall list:SList_List, oldstate:SystemState \u0026 (true \u003d\u003e ((tl SList_Seq(heap~, list)) \u003d SList_Seq(heap, RESULT))))","operation call obligation:(forall list:SList_List, ptr:Nodes_NodePtr, oldstate:SystemState \u0026 (true \u003d\u003e pre_Heaps_ModifyLoc(heap, address, mk_Heaps_Location(nil, false))))","legal sequence application obligation:(forall list:SList_List, ptr:Nodes_NodePtr, oldstate:SystemState \u0026 (true \u003d\u003e (true \u003d\u003e let old:seq of (SList_Data) \u003d SList_Seq(heap~, ptr) in (1 in set (inds old)))))","non-empty sequence obligation:(forall list:SList_List, ptr:Nodes_NodePtr, oldstate:SystemState \u0026 (true \u003d\u003e (true \u003d\u003e let old:seq of (SList_Data) \u003d SList_Seq(heap~, ptr) in (old \u003c\u003e []))))","non-empty sequence obligation:(forall list:SList_List, ptr:Nodes_NodePtr, oldstate:SystemState \u0026 (true \u003d\u003e (true \u003d\u003e let old:seq of (SList_Data) \u003d SList_Seq(heap~, ptr) in ((tl old) \u003c\u003e []))))","operation establishes postcondition obligation:(forall list:SList_List, ptr:Nodes_NodePtr, oldstate:SystemState \u0026 (true \u003d\u003e (true \u003d\u003e let old:seq of (SList_Data) \u003d SList_Seq(heap~, ptr) in (([old(1)] ^ (tl (tl old))) \u003d SList_Seq(heap, ptr)))))","legal function application obligation:(forall list:SList_List, position:nat1, oldstate:SystemState \u0026 ((position \u003c\u003d SList_Lengthf(heap, list)) \u003d\u003e pre_SList_PtrToNode(heap, list, (position - 1))))","type compatibility obligation:(forall list:SList_List, position:nat1, oldstate:SystemState \u0026 ((position \u003c\u003d SList_Lengthf(heap, list)) \u003d\u003e ((position - 1) \u003e 0)))","legal sequence application obligation:(forall list:SList_List, position:nat1, oldstate:SystemState \u0026 ((position \u003c\u003d SList_Lengthf(heap, list)) \u003d\u003e let old:seq of (SList_Data) \u003d SList_Seq(heap~, list) in (forall i in set (inds old) \u0026 ((i \u003c\u003e position) \u003d\u003e (i in set (inds old))))))","operation establishes postcondition obligation:(forall list:SList_List, position:nat1, oldstate:SystemState \u0026 ((position \u003c\u003d SList_Lengthf(heap, list)) \u003d\u003e let old:seq of (SList_Data) \u003d SList_Seq(heap~, list) in (([old(i) | i in set (inds old) \u0026 (i \u003c\u003e position)] \u003d SList_Seq(heap, RESULT)) and (Heaps_AmountUsed(heap~) \u003d (Heaps_AmountUsed(heap) + 1)))))","while loop termination obligation:NotYetImplemented","legal function application obligation:(forall list:SList_List, traversal:(SList_Data -\u003e SList_Data), oldstate:SystemState \u0026 pre_(traversalDATA(ptr)))","legal function application obligation:(forall list:SList_List, traversal:(SList_Data -\u003e SList_Data), oldstate:SystemState \u0026 (true \u003d\u003e let old:seq of (SList_Data) \u003d SList_Seq(heap~, list) in ((old \u003c\u003e []) \u003d\u003e (forall i in set (inds old) \u0026 pre_(traversalold(i))))))","legal sequence application obligation:(forall list:SList_List, traversal:(SList_Data -\u003e SList_Data), oldstate:SystemState \u0026 (true \u003d\u003e let old:seq of (SList_Data) \u003d SList_Seq(heap~, list) in ((old \u003c\u003e []) \u003d\u003e (forall i in set (inds old) \u0026 (i in set (inds old))))))","operation establishes postcondition obligation:(forall list:SList_List, traversal:(SList_Data -\u003e SList_Data), oldstate:SystemState \u0026 (true \u003d\u003e let old:seq of (SList_Data) \u003d SList_Seq(heap~, list) in ((old \u003c\u003e []) \u003d\u003e ([traversal(old(i)) | i in set (inds old)] \u003d SList_Seq(heap, RESULT)))))","legal function application obligation:(forall list:SList_List, position:nat1, oldstate:SystemState \u0026 pre_SList_PtrToNode(heap, list, position))","legal function application obligation:(forall heap:Heaps_Heap, list:DList_List \u0026 pre_Nodes_GetNext(Heaps_Retrieve(heap, list)))","type compatibility obligation:(forall heap:Heaps_Heap, list:DList_List \u0026 ((is_(Heaps_Retrieve(heap, list), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, list), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, list), Nodes_SingleLink)))","legal function application obligation:(forall heap:Heaps_Heap, list:DList_List \u0026 pre_Heaps_Retrieve(heap, list))","legal function application obligation:(forall heap:Heaps_Heap, list:DList_List \u0026 ((list \u003c\u003e NIL) \u003d\u003e pre_Nodes_GetPrev(Heaps_Retrieve(heap, list))))","type compatibility obligation:(forall heap:Heaps_Heap, list:DList_List \u0026 ((list \u003c\u003e NIL) \u003d\u003e ((is_(Heaps_Retrieve(heap, list), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, list), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, list), Nodes_SingleLink))))","legal function application obligation:(forall heap:Heaps_Heap, list:DList_List \u0026 ((list \u003c\u003e NIL) \u003d\u003e pre_Heaps_Retrieve(heap, list)))","legal function application obligation:(forall heap:Heaps_Heap, list:DList_List \u0026 ((list \u003c\u003e NIL) \u003d\u003e let prev:Nodes_NodePtr \u003d Nodes_GetPrev(Heaps_Retrieve(heap, list)) in pre_Nodes_GetData(Heaps_Retrieve(heap, list))))","type compatibility obligation:(forall heap:Heaps_Heap, list:DList_List \u0026 ((list \u003c\u003e NIL) \u003d\u003e let prev:Nodes_NodePtr \u003d Nodes_GetPrev(Heaps_Retrieve(heap, list)) in ((is_(Heaps_Retrieve(heap, list), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, list), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, list), Nodes_SingleLink))))","legal function application obligation:(forall heap:Heaps_Heap, list:DList_List \u0026 ((list \u003c\u003e NIL) \u003d\u003e let prev:Nodes_NodePtr \u003d Nodes_GetPrev(Heaps_Retrieve(heap, list)) in pre_Heaps_Retrieve(heap, list)))","operation establishes postcondition obligation:(forall list:DList_List, data:DList_Data, oldstate:SystemState \u0026 (true \u003d\u003e (([data] ^ SList_Seq(heap~, list)) \u003d SList_Seq(heap, RESULT))))","legal sequence application obligation:(forall list:DList_List, ptr:Nodes_NodePtr, data:DList_Data, oldstate:SystemState \u0026 (true \u003d\u003e (true \u003d\u003e let old:seq of (SList_Data) \u003d SList_Seq(heap~, ptr) in (1 in set (inds old)))))","non-empty sequence obligation:(forall list:DList_List, ptr:Nodes_NodePtr, data:DList_Data, oldstate:SystemState \u0026 (true \u003d\u003e (true \u003d\u003e let old:seq of (SList_Data) \u003d SList_Seq(heap~, ptr) in (old \u003c\u003e []))))","operation establishes postcondition obligation:(forall list:DList_List, ptr:Nodes_NodePtr, data:DList_Data, oldstate:SystemState \u0026 (true \u003d\u003e (true \u003d\u003e let old:seq of (SList_Data) \u003d SList_Seq(heap~, ptr) in ((([old(1)] ^ [data]) ^ (tl old)) \u003d SList_Seq(heap, ptr)))))","legal function application obligation:(forall list:DList_List, data:DList_Data, position:nat1, oldstate:SystemState \u0026 (((position \u003c\u003d (SList_Lengthf(heap, list) + 1)) and (Heaps_Available(heap) and DList_IsList(heap, list))) \u003d\u003e pre_SList_PtrToNode(heap, list, (position - 1))))","type compatibility obligation:(forall list:DList_List, data:DList_Data, position:nat1, oldstate:SystemState \u0026 (((position \u003c\u003d (SList_Lengthf(heap, list) + 1)) and (Heaps_Available(heap) and DList_IsList(heap, list))) \u003d\u003e ((position - 1) \u003e 0)))","legal sequence application obligation:(forall list:DList_List, data:DList_Data, position:nat1, oldstate:SystemState \u0026 (((position \u003c\u003d (SList_Lengthf(heap, list) + 1)) and (Heaps_Available(heap) and DList_IsList(heap, list))) \u003d\u003e (DList_IsList(heap, RESULT) \u003d\u003e let new:seq of (SList_Data) \u003d SList_Seq(heap, RESULT) in (forall i in set (inds new) \u0026 ((i \u003c\u003e position) \u003d\u003e (i in set (inds new)))))))","legal sequence application obligation:(forall list:DList_List, data:DList_Data, position:nat1, oldstate:SystemState \u0026 (((position \u003c\u003d (SList_Lengthf(heap, list) + 1)) and (Heaps_Available(heap) and DList_IsList(heap, list))) \u003d\u003e (DList_IsList(heap, RESULT) \u003d\u003e let new:seq of (SList_Data) \u003d SList_Seq(heap, RESULT) in ((SList_Seq(heap~, list) \u003d [new(i) | i in set (inds new) \u0026 (i \u003c\u003e position)]) \u003d\u003e (position in set (inds new))))))","operation establishes postcondition obligation:(forall list:DList_List, data:DList_Data, position:nat1, oldstate:SystemState \u0026 (((position \u003c\u003d (SList_Lengthf(heap, list) + 1)) and (Heaps_Available(heap) and DList_IsList(heap, list))) \u003d\u003e (DList_IsList(heap, RESULT) and let new:seq of (SList_Data) \u003d SList_Seq(heap, RESULT) in ((SList_Seq(heap~, list) \u003d [new(i) | i in set (inds new) \u0026 (i \u003c\u003e position)]) and (new(position) \u003d data)))))","operation call obligation:(forall list:DList_List, oldstate:SystemState \u0026 (true \u003d\u003e pre_Heaps_ModifyLoc(heap, address, mk_Heaps_Location(nil, false))))","non-empty sequence obligation:(forall list:DList_List, oldstate:SystemState \u0026 (true \u003d\u003e (true \u003d\u003e (SList_Seq(heap~, list) \u003c\u003e []))))","operation establishes postcondition obligation:(forall list:DList_List, oldstate:SystemState \u0026 (true \u003d\u003e (true \u003d\u003e ((tl SList_Seq(heap~, list)) \u003d SList_Seq(heap, RESULT)))))","operation call obligation:(forall list:DList_List, ptr:Nodes_NodePtr, oldstate:SystemState \u0026 (true \u003d\u003e (true \u003d\u003e pre_Heaps_ModifyLoc(heap, address, mk_Heaps_Location(nil, false)))))","legal sequence application obligation:(forall list:DList_List, ptr:Nodes_NodePtr, oldstate:SystemState \u0026 (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e let old:seq of (SList_Data) \u003d SList_Seq(heap~, ptr) in (1 in set (inds old))))))","non-empty sequence obligation:(forall list:DList_List, ptr:Nodes_NodePtr, oldstate:SystemState \u0026 (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e let old:seq of (SList_Data) \u003d SList_Seq(heap~, ptr) in (old \u003c\u003e [])))))","non-empty sequence obligation:(forall list:DList_List, ptr:Nodes_NodePtr, oldstate:SystemState \u0026 (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e let old:seq of (SList_Data) \u003d SList_Seq(heap~, ptr) in ((tl old) \u003c\u003e [])))))","operation establishes postcondition obligation:(forall list:DList_List, ptr:Nodes_NodePtr, oldstate:SystemState \u0026 (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e let old:seq of (SList_Data) \u003d SList_Seq(heap~, ptr) in (([old(1)] ^ (tl (tl old))) \u003d SList_Seq(heap, ptr))))))","legal function application obligation:(forall list:DList_List, position:nat1, oldstate:SystemState \u0026 (((position \u003c\u003d SList_Lengthf(heap, list)) and DList_IsList(heap, list)) \u003d\u003e pre_SList_PtrToNode(heap, list, (position - 1))))","type compatibility obligation:(forall list:DList_List, position:nat1, oldstate:SystemState \u0026 (((position \u003c\u003d SList_Lengthf(heap, list)) and DList_IsList(heap, list)) \u003d\u003e ((position - 1) \u003e 0)))","legal sequence application obligation:(forall list:DList_List, position:nat1, oldstate:SystemState \u0026 (((position \u003c\u003d SList_Lengthf(heap, list)) and DList_IsList(heap, list)) \u003d\u003e (DList_IsList(heap, RESULT) \u003d\u003e let old:seq of (SList_Data) \u003d SList_Seq(heap~, list) in (forall i in set (inds old) \u0026 ((i \u003c\u003e position) \u003d\u003e (i in set (inds old)))))))","operation establishes postcondition obligation:(forall list:DList_List, position:nat1, oldstate:SystemState \u0026 (((position \u003c\u003d SList_Lengthf(heap, list)) and DList_IsList(heap, list)) \u003d\u003e (DList_IsList(heap, RESULT) and let old:seq of (SList_Data) \u003d SList_Seq(heap~, list) in (([old(i) | i in set (inds old) \u0026 (i \u003c\u003e position)] \u003d SList_Seq(heap, RESULT)) and (Heaps_AmountUsed(heap~) \u003d (Heaps_AmountUsed(heap) + 1))))))","while loop termination obligation:NotYetImplemented","operation establishes postcondition obligation:(forall list:DList_List, data:DList_Data, oldstate:SystemState \u0026 ((Heaps_Available(heap) and DList_IsList(heap, list)) \u003d\u003e (((SList_Seq(heap~, list) ^ [data]) \u003d SList_Seq(heap, RESULT)) and (((Heaps_AmountUsed(heap~) + 1) \u003d Heaps_AmountUsed(heap)) and DList_IsList(heap, RESULT)))))","operation call obligation:(forall list:DList_List, data:DList_Data, position:nat1, oldstate:SystemState \u0026 (list \u003c\u003d SList_Lengthf(heap, list)))","type compatibility obligation:(forall queue:Queues_Queue, oldstate:SystemState \u0026 is_(RESULT, (Queues_Queue * Queues_Data)))","type compatibility obligation:(forall stack:Stacks_Stack, oldstate:SystemState \u0026 is_(RESULT, (Stacks_Stack * Stacks_Data)))","legal function application obligation:(forall tree:set of (STrees_Node) \u0026 (forall node in set tree \u0026 pre_STrees_IsRoot(tree, node)))","legal function application obligation:(forall tree:set of (STrees_Node) \u0026 (forall node in set tree \u0026 pre_STrees_IsChild(tree, node)))","legal function application obligation:(forall tree:set of (STrees_Node) \u0026 ((forall node in set tree \u0026 ((not STrees_IsRoot(tree, node)) \u003c\u003d\u003e (STrees_IsChild(tree, node) and STrees_IsUnique(tree, node)))) \u003d\u003e (forall node in set tree \u0026 pre_STrees_IsRoot(tree, node))))","type invariant satisfiable obligation:(exists tree:STrees_Tree \u0026 ((forall node in set tree \u0026 ((not STrees_IsRoot(tree, node)) \u003c\u003d\u003e (STrees_IsChild(tree, node) and STrees_IsUnique(tree, node)))) and ((tree \u003c\u003e {}) \u003c\u003d\u003e (exists1 node in set tree \u0026 STrees_IsRoot(tree, node)))))","legal function application obligation:(forall mk_STrees_Info(t, c):STrees_Info \u0026 (((c \u003d nil) \u003c\u003d\u003e (t \u003d {})) \u003d\u003e ((c in set t) \u003d\u003e pre_STrees_Root(t))))","type invariant satisfiable obligation:(exists mk_STrees_Info(t, c):STrees_Info \u0026 (((c \u003d nil) \u003c\u003d\u003e (t \u003d {})) and ((c \u003c\u003e nil) \u003c\u003d\u003e ((c in set t) and let r:STrees_Node \u003d STrees_Root(t) in ((r.position) \u003d 1)))))","type compatibility obligation:(forall tree:set of (STrees_Node) \u0026 (inv_STrees_Tree(tree) \u003d\u003e inv_STrees_Tree(tree)))","type compatibility obligation:(forall tree:STrees_Tree, current:STrees_Node \u0026 inv_STrees_Info(mk_STrees_Info(tree, current)))","type compatibility obligation:(forall tree:STrees_Tree, current:STrees_Node \u0026 (inv_STrees_Info(mk_STrees_Info(tree, current)) \u003d\u003e inv_STrees_Info(mk_STrees_Info(tree, current))))","type compatibility obligation:inv_STrees_Tree({})","type compatibility obligation:(inv_STrees_Info(mk_STrees_Info({}, nil)) and inv_STrees_Tree({}))","legal function application obligation:(forall tree:set of (STrees_Node), mk_STrees_Node(dr, pr):STrees_Node \u0026 ((mk_STrees_Node(dr, pr) in set tree) \u003d\u003e pre_STrees_IsChild(tree, mk_STrees_Node(dr, pr))))","legal function application obligation:(forall tree:STrees_Tree, node:STrees_Node \u0026 ((node in set tree) \u003d\u003e (forall child in set tree \u0026 pre_STrees_IsParentOf(tree, node, child))))","legal function application obligation:(forall tree:set of (STrees_Node), node:STrees_Node \u0026 ((node in set tree) \u003d\u003e (forall parent in set tree \u0026 pre_STrees_IsParentOf(tree, parent, node))))","legal function application obligation:(forall tree:set of (STrees_Node), node:STrees_Node \u0026 ((node in set tree) \u003d\u003e ((exists parent in set tree \u0026 STrees_IsParentOf(tree, parent, node)) \u003d\u003e (forall parent in set tree \u0026 pre_STrees_IsParentOf(tree, parent, node)))))","legal function application obligation:(forall tree:set of (STrees_Node), node1:STrees_Node, node2:STrees_Node \u0026 (((node1 in set tree) and (node2 in set tree)) \u003d\u003e pre_STrees_IsRightChildOf(tree, node2, node1)))","legal function application obligation:(forall tree:set of (STrees_Node), node1:STrees_Node, node2:STrees_Node \u0026 (((node1 in set tree) and (node2 in set tree)) \u003d\u003e ((not STrees_IsRightChildOf(tree, node2, node1)) \u003d\u003e pre_STrees_IsLeftChildOf(tree, node2, node1))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info, data:STrees_Data, direction:STrees_Direction \u0026 (((direction \u003d \u003cToRoot\u003e) \u003d\u003e (tree \u003d {})) \u003d\u003e ((direction \u003d \u003cToLeft\u003e) \u003d\u003e pre_STrees_HasLeftChild(tree, current))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info, data:STrees_Data, direction:STrees_Direction \u0026 (((direction \u003d \u003cToRoot\u003e) \u003d\u003e (tree \u003d {})) \u003d\u003e ((direction \u003d \u003cToLeft\u003e) \u003d\u003e is_(current, STrees_Node))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info, data:STrees_Data, direction:STrees_Direction \u0026 (((direction \u003d \u003cToRoot\u003e) \u003d\u003e (tree \u003d {})) \u003d\u003e (((direction \u003d \u003cToLeft\u003e) \u003d\u003e (not STrees_HasLeftChild(tree, current))) \u003d\u003e ((direction \u003d \u003cToRight\u003e) \u003d\u003e pre_STrees_HasRightChild(tree, current)))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info, data:STrees_Data, direction:STrees_Direction \u0026 (((direction \u003d \u003cToRoot\u003e) \u003d\u003e (tree \u003d {})) \u003d\u003e (((direction \u003d \u003cToLeft\u003e) \u003d\u003e (not STrees_HasLeftChild(tree, current))) \u003d\u003e ((direction \u003d \u003cToRight\u003e) \u003d\u003e is_(current, STrees_Node)))))","function establishes postcondition obligation:(forall mk_STrees_Info(tree, current):STrees_Info, data:STrees_Data, direction:STrees_Direction \u0026 (pre_STrees_Insert(mk_STrees_Info(tree, current), data, direction) \u003d\u003e post_STrees_Insert(mk_STrees_Info(tree, current), data, direction, (cases mk_(current, direction) :\nmk_(nil, \u003cToRoot\u003e) -\u003e STrees_InsertRoot(data),\nmk_(-, \u003cToLeft\u003e) -\u003e STrees_InsertLeft(tree, current, data),\nmk_(-, \u003cToRight\u003e) -\u003e STrees_InsertRight(tree, current, data)\n end))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info, data:STrees_Data, direction:STrees_Direction \u0026 ((((direction \u003d \u003cToRoot\u003e) \u003d\u003e (tree \u003d {})) and (((direction \u003d \u003cToLeft\u003e) \u003d\u003e (not STrees_HasLeftChild(tree, current))) and ((direction \u003d \u003cToRight\u003e) \u003d\u003e (not STrees_HasRightChild(tree, current))))) \u003d\u003e ((not (mk_(nil, \u003cToRoot\u003e) \u003d mk_(current, direction))) \u003d\u003e (exists mk_(-, \u003cToLeft\u003e):([STrees_Node] * STrees_Direction) \u0026 ((mk_(any1, \u003cToLeft\u003e) \u003d mk_(current, direction)) \u003d\u003e let mk_(-, \u003cToLeft\u003e) \u003d mk_(current, direction) in pre_STrees_InsertLeft(tree, current, data))))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info, data:STrees_Data, direction:STrees_Direction \u0026 ((((direction \u003d \u003cToRoot\u003e) \u003d\u003e (tree \u003d {})) and (((direction \u003d \u003cToLeft\u003e) \u003d\u003e (not STrees_HasLeftChild(tree, current))) and ((direction \u003d \u003cToRight\u003e) \u003d\u003e (not STrees_HasRightChild(tree, current))))) \u003d\u003e ((not (mk_(nil, \u003cToRoot\u003e) \u003d mk_(current, direction))) \u003d\u003e (exists mk_(-, \u003cToLeft\u003e):([STrees_Node] * STrees_Direction) \u0026 ((mk_(any1, \u003cToLeft\u003e) \u003d mk_(current, direction)) \u003d\u003e let mk_(-, \u003cToLeft\u003e) \u003d mk_(current, direction) in is_(current, STrees_Node))))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info, data:STrees_Data, direction:STrees_Direction \u0026 ((((direction \u003d \u003cToRoot\u003e) \u003d\u003e (tree \u003d {})) and (((direction \u003d \u003cToLeft\u003e) \u003d\u003e (not STrees_HasLeftChild(tree, current))) and ((direction \u003d \u003cToRight\u003e) \u003d\u003e (not STrees_HasRightChild(tree, current))))) \u003d\u003e ((not (mk_(nil, \u003cToRoot\u003e) \u003d mk_(current, direction))) \u003d\u003e ((not (exists mk_(-, \u003cToLeft\u003e):([STrees_Node] * STrees_Direction) \u0026 (mk_(any1, \u003cToLeft\u003e) \u003d mk_(current, direction)))) \u003d\u003e (exists mk_(-, \u003cToRight\u003e):([STrees_Node] * STrees_Direction) \u0026 ((mk_(any1, \u003cToRight\u003e) \u003d mk_(current, direction)) \u003d\u003e let mk_(-, \u003cToRight\u003e) \u003d mk_(current, direction) in pre_STrees_InsertRight(tree, current, data)))))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info, data:STrees_Data, direction:STrees_Direction \u0026 ((((direction \u003d \u003cToRoot\u003e) \u003d\u003e (tree \u003d {})) and (((direction \u003d \u003cToLeft\u003e) \u003d\u003e (not STrees_HasLeftChild(tree, current))) and ((direction \u003d \u003cToRight\u003e) \u003d\u003e (not STrees_HasRightChild(tree, current))))) \u003d\u003e ((not (mk_(nil, \u003cToRoot\u003e) \u003d mk_(current, direction))) \u003d\u003e ((not (exists mk_(-, \u003cToLeft\u003e):([STrees_Node] * STrees_Direction) \u0026 (mk_(any1, \u003cToLeft\u003e) \u003d mk_(current, direction)))) \u003d\u003e (exists mk_(-, \u003cToRight\u003e):([STrees_Node] * STrees_Direction) \u0026 ((mk_(any1, \u003cToRight\u003e) \u003d mk_(current, direction)) \u003d\u003e let mk_(-, \u003cToRight\u003e) \u003d mk_(current, direction) in is_(current, STrees_Node)))))))","cases exhaustive obligation:(forall mk_STrees_Info(tree, current):STrees_Info, data:STrees_Data, direction:STrees_Direction \u0026 ((((direction \u003d \u003cToRoot\u003e) \u003d\u003e (tree \u003d {})) and (((direction \u003d \u003cToLeft\u003e) \u003d\u003e (not STrees_HasLeftChild(tree, current))) and ((direction \u003d \u003cToRight\u003e) \u003d\u003e (not STrees_HasRightChild(tree, current))))) \u003d\u003e (((mk_(current, direction) \u003d mk_(nil, \u003cToRoot\u003e)) or (exists mk_(-, \u003cToLeft\u003e):([STrees_Node] * STrees_Direction) \u0026 (mk_(current, direction) \u003d mk_(any1, \u003cToLeft\u003e)))) or (exists mk_(-, \u003cToRight\u003e):([STrees_Node] * STrees_Direction) \u0026 (mk_(current, direction) \u003d mk_(any1, \u003cToRight\u003e))))))","type compatibility obligation:(forall data:STrees_Data \u0026 let root:STrees_Node \u003d mk_STrees_Node(data, 1) in inv_STrees_Tree({root}))","type compatibility obligation:(forall data:STrees_Data \u0026 let root:STrees_Node \u003d mk_STrees_Node(data, 1) in (inv_STrees_Info(mk_STrees_Info({root}, root)) and inv_STrees_Tree({root})))","legal function application obligation:(forall tree:STrees_Tree, current:STrees_Node, data:STrees_Data \u0026 pre_STrees_HasLeftChild(tree, current))","type compatibility obligation:(forall tree:STrees_Tree, current:STrees_Node, data:STrees_Data \u0026 ((not STrees_HasLeftChild(tree, current)) \u003d\u003e let mk_STrees_Node(-, position):STrees_Node \u003d current in let new:STrees_Node \u003d mk_STrees_Node(data, (2 * position)) in inv_STrees_Tree((tree union {new}))))","type compatibility obligation:(forall tree:STrees_Tree, current:STrees_Node, data:STrees_Data \u0026 ((not STrees_HasLeftChild(tree, current)) \u003d\u003e let mk_STrees_Node(-, position):STrees_Node \u003d current in let new:STrees_Node \u003d mk_STrees_Node(data, (2 * position)) in (inv_STrees_Info(mk_STrees_Info((tree union {new}), new)) and inv_STrees_Tree((tree union {new})))))","legal function application obligation:(forall tree:STrees_Tree, current:STrees_Node, data:STrees_Data \u0026 pre_STrees_HasRightChild(tree, current))","type compatibility obligation:(forall tree:STrees_Tree, current:STrees_Node, data:STrees_Data \u0026 ((not STrees_HasRightChild(tree, current)) \u003d\u003e let mk_STrees_Node(-, position):STrees_Node \u003d current in let new:STrees_Node \u003d mk_STrees_Node(data, ((2 * position) + 1)) in inv_STrees_Tree((tree union {new}))))","type compatibility obligation:(forall tree:STrees_Tree, current:STrees_Node, data:STrees_Data \u0026 ((not STrees_HasRightChild(tree, current)) \u003d\u003e let mk_STrees_Node(-, position):STrees_Node \u003d current in let new:STrees_Node \u003d mk_STrees_Node(data, ((2 * position) + 1)) in (inv_STrees_Info(mk_STrees_Info((tree union {new}), new)) and inv_STrees_Tree((tree union {new})))))","legal function application obligation:(forall treeinfo:STrees_Info, traversal:(STrees_Data -\u003e STrees_Data) \u0026 let mk_STrees_Info(tree, current):STrees_Info \u003d treeinfo in ((current \u003c\u003e nil) \u003d\u003e let mk_STrees_Node(data, position):[STrees_Node] \u003d current in (forall mk_STrees_Node(data, position) in set tree \u0026 pre_(traversaldata))))","legal function application obligation:(forall treeinfo:STrees_Info, traversal:(STrees_Data -\u003e STrees_Data) \u0026 let mk_STrees_Info(tree, current):STrees_Info \u003d treeinfo in ((current \u003c\u003e nil) \u003d\u003e let mk_STrees_Node(data, position):[STrees_Node] \u003d current in let newtree:set of (STrees_Node) \u003d {mk_STrees_Node(traversal(data), position) | mk_STrees_Node(data, position) in set tree} in pre_(traversaldata)))","type compatibility obligation:(forall treeinfo:STrees_Info, traversal:(STrees_Data -\u003e STrees_Data) \u0026 let mk_STrees_Info(tree, current):STrees_Info \u003d treeinfo in ((current \u003c\u003e nil) \u003d\u003e let mk_STrees_Node(data, position):[STrees_Node] \u003d current in let newtree:set of (STrees_Node) \u003d {mk_STrees_Node(traversal(data), position) | mk_STrees_Node(data, position) in set tree} in inv_STrees_Tree(newtree)))","type compatibility obligation:(forall treeinfo:STrees_Info, traversal:(STrees_Data -\u003e STrees_Data) \u0026 let mk_STrees_Info(tree, current):STrees_Info \u003d treeinfo in ((current \u003c\u003e nil) \u003d\u003e let mk_STrees_Node(data, position):[STrees_Node] \u003d current in let newtree:set of (STrees_Node) \u003d {mk_STrees_Node(traversal(data), position) | mk_STrees_Node(data, position) in set tree} in (inv_STrees_Info(mk_STrees_Info(newtree, mk_STrees_Node(traversal(data), position))) and inv_STrees_Tree(newtree))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info, direction:STrees_Direction \u0026 inv_STrees_Info(mk_STrees_Info(tree, current)))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info, direction:STrees_Direction \u0026 (STrees_ExistsDirection(mk_STrees_Info(tree, current), direction) \u003d\u003e ((\u003cToRoot\u003e \u003d direction) \u003d\u003e pre_STrees_Root(tree))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info, direction:STrees_Direction \u0026 (STrees_ExistsDirection(mk_STrees_Info(tree, current), direction) \u003d\u003e ((\u003cToRoot\u003e \u003d direction) \u003d\u003e inv_STrees_Info(mk_STrees_Info(tree, STrees_Root(tree))))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info, direction:STrees_Direction \u0026 (STrees_ExistsDirection(mk_STrees_Info(tree, current), direction) \u003d\u003e ((not (\u003cToRoot\u003e \u003d direction)) \u003d\u003e ((\u003cToLeft\u003e \u003d direction) \u003d\u003e pre_STrees_LeftChild(tree, current)))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info, direction:STrees_Direction \u0026 (STrees_ExistsDirection(mk_STrees_Info(tree, current), direction) \u003d\u003e ((not (\u003cToRoot\u003e \u003d direction)) \u003d\u003e ((\u003cToLeft\u003e \u003d direction) \u003d\u003e is_(current, STrees_Node)))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info, direction:STrees_Direction \u0026 (STrees_ExistsDirection(mk_STrees_Info(tree, current), direction) \u003d\u003e ((not (\u003cToRoot\u003e \u003d direction)) \u003d\u003e ((\u003cToLeft\u003e \u003d direction) \u003d\u003e inv_STrees_Info(mk_STrees_Info(tree, STrees_LeftChild(tree, current)))))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info, direction:STrees_Direction \u0026 (STrees_ExistsDirection(mk_STrees_Info(tree, current), direction) \u003d\u003e ((not (\u003cToRoot\u003e \u003d direction)) \u003d\u003e ((not (\u003cToLeft\u003e \u003d direction)) \u003d\u003e ((\u003cToRight\u003e \u003d direction) \u003d\u003e pre_STrees_RightChild(tree, current))))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info, direction:STrees_Direction \u0026 (STrees_ExistsDirection(mk_STrees_Info(tree, current), direction) \u003d\u003e ((not (\u003cToRoot\u003e \u003d direction)) \u003d\u003e ((not (\u003cToLeft\u003e \u003d direction)) \u003d\u003e ((\u003cToRight\u003e \u003d direction) \u003d\u003e is_(current, STrees_Node))))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info, direction:STrees_Direction \u0026 (STrees_ExistsDirection(mk_STrees_Info(tree, current), direction) \u003d\u003e ((not (\u003cToRoot\u003e \u003d direction)) \u003d\u003e ((not (\u003cToLeft\u003e \u003d direction)) \u003d\u003e ((\u003cToRight\u003e \u003d direction) \u003d\u003e inv_STrees_Info(mk_STrees_Info(tree, STrees_RightChild(tree, current))))))))","cases exhaustive obligation:(forall mk_STrees_Info(tree, current):STrees_Info, direction:STrees_Direction \u0026 (STrees_ExistsDirection(mk_STrees_Info(tree, current), direction) \u003d\u003e (((direction \u003d \u003cToRoot\u003e) or (direction \u003d \u003cToLeft\u003e)) or (direction \u003d \u003cToRight\u003e))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info, position:nat1 \u0026 inv_STrees_Info(mk_STrees_Info(tree, current)))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info, position:nat1 \u0026 (STrees_ExistsNode(mk_STrees_Info(tree, current), position) \u003d\u003e pre_STrees_GetNode(tree, position)))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info, position:nat1 \u0026 (STrees_ExistsNode(mk_STrees_Info(tree, current), position) \u003d\u003e inv_STrees_Info(mk_STrees_Info(tree, STrees_GetNode(tree, position)))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 pre_STrees_IsRoot(tree, current))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 is_(current, STrees_Node))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((not STrees_IsRoot(tree, current)) \u003d\u003e pre_STrees_Parent(tree, current)))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((not STrees_IsRoot(tree, current)) \u003d\u003e is_(current, STrees_Node)))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((not STrees_IsRoot(tree, current)) \u003d\u003e inv_STrees_Info(mk_STrees_Info(tree, STrees_Parent(tree, current)))))","legal function application obligation:(forall treeinfo:STrees_Info, pathlength:nat1 \u0026 (pre_STrees_MoveToParent(treeinfo) \u003d\u003e ((pathlength \u003e 1) \u003d\u003e pre_STrees_MoveToAnscestor(STrees_MoveToParent(treeinfo), (pathlength - 1)))))","type compatibility obligation:(forall treeinfo:STrees_Info, pathlength:nat1 \u0026 (pre_STrees_MoveToParent(treeinfo) \u003d\u003e ((pathlength \u003e 1) \u003d\u003e ((pathlength - 1) \u003e 0))))","legal function application obligation:(forall treeinfo:STrees_Info, pathlength:nat1 \u0026 (pre_STrees_MoveToParent(treeinfo) \u003d\u003e ((pathlength \u003e 1) \u003d\u003e pre_STrees_MoveToParent(treeinfo))))","legal function application obligation:(forall treeinfo:STrees_Info, pathlength:nat1 \u0026 (pre_STrees_MoveToParent(treeinfo) \u003d\u003e ((not (pathlength \u003e 1)) \u003d\u003e pre_STrees_MoveToParent(treeinfo))))","unique existence binding obligation:(forall tree:STrees_Tree \u0026 ((tree \u003c\u003e {}) \u003d\u003e (exists1 root in set tree \u0026 STrees_IsRoot(tree, root))))","legal function application obligation:(forall tree:STrees_Tree \u0026 ((tree \u003c\u003e {}) \u003d\u003e (forall root in set tree \u0026 pre_STrees_IsRoot(tree, root))))","legal function application obligation:(forall tree:STrees_Tree, node:STrees_Node \u0026 ((node in set tree) \u003d\u003e pre_STrees_IsRoot(tree, node)))","unique existence binding obligation:(forall tree:STrees_Tree, node:STrees_Node \u0026 (((node in set tree) and (not STrees_IsRoot(tree, node))) \u003d\u003e (exists1 parent in set tree \u0026 STrees_IsParentOf(tree, parent, node))))","legal function application obligation:(forall tree:STrees_Tree, node:STrees_Node \u0026 (((node in set tree) and (not STrees_IsRoot(tree, node))) \u003d\u003e (forall parent in set tree \u0026 pre_STrees_IsParentOf(tree, parent, node))))","legal function application obligation:(forall tree:STrees_Tree, parent:STrees_Node \u0026 ((parent in set tree) \u003d\u003e pre_STrees_HasLeftChild(tree, parent)))","unique existence binding obligation:(forall tree:STrees_Tree, parent:STrees_Node \u0026 (((parent in set tree) and STrees_HasLeftChild(tree, parent)) \u003d\u003e (exists1 leftchild in set tree \u0026 STrees_IsLeftChildOf(tree, leftchild, parent))))","legal function application obligation:(forall tree:STrees_Tree, parent:STrees_Node \u0026 (((parent in set tree) and STrees_HasLeftChild(tree, parent)) \u003d\u003e (forall leftchild in set tree \u0026 pre_STrees_IsLeftChildOf(tree, leftchild, parent))))","legal function application obligation:(forall tree:STrees_Tree, parent:STrees_Node \u0026 ((parent in set tree) \u003d\u003e pre_STrees_HasRightChild(tree, parent)))","unique existence binding obligation:(forall tree:STrees_Tree, parent:STrees_Node \u0026 (((parent in set tree) and STrees_HasRightChild(tree, parent)) \u003d\u003e (exists1 rightchild in set tree \u0026 STrees_IsRightChildOf(tree, rightchild, parent))))","legal function application obligation:(forall tree:STrees_Tree, parent:STrees_Node \u0026 (((parent in set tree) and STrees_HasRightChild(tree, parent)) \u003d\u003e (forall rightchild in set tree \u0026 pre_STrees_IsRightChildOf(tree, rightchild, parent))))","unique existence binding obligation:(forall tree:STrees_Tree, position:nat1 \u0026 ((exists node in set tree \u0026 ((node.position) \u003d position)) \u003d\u003e (exists1 node in set tree \u0026 ((node.position) \u003d position))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info, position:nat1 \u0026 inv_STrees_Info(mk_STrees_Info(tree, current)))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info, position:nat1 \u0026 (STrees_ExistsNode(mk_STrees_Info(tree, current), position) \u003d\u003e pre_STrees_GetNode(tree, position)))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info, data:STrees_Data \u0026 ((current \u003c\u003e nil) \u003d\u003e let mk_STrees_Node(-, position):[STrees_Node] \u003d current in let newcurrent:STrees_Node \u003d mk_STrees_Node(data, position) in inv_STrees_Tree(((tree \\ {current}) union {newcurrent}))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info, data:STrees_Data \u0026 ((current \u003c\u003e nil) \u003d\u003e let mk_STrees_Node(-, position):[STrees_Node] \u003d current in let newcurrent:STrees_Node \u003d mk_STrees_Node(data, position) in (inv_STrees_Info(mk_STrees_Info(((tree \\ {current}) union {newcurrent}), newcurrent)) and inv_STrees_Tree(((tree \\ {current}) union {newcurrent})))))","type compatibility obligation:(forall mk_STrees_Info(-, current):STrees_Info \u0026 is_(current, STrees_Node))","type compatibility obligation:(forall mk_STrees_Info(tree, -):STrees_Info, newcurrent:STrees_Node \u0026 ((newcurrent in set tree) \u003d\u003e inv_STrees_Info(mk_STrees_Info(tree, newcurrent))))","legal function application obligation:(forall tree:STrees_Tree, parent:STrees_Node \u0026 ((parent in set tree) \u003d\u003e (forall child in set tree \u0026 pre_STrees_IsLeftChildOf(tree, child, parent))))","legal function application obligation:(forall tree:STrees_Tree, parent:STrees_Node \u0026 ((parent in set tree) \u003d\u003e (forall child in set tree \u0026 pre_STrees_IsRightChildOf(tree, child, parent))))","legal function application obligation:(forall tree:STrees_Tree, node:STrees_Node \u0026 ((node in set tree) \u003d\u003e pre_STrees_HasLeftChild(tree, node)))","legal function application obligation:(forall tree:STrees_Tree, node:STrees_Node \u0026 (((node in set tree) and STrees_HasLeftChild(tree, node)) \u003d\u003e pre_STrees_LeftChild(tree, node)))","legal function application obligation:(forall tree:STrees_Tree, node:STrees_Node \u0026 (((node in set tree) and STrees_HasLeftChild(tree, node)) \u003d\u003e let leftchild:STrees_Node \u003d STrees_LeftChild(tree, node) in pre_STrees_Subtree(tree, leftchild)))","unique existence binding obligation:(forall tree:STrees_Tree, node:STrees_Node \u0026 (((node in set tree) and STrees_HasLeftChild(tree, node)) \u003d\u003e let leftchild:STrees_Node \u003d STrees_LeftChild(tree, node) in let left:STrees_Tree \u003d STrees_Subtree(tree, leftchild) in let rightpath:set of (STrees_Node) \u003d {n | n in set left \u0026 (exists p in set {0, ... ,(card left)} \u0026 ((n.position) \u003d ((((leftchild.position) + 1) * (2 ** p)) - 1)))} in (exists1 pred in set rightpath \u0026 (forall n in set rightpath \u0026 ((n.position) \u003c\u003d (pred.position))))))","function establishes postcondition obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 (pre_STrees_Delete(mk_STrees_Info(tree, current)) \u003d\u003e post_STrees_Delete(mk_STrees_Info(tree, current), let old:STrees_Tree \u003d STrees_Subtree(tree, current) in (if (STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current))\nthen let leftchild:STrees_Node \u003d STrees_LeftChild(tree, current), rightchild:STrees_Node \u003d STrees_RightChild(tree, current), left:STrees_Tree \u003d STrees_Subtree(old, leftchild), mk_STrees_Node(-, position):STrees_Node \u003d STrees_InOrderPredecessor(old, current), newright:STrees_Tree \u003d STrees_MoveSubtree(old, rightchild, ((2 * position) + 1)), newleft:STrees_Tree \u003d (left union newright), new:STrees_Tree \u003d STrees_MoveSubtree(newleft, STrees_Root(newleft), (current.position)) in mk_STrees_Info(((tree \\ old) union new), STrees_Root(new))\nelseif STrees_HasLeftChild(tree, current)\nthen let leftchild:STrees_Node \u003d STrees_LeftChild(tree, current), new:STrees_Tree \u003d STrees_MoveSubtree(old, leftchild, (current.position)) in mk_STrees_Info(((tree \\ old) union new), STrees_Root(new))\nelseif STrees_HasRightChild(tree, current)\nthen let rightchild:STrees_Node \u003d STrees_RightChild(tree, current), new:STrees_Tree \u003d STrees_MoveSubtree(old, rightchild, (current.position)) in mk_STrees_Info(((tree \\ old) union new), STrees_Root(new))\nelse mk_STrees_Info((tree \\ {current}), STrees_Parent(tree, current))))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e pre_STrees_Subtree(tree, current)))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e is_(current, STrees_Node)))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in pre_STrees_HasRightChild(tree, current)))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in is_(current, STrees_Node)))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in (STrees_HasRightChild(tree, current) \u003d\u003e pre_STrees_HasLeftChild(tree, current))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in (STrees_HasRightChild(tree, current) \u003d\u003e is_(current, STrees_Node))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current)) \u003d\u003e pre_STrees_LeftChild(tree, current))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current)) \u003d\u003e is_(current, STrees_Node))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current)) \u003d\u003e pre_STrees_RightChild(tree, current))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current)) \u003d\u003e is_(current, STrees_Node))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current)) \u003d\u003e pre_STrees_Subtree(old, leftchild))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current)) \u003d\u003e pre_STrees_InOrderPredecessor(old, current))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current)) \u003d\u003e is_(current, STrees_Node))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current)) \u003d\u003e pre_STrees_MoveSubtree(old, rightchild, ((2 * position) + 1)))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current)) \u003d\u003e pre_STrees_MoveSubtree(newleft, STrees_Root(newleft), (current.position)))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current)) \u003d\u003e pre_STrees_Root(newleft))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current)) \u003d\u003e let leftchild:STrees_Node \u003d STrees_LeftChild(tree, current), rightchild:STrees_Node \u003d STrees_RightChild(tree, current), left:STrees_Tree \u003d STrees_Subtree(old, leftchild), mk_STrees_Node(-, position):STrees_Node \u003d STrees_InOrderPredecessor(old, current), newright:STrees_Tree \u003d STrees_MoveSubtree(old, rightchild, ((2 * position) + 1)), newleft:STrees_Tree \u003d (left union newright), new:STrees_Tree \u003d STrees_MoveSubtree(newleft, STrees_Root(newleft), (current.position)) in pre_STrees_Root(new))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current)) \u003d\u003e let leftchild:STrees_Node \u003d STrees_LeftChild(tree, current), rightchild:STrees_Node \u003d STrees_RightChild(tree, current), left:STrees_Tree \u003d STrees_Subtree(old, leftchild), mk_STrees_Node(-, position):STrees_Node \u003d STrees_InOrderPredecessor(old, current), newright:STrees_Tree \u003d STrees_MoveSubtree(old, rightchild, ((2 * position) + 1)), newleft:STrees_Tree \u003d (left union newright), new:STrees_Tree \u003d STrees_MoveSubtree(newleft, STrees_Root(newleft), (current.position)) in inv_STrees_Info(mk_STrees_Info(((tree \\ old) union new), STrees_Root(new))))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((not (STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current))) \u003d\u003e (STrees_HasLeftChild(tree, current) \u003d\u003e pre_STrees_LeftChild(tree, current)))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((not (STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current))) \u003d\u003e (STrees_HasLeftChild(tree, current) \u003d\u003e is_(current, STrees_Node)))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((not (STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current))) \u003d\u003e (STrees_HasLeftChild(tree, current) \u003d\u003e pre_STrees_MoveSubtree(old, leftchild, (current.position))))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((not (STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current))) \u003d\u003e (STrees_HasLeftChild(tree, current) \u003d\u003e let leftchild:STrees_Node \u003d STrees_LeftChild(tree, current), new:STrees_Tree \u003d STrees_MoveSubtree(old, leftchild, (current.position)) in pre_STrees_Root(new)))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((not (STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current))) \u003d\u003e (STrees_HasLeftChild(tree, current) \u003d\u003e let leftchild:STrees_Node \u003d STrees_LeftChild(tree, current), new:STrees_Tree \u003d STrees_MoveSubtree(old, leftchild, (current.position)) in inv_STrees_Info(mk_STrees_Info(((tree \\ old) union new), STrees_Root(new)))))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((not (STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current))) \u003d\u003e ((not STrees_HasLeftChild(tree, current)) \u003d\u003e (STrees_HasRightChild(tree, current) \u003d\u003e pre_STrees_RightChild(tree, current))))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((not (STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current))) \u003d\u003e ((not STrees_HasLeftChild(tree, current)) \u003d\u003e (STrees_HasRightChild(tree, current) \u003d\u003e is_(current, STrees_Node))))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((not (STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current))) \u003d\u003e ((not STrees_HasLeftChild(tree, current)) \u003d\u003e (STrees_HasRightChild(tree, current) \u003d\u003e pre_STrees_MoveSubtree(old, rightchild, (current.position)))))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((not (STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current))) \u003d\u003e ((not STrees_HasLeftChild(tree, current)) \u003d\u003e (STrees_HasRightChild(tree, current) \u003d\u003e let rightchild:STrees_Node \u003d STrees_RightChild(tree, current), new:STrees_Tree \u003d STrees_MoveSubtree(old, rightchild, (current.position)) in pre_STrees_Root(new))))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((not (STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current))) \u003d\u003e ((not STrees_HasLeftChild(tree, current)) \u003d\u003e (STrees_HasRightChild(tree, current) \u003d\u003e let rightchild:STrees_Node \u003d STrees_RightChild(tree, current), new:STrees_Tree \u003d STrees_MoveSubtree(old, rightchild, (current.position)) in inv_STrees_Info(mk_STrees_Info(((tree \\ old) union new), STrees_Root(new))))))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((not (STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current))) \u003d\u003e ((not STrees_HasLeftChild(tree, current)) \u003d\u003e ((not STrees_HasRightChild(tree, current)) \u003d\u003e pre_STrees_Parent(tree, current))))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((not (STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current))) \u003d\u003e ((not STrees_HasLeftChild(tree, current)) \u003d\u003e ((not STrees_HasRightChild(tree, current)) \u003d\u003e is_(current, STrees_Node))))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((not (STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current))) \u003d\u003e ((not STrees_HasLeftChild(tree, current)) \u003d\u003e ((not STrees_HasRightChild(tree, current)) \u003d\u003e inv_STrees_Info(mk_STrees_Info((tree \\ {current}), STrees_Parent(tree, current))))))))","type compatibility obligation:(forall tree:STrees_Tree, mk_STrees_Node(rootdata, rootpos):STrees_Node \u0026 ((mk_STrees_Node(rootdata, rootpos) in set tree) \u003d\u003e inv_STrees_Tree({mk_STrees_Node(d, p) | mk_STrees_Node(d, p) in set tree \u0026 (exists1 n in set {0, ... ,(card tree)} \u0026 ((p \u003e\u003d (rootpos * (2 ** n))) and (p \u003c ((rootpos + 1) * (2 ** n)))))})))","legal function application obligation:(forall tree:STrees_Tree, subtreeRoot:STrees_Node, newRootPos:nat1 \u0026 ((subtreeRoot in set tree) \u003d\u003e pre_STrees_Subtree(tree, subtreeRoot)))","type compatibility obligation:(forall tree:STrees_Tree, subtreeRoot:STrees_Node, newRootPos:nat1 \u0026 ((subtreeRoot in set tree) \u003d\u003e inv_STrees_Tree(let subtree:STrees_Tree \u003d STrees_Subtree(tree, subtreeRoot), mk_STrees_Node(-, oldRootPos):STrees_Node \u003d subtreeRoot in {STrees_MoveNode(tree, node, oldRootPos, newRootPos) | node in set subtree})))","unique existence binding obligation:(forall tree:STrees_Tree, mk_STrees_Node(d, p):STrees_Node, oldRootPos:nat1, newRootPos:nat1 \u0026 (exists1 n in set {0, ... ,(card tree)} \u0026 ((p \u003e\u003d (oldRootPos * (2 ** n))) and (p \u003c ((oldRootPos + 1) * (2 ** n))))))","type compatibility obligation:(forall tree:STrees_Tree, mk_STrees_Node(d, p):STrees_Node, oldRootPos:nat1, newRootPos:nat1 \u0026 let n:nat \u003d (iota n in set {0, ... ,(card tree)} \u0026 ((p \u003e\u003d (oldRootPos * (2 ** n))) and (p \u003c ((oldRootPos + 1) * (2 ** n))))) in ((((newRootPos * (2 ** n)) + p) - (oldRootPos * (2 ** n))) \u003e 0))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info, direction:STrees_Direction \u0026 ((not (\u003cToRoot\u003e \u003d direction)) \u003d\u003e ((\u003cToLeft\u003e \u003d direction) \u003d\u003e ((current \u003c\u003e nil) \u003d\u003e pre_STrees_HasLeftChild(tree, current)))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info, direction:STrees_Direction \u0026 ((not (\u003cToRoot\u003e \u003d direction)) \u003d\u003e ((\u003cToLeft\u003e \u003d direction) \u003d\u003e ((current \u003c\u003e nil) \u003d\u003e is_(current, STrees_Node)))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info, direction:STrees_Direction \u0026 ((not (\u003cToRoot\u003e \u003d direction)) \u003d\u003e ((not (\u003cToLeft\u003e \u003d direction)) \u003d\u003e ((\u003cToRight\u003e \u003d direction) \u003d\u003e ((current \u003c\u003e nil) \u003d\u003e pre_STrees_HasRightChild(tree, current))))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info, direction:STrees_Direction \u0026 ((not (\u003cToRoot\u003e \u003d direction)) \u003d\u003e ((not (\u003cToLeft\u003e \u003d direction)) \u003d\u003e ((\u003cToRight\u003e \u003d direction) \u003d\u003e ((current \u003c\u003e nil) \u003d\u003e is_(current, STrees_Node))))))","cases exhaustive obligation:(forall mk_STrees_Info(tree, current):STrees_Info, direction:STrees_Direction \u0026 (((direction \u003d \u003cToRoot\u003e) or (direction \u003d \u003cToLeft\u003e)) or (direction \u003d \u003cToRight\u003e)))","legal function application obligation:(forall heap:Heaps_Heap, child:Nodes_NodePtr \u0026 ((child \u003c\u003e NIL) \u003d\u003e pre_Nodes_GetParent(Heaps_Retrieve(heap, child))))","type compatibility obligation:(forall heap:Heaps_Heap, child:Nodes_NodePtr \u0026 ((child \u003c\u003e NIL) \u003d\u003e ((is_(Heaps_Retrieve(heap, child), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, child), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, child), Nodes_SingleLink))))","legal function application obligation:(forall heap:Heaps_Heap, child:Nodes_NodePtr \u0026 ((child \u003c\u003e NIL) \u003d\u003e pre_Heaps_Retrieve(heap, child)))","legal function application obligation:(forall heap:Heaps_Heap, child:Nodes_NodePtr \u0026 ((child \u003c\u003e NIL) \u003d\u003e let parent:Nodes_NodePtr \u003d Nodes_GetParent(Heaps_Retrieve(heap, child)) in ((not (parent \u003d NIL)) \u003d\u003e (Trees_IsRightChildOf(heap, child, parent) \u003d\u003e pre_Trees_Position(heap, parent)))))","legal function application obligation:(forall heap:Heaps_Heap, child:Nodes_NodePtr \u0026 ((child \u003c\u003e NIL) \u003d\u003e let parent:Nodes_NodePtr \u003d Nodes_GetParent(Heaps_Retrieve(heap, child)) in ((not (parent \u003d NIL)) \u003d\u003e ((not Trees_IsRightChildOf(heap, child, parent)) \u003d\u003e pre_Trees_Position(heap, parent)))))","legal function application obligation:(forall heap:Heaps_Heap, mk_Trees_Tree(treePtr, current):Trees_Tree \u0026 ((treePtr \u003c\u003e NIL) \u003d\u003e pre_STrees_MkTree(Trees_SubtreeToSet(heap, treePtr, 1))))","legal function application obligation:(forall heap:Heaps_Heap, mk_Trees_Tree(treePtr, current):Trees_Tree \u0026 ((treePtr \u003c\u003e NIL) \u003d\u003e let treeset:STrees_Tree \u003d STrees_MkTree(Trees_SubtreeToSet(heap, treePtr, 1)) in pre_Nodes_GetData(Heaps_Retrieve(heap, current))))","type compatibility obligation:(forall heap:Heaps_Heap, mk_Trees_Tree(treePtr, current):Trees_Tree \u0026 ((treePtr \u003c\u003e NIL) \u003d\u003e let treeset:STrees_Tree \u003d STrees_MkTree(Trees_SubtreeToSet(heap, treePtr, 1)) in ((is_(Heaps_Retrieve(heap, current), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, current), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, current), Nodes_SingleLink))))","legal function application obligation:(forall heap:Heaps_Heap, mk_Trees_Tree(treePtr, current):Trees_Tree \u0026 ((treePtr \u003c\u003e NIL) \u003d\u003e let treeset:STrees_Tree \u003d STrees_MkTree(Trees_SubtreeToSet(heap, treePtr, 1)) in pre_Heaps_Retrieve(heap, current)))","legal function application obligation:(forall heap:Heaps_Heap, mk_Trees_Tree(treePtr, current):Trees_Tree \u0026 ((treePtr \u003c\u003e NIL) \u003d\u003e let treeset:STrees_Tree \u003d STrees_MkTree(Trees_SubtreeToSet(heap, treePtr, 1)) in let data:Nodes_Data \u003d Nodes_GetData(Heaps_Retrieve(heap, current)) in pre_Trees_Position(heap, current)))","legal function application obligation:(forall heap:Heaps_Heap, mk_Trees_Tree(treePtr, current):Trees_Tree \u0026 ((treePtr \u003c\u003e NIL) \u003d\u003e let treeset:STrees_Tree \u003d STrees_MkTree(Trees_SubtreeToSet(heap, treePtr, 1)) in let data:Nodes_Data \u003d Nodes_GetData(Heaps_Retrieve(heap, current)) in let position:nat1 \u003d Trees_Position(heap, current) in let currentnode:STrees_Node \u003d STrees_MkNode(data, position) in pre_STrees_MkInfo(treeset, currentnode)))","legal function application obligation:(forall heap:Heaps_Heap, subtree:Nodes_NodePtr, position:nat1 \u0026 ((subtree \u003c\u003e NIL) \u003d\u003e pre_Nodes_GetData(Heaps_Retrieve(heap, subtree))))","type compatibility obligation:(forall heap:Heaps_Heap, subtree:Nodes_NodePtr, position:nat1 \u0026 ((subtree \u003c\u003e NIL) \u003d\u003e ((is_(Heaps_Retrieve(heap, subtree), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, subtree), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, subtree), Nodes_SingleLink))))","legal function application obligation:(forall heap:Heaps_Heap, subtree:Nodes_NodePtr, position:nat1 \u0026 ((subtree \u003c\u003e NIL) \u003d\u003e pre_Heaps_Retrieve(heap, subtree)))","legal function application obligation:(forall heap:Heaps_Heap, subtree:Nodes_NodePtr, position:nat1 \u0026 ((subtree \u003c\u003e NIL) \u003d\u003e pre_Nodes_GetLeft(Heaps_Retrieve(heap, subtree))))","type compatibility obligation:(forall heap:Heaps_Heap, subtree:Nodes_NodePtr, position:nat1 \u0026 ((subtree \u003c\u003e NIL) \u003d\u003e ((is_(Heaps_Retrieve(heap, subtree), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, subtree), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, subtree), Nodes_SingleLink))))","legal function application obligation:(forall heap:Heaps_Heap, subtree:Nodes_NodePtr, position:nat1 \u0026 ((subtree \u003c\u003e NIL) \u003d\u003e pre_Heaps_Retrieve(heap, subtree)))","legal function application obligation:(forall heap:Heaps_Heap, subtree:Nodes_NodePtr, position:nat1 \u0026 ((subtree \u003c\u003e NIL) \u003d\u003e pre_Nodes_GetRight(Heaps_Retrieve(heap, subtree))))","type compatibility obligation:(forall heap:Heaps_Heap, subtree:Nodes_NodePtr, position:nat1 \u0026 ((subtree \u003c\u003e NIL) \u003d\u003e ((is_(Heaps_Retrieve(heap, subtree), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, subtree), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, subtree), Nodes_SingleLink))))","legal function application obligation:(forall heap:Heaps_Heap, subtree:Nodes_NodePtr, position:nat1 \u0026 ((subtree \u003c\u003e NIL) \u003d\u003e pre_Heaps_Retrieve(heap, subtree)))","legal function application obligation:(forall heap:Heaps_Heap, ptr:Nodes_NodePtr \u0026 (((ptr \u003c\u003e NIL) \u003d\u003e pre_Heaps_Retrieve(heap, ptr)) \u003d\u003e ((ptr \u003c\u003e NIL) \u003d\u003e pre_Nodes_GetLeft(Heaps_Retrieve(heap, ptr)))))","type compatibility obligation:(forall heap:Heaps_Heap, ptr:Nodes_NodePtr \u0026 (((ptr \u003c\u003e NIL) \u003d\u003e pre_Heaps_Retrieve(heap, ptr)) \u003d\u003e ((ptr \u003c\u003e NIL) \u003d\u003e ((is_(Heaps_Retrieve(heap, ptr), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, ptr), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, ptr), Nodes_SingleLink)))))","legal function application obligation:(forall heap:Heaps_Heap, ptr:Nodes_NodePtr \u0026 (((ptr \u003c\u003e NIL) \u003d\u003e pre_Heaps_Retrieve(heap, ptr)) \u003d\u003e ((ptr \u003c\u003e NIL) \u003d\u003e pre_Heaps_Retrieve(heap, ptr))))","legal function application obligation:(forall heap:Heaps_Heap, ptr:Nodes_NodePtr \u0026 (((ptr \u003c\u003e NIL) \u003d\u003e pre_Heaps_Retrieve(heap, ptr)) \u003d\u003e ((ptr \u003c\u003e NIL) \u003d\u003e pre_Nodes_GetRight(Heaps_Retrieve(heap, ptr)))))","type compatibility obligation:(forall heap:Heaps_Heap, ptr:Nodes_NodePtr \u0026 (((ptr \u003c\u003e NIL) \u003d\u003e pre_Heaps_Retrieve(heap, ptr)) \u003d\u003e ((ptr \u003c\u003e NIL) \u003d\u003e ((is_(Heaps_Retrieve(heap, ptr), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, ptr), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, ptr), Nodes_SingleLink)))))","legal function application obligation:(forall heap:Heaps_Heap, ptr:Nodes_NodePtr \u0026 (((ptr \u003c\u003e NIL) \u003d\u003e pre_Heaps_Retrieve(heap, ptr)) \u003d\u003e ((ptr \u003c\u003e NIL) \u003d\u003e pre_Heaps_Retrieve(heap, ptr))))","legal function application obligation:(forall heap:Heaps_Heap, child:Nodes_NodePtr, parent:Nodes_NodePtr \u0026 ((pre_Heaps_Retrieve(heap, parent) and pre_Heaps_Retrieve(heap, child)) \u003d\u003e pre_Nodes_GetRight(Heaps_Retrieve(heap, parent))))","type compatibility obligation:(forall heap:Heaps_Heap, child:Nodes_NodePtr, parent:Nodes_NodePtr \u0026 ((pre_Heaps_Retrieve(heap, parent) and pre_Heaps_Retrieve(heap, child)) \u003d\u003e ((is_(Heaps_Retrieve(heap, parent), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, parent), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, parent), Nodes_SingleLink))))","legal function application obligation:(forall heap:Heaps_Heap, child:Nodes_NodePtr, parent:Nodes_NodePtr \u0026 ((pre_Heaps_Retrieve(heap, parent) and pre_Heaps_Retrieve(heap, child)) \u003d\u003e pre_Heaps_Retrieve(heap, parent)))","legal function application obligation:(forall heap:Heaps_Heap, child:Nodes_NodePtr, parent:Nodes_NodePtr \u0026 ((pre_Heaps_Retrieve(heap, parent) and pre_Heaps_Retrieve(heap, child)) \u003d\u003e ((child \u003d Nodes_GetRight(Heaps_Retrieve(heap, parent))) \u003d\u003e pre_Nodes_GetParent(Heaps_Retrieve(heap, child)))))","type compatibility obligation:(forall heap:Heaps_Heap, child:Nodes_NodePtr, parent:Nodes_NodePtr \u0026 ((pre_Heaps_Retrieve(heap, parent) and pre_Heaps_Retrieve(heap, child)) \u003d\u003e ((child \u003d Nodes_GetRight(Heaps_Retrieve(heap, parent))) \u003d\u003e ((is_(Heaps_Retrieve(heap, child), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, child), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, child), Nodes_SingleLink)))))","legal function application obligation:(forall heap:Heaps_Heap, child:Nodes_NodePtr, parent:Nodes_NodePtr \u0026 ((pre_Heaps_Retrieve(heap, parent) and pre_Heaps_Retrieve(heap, child)) \u003d\u003e ((child \u003d Nodes_GetRight(Heaps_Retrieve(heap, parent))) \u003d\u003e pre_Heaps_Retrieve(heap, child))))","legal function application obligation:(forall heap:Heaps_Heap, child:Nodes_NodePtr, parent:Nodes_NodePtr \u0026 ((pre_Heaps_Retrieve(heap, parent) and pre_Heaps_Retrieve(heap, child)) \u003d\u003e pre_Nodes_GetLeft(Heaps_Retrieve(heap, parent))))","type compatibility obligation:(forall heap:Heaps_Heap, child:Nodes_NodePtr, parent:Nodes_NodePtr \u0026 ((pre_Heaps_Retrieve(heap, parent) and pre_Heaps_Retrieve(heap, child)) \u003d\u003e ((is_(Heaps_Retrieve(heap, parent), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, parent), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, parent), Nodes_SingleLink))))","legal function application obligation:(forall heap:Heaps_Heap, child:Nodes_NodePtr, parent:Nodes_NodePtr \u0026 ((pre_Heaps_Retrieve(heap, parent) and pre_Heaps_Retrieve(heap, child)) \u003d\u003e pre_Heaps_Retrieve(heap, parent)))","legal function application obligation:(forall heap:Heaps_Heap, child:Nodes_NodePtr, parent:Nodes_NodePtr \u0026 ((pre_Heaps_Retrieve(heap, parent) and pre_Heaps_Retrieve(heap, child)) \u003d\u003e ((child \u003d Nodes_GetLeft(Heaps_Retrieve(heap, parent))) \u003d\u003e pre_Nodes_GetParent(Heaps_Retrieve(heap, child)))))","type compatibility obligation:(forall heap:Heaps_Heap, child:Nodes_NodePtr, parent:Nodes_NodePtr \u0026 ((pre_Heaps_Retrieve(heap, parent) and pre_Heaps_Retrieve(heap, child)) \u003d\u003e ((child \u003d Nodes_GetLeft(Heaps_Retrieve(heap, parent))) \u003d\u003e ((is_(Heaps_Retrieve(heap, child), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, child), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, child), Nodes_SingleLink)))))","legal function application obligation:(forall heap:Heaps_Heap, child:Nodes_NodePtr, parent:Nodes_NodePtr \u0026 ((pre_Heaps_Retrieve(heap, parent) and pre_Heaps_Retrieve(heap, child)) \u003d\u003e ((child \u003d Nodes_GetLeft(Heaps_Retrieve(heap, parent))) \u003d\u003e pre_Heaps_Retrieve(heap, child))))","legal function application obligation:(forall heap:Heaps_Heap, ptr:Nodes_NodePtr \u0026 ((ptr \u003c\u003e NIL) \u003d\u003e pre_Nodes_GetParent(Heaps_Retrieve(heap, ptr))))","type compatibility obligation:(forall heap:Heaps_Heap, ptr:Nodes_NodePtr \u0026 ((ptr \u003c\u003e NIL) \u003d\u003e ((is_(Heaps_Retrieve(heap, ptr), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, ptr), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, ptr), Nodes_SingleLink))))","legal function application obligation:(forall heap:Heaps_Heap, ptr:Nodes_NodePtr \u0026 ((ptr \u003c\u003e NIL) \u003d\u003e pre_Heaps_Retrieve(heap, ptr)))","legal function application obligation:(forall tree:Trees_Tree, data:Trees_Data, direction:Trees_Direction, oldstate:SystemState \u0026 ((Heaps_Available(heap) and let mk_Trees_Tree(treePtr, current):Trees_Tree \u003d tree in (((direction \u003d \u003cToRoot\u003e) \u003d\u003e (treePtr \u003d NIL)) and (((direction \u003d \u003cToRight\u003e) \u003d\u003e (not Trees_HasRightChild(heap, current))) and ((direction \u003d \u003cToLeft\u003e) \u003d\u003e (not Trees_HasLeftChild(heap, current)))))) \u003d\u003e (Heaps_Available(heap) \u003d\u003e let mk_Trees_Tree(treePtr, current):Trees_Tree \u003d tree in (((direction \u003d \u003cToRoot\u003e) \u003d\u003e (treePtr \u003d NIL)) \u003d\u003e ((direction \u003d \u003cToRight\u003e) \u003d\u003e pre_Trees_HasRightChild(heap, current))))))","legal function application obligation:(forall tree:Trees_Tree, data:Trees_Data, direction:Trees_Direction, oldstate:SystemState \u0026 ((Heaps_Available(heap) and let mk_Trees_Tree(treePtr, current):Trees_Tree \u003d tree in (((direction \u003d \u003cToRoot\u003e) \u003d\u003e (treePtr \u003d NIL)) and (((direction \u003d \u003cToRight\u003e) \u003d\u003e (not Trees_HasRightChild(heap, current))) and ((direction \u003d \u003cToLeft\u003e) \u003d\u003e (not Trees_HasLeftChild(heap, current)))))) \u003d\u003e (Heaps_Available(heap) \u003d\u003e let mk_Trees_Tree(treePtr, current):Trees_Tree \u003d tree in (((direction \u003d \u003cToRoot\u003e) \u003d\u003e (treePtr \u003d NIL)) \u003d\u003e (((direction \u003d \u003cToRight\u003e) \u003d\u003e (not Trees_HasRightChild(heap, current))) \u003d\u003e ((direction \u003d \u003cToLeft\u003e) \u003d\u003e pre_Trees_HasLeftChild(heap, current)))))))","legal function application obligation:(forall tree:Trees_Tree, data:Trees_Data, direction:Trees_Direction, oldstate:SystemState \u0026 ((Heaps_Available(heap) and let mk_Trees_Tree(treePtr, current):Trees_Tree \u003d tree in (((direction \u003d \u003cToRoot\u003e) \u003d\u003e (treePtr \u003d NIL)) and (((direction \u003d \u003cToRight\u003e) \u003d\u003e (not Trees_HasRightChild(heap, current))) and ((direction \u003d \u003cToLeft\u003e) \u003d\u003e (not Trees_HasLeftChild(heap, current)))))) \u003d\u003e (((Heaps_AmountUsed(heap~) + 1) \u003d Heaps_AmountUsed(heap)) \u003d\u003e let old:STrees_Info \u003d Trees_Set(heap~, tree) in pre_STrees_Insert(old, data, direction))))","operation establishes postcondition obligation:(forall tree:Trees_Tree, data:Trees_Data, direction:Trees_Direction, oldstate:SystemState \u0026 ((Heaps_Available(heap) and let mk_Trees_Tree(treePtr, current):Trees_Tree \u003d tree in (((direction \u003d \u003cToRoot\u003e) \u003d\u003e (treePtr \u003d NIL)) and (((direction \u003d \u003cToRight\u003e) \u003d\u003e (not Trees_HasRightChild(heap, current))) and ((direction \u003d \u003cToLeft\u003e) \u003d\u003e (not Trees_HasLeftChild(heap, current)))))) \u003d\u003e (((Heaps_AmountUsed(heap~) + 1) \u003d Heaps_AmountUsed(heap)) and let old:STrees_Info \u003d Trees_Set(heap~, tree) in (STrees_Insert(old, data, direction) \u003d Trees_Set(heap, RESULT)))))","legal function application obligation:(forall ptr:Nodes_NodePtr, oldstate:SystemState \u0026 (Trees_HasLeftChild(heap, ptr) \u003d\u003e pre_Trees_HasLeftChild(heap, ptr)))","while loop termination obligation:NotYetImplemented","legal function application obligation:(forall ptr:Nodes_NodePtr, oldstate:SystemState \u0026 (Trees_HasLeftChild(heap, ptr) \u003d\u003e pre_Trees_HasRightChild(heap, pred)))","legal function application obligation:(forall mk_Trees_Tree(treePtr, current):Trees_Tree, oldstate:SystemState \u0026 ((treePtr \u003c\u003e NIL) \u003d\u003e pre_Trees_HasLeftChild(heap, current)))","legal function application obligation:(forall mk_Trees_Tree(treePtr, current):Trees_Tree, oldstate:SystemState \u0026 ((treePtr \u003c\u003e NIL) \u003d\u003e pre_Trees_HasRightChild(heap, current)))","legal function application obligation:(forall mk_Trees_Tree(treePtr, current):Trees_Tree, oldstate:SystemState \u0026 ((treePtr \u003c\u003e NIL) \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e pre_Trees_IsRoot(heap, current))))))","legal function application obligation:(forall mk_Trees_Tree(treePtr, current):Trees_Tree, oldstate:SystemState \u0026 ((treePtr \u003c\u003e NIL) \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e pre_Trees_IsRightChildOf(heap, current, parent))))))","operation call obligation:(forall mk_Trees_Tree(treePtr, current):Trees_Tree, oldstate:SystemState \u0026 ((treePtr \u003c\u003e NIL) \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e pre_Heaps_ModifyLoc(heap, address, mk_Heaps_Location(nil, false)))))))))","legal function application obligation:(forall mk_Trees_Tree(treePtr, current):Trees_Tree, oldstate:SystemState \u0026 ((treePtr \u003c\u003e NIL) \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e ((Heaps_AmountUsed(heap~) \u003d (Heaps_AmountUsed(heap) + 1)) \u003d\u003e let old:STrees_Info \u003d Trees_Set(heap~, mk_Trees_Tree(treePtr, current)) in pre_STrees_Delete(old))))))))))","operation establishes postcondition obligation:(forall mk_Trees_Tree(treePtr, current):Trees_Tree, oldstate:SystemState \u0026 ((treePtr \u003c\u003e NIL) \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e ((Heaps_AmountUsed(heap~) \u003d (Heaps_AmountUsed(heap) + 1)) and let old:STrees_Info \u003d Trees_Set(heap~, mk_Trees_Tree(treePtr, current)) in (STrees_Delete(old) \u003d Trees_Set(heap, RESULT)))))))))))","operation establishes postcondition obligation:(forall tree:Trees_Tree, data:Trees_Data, oldstate:SystemState \u0026 (true \u003d\u003e (STrees_ExistsData(Trees_Set(heap, tree), data) \u003d RESULT)))","legal function application obligation:(forall tree:Trees_Tree, direction:Trees_Direction, oldstate:SystemState \u0026 (((tree.current) \u003c\u003e NIL) \u003d\u003e pre_Trees_HasLeftChild(heap, (tree.current))))","legal function application obligation:(forall tree:Trees_Tree, direction:Trees_Direction, oldstate:SystemState \u0026 (((tree.current) \u003c\u003e NIL) \u003d\u003e pre_Trees_HasRightChild(heap, (tree.current))))","operation establishes postcondition obligation:(forall tree:Trees_Tree, direction:Trees_Direction, oldstate:SystemState \u0026 (STrees_ExistsDirection(Trees_Set(heap, tree), direction) \u003d RESULT))","legal function application obligation:(forall tree:Trees_Tree, oldstate:SystemState \u0026 (((tree.treePtr) \u003c\u003e NIL) \u003d\u003e (true \u003d\u003e pre_STrees_GetCurrentData(Trees_Set(heap, tree)))))","operation establishes postcondition obligation:(forall tree:Trees_Tree, oldstate:SystemState \u0026 (((tree.treePtr) \u003c\u003e NIL) \u003d\u003e (true \u003d\u003e (STrees_GetCurrentData(Trees_Set(heap, tree)) \u003d RESULT))))","legal function application obligation:(forall tree:Trees_Tree, data:Trees_Data, oldstate:SystemState \u0026 (((tree.treePtr) \u003c\u003e NIL) \u003d\u003e (true \u003d\u003e pre_STrees_StoreCurrentData(Trees_Set(heap~, tree), data))))","operation establishes postcondition obligation:(forall tree:Trees_Tree, data:Trees_Data, oldstate:SystemState \u0026 (((tree.treePtr) \u003c\u003e NIL) \u003d\u003e (true \u003d\u003e (STrees_StoreCurrentData(Trees_Set(heap~, tree), data) \u003d Trees_Set(heap, RESULT)))))","legal function application obligation:(forall tree:Trees_Tree, direction:Trees_Direction, oldstate:SystemState \u0026 ((((tree.treePtr) \u003c\u003e NIL) and (((direction \u003d \u003cToLeft\u003e) \u003d\u003e Trees_HasLeftChild(heap, (tree.current))) and ((direction \u003d \u003cToRight\u003e) \u003d\u003e Trees_HasRightChild(heap, (tree.current))))) \u003d\u003e (((tree.treePtr) \u003c\u003e NIL) \u003d\u003e ((direction \u003d \u003cToLeft\u003e) \u003d\u003e pre_Trees_HasLeftChild(heap, (tree.current))))))","legal function application obligation:(forall tree:Trees_Tree, direction:Trees_Direction, oldstate:SystemState \u0026 ((((tree.treePtr) \u003c\u003e NIL) and (((direction \u003d \u003cToLeft\u003e) \u003d\u003e Trees_HasLeftChild(heap, (tree.current))) and ((direction \u003d \u003cToRight\u003e) \u003d\u003e Trees_HasRightChild(heap, (tree.current))))) \u003d\u003e (((tree.treePtr) \u003c\u003e NIL) \u003d\u003e (((direction \u003d \u003cToLeft\u003e) \u003d\u003e Trees_HasLeftChild(heap, (tree.current))) \u003d\u003e ((direction \u003d \u003cToRight\u003e) \u003d\u003e pre_Trees_HasRightChild(heap, (tree.current)))))))","legal function application obligation:(forall tree:Trees_Tree, direction:Trees_Direction, oldstate:SystemState \u0026 ((((tree.treePtr) \u003c\u003e NIL) and (((direction \u003d \u003cToLeft\u003e) \u003d\u003e Trees_HasLeftChild(heap, (tree.current))) and ((direction \u003d \u003cToRight\u003e) \u003d\u003e Trees_HasRightChild(heap, (tree.current))))) \u003d\u003e pre_STrees_MoveInDir(Trees_Set(heap~, tree), direction)))","operation establishes postcondition obligation:(forall tree:Trees_Tree, direction:Trees_Direction, oldstate:SystemState \u0026 ((((tree.treePtr) \u003c\u003e NIL) and (((direction \u003d \u003cToLeft\u003e) \u003d\u003e Trees_HasLeftChild(heap, (tree.current))) and ((direction \u003d \u003cToRight\u003e) \u003d\u003e Trees_HasRightChild(heap, (tree.current))))) \u003d\u003e (STrees_MoveInDir(Trees_Set(heap~, tree), direction) \u003d Trees_Set(heap, RESULT))))","legal function application obligation:(forall tree:Trees_Tree, oldstate:SystemState \u0026 ((not Trees_IsRoot(heap, (tree.current))) \u003d\u003e pre_Trees_IsRoot(heap, (tree.current))))","legal function application obligation:(forall tree:Trees_Tree, oldstate:SystemState \u0026 ((not Trees_IsRoot(heap, (tree.current))) \u003d\u003e pre_STrees_MoveToParent(Trees_Set(heap~, tree))))","operation establishes postcondition obligation:(forall tree:Trees_Tree, oldstate:SystemState \u0026 ((not Trees_IsRoot(heap, (tree.current))) \u003d\u003e (STrees_MoveToParent(Trees_Set(heap~, tree)) \u003d Trees_Set(heap, RESULT))))","operation establishes postcondition obligation:(forall tree:Trees_Tree, oldstate:SystemState \u0026 (true \u003d\u003e (STrees_Size(Trees_Set(heap~, tree)) \u003d RESULT)))","operation establishes postcondition obligation:(forall tree:Trees_Tree, traversal:(Trees_Data -\u003e Trees_Data), oldstate:SystemState \u0026 (true \u003d\u003e (STrees_Traverse(Trees_Set(heap~, tree), traversal) \u003d Trees_Set(heap, RESULT))))","legal function application obligation:(forall subtree:Nodes_NodePtr, traversal:(Trees_Data -\u003e Trees_Data), oldstate:SystemState \u0026 pre_(traversalDATA(subtree)))","legal function application obligation:pre_STrees_MkTree({STrees_MkNode(\u0027a\u0027, 1), STrees_MkNode(\u0027b\u0027, 2), STrees_MkNode(\u0027c\u0027, 3), STrees_MkNode(\u0027d\u0027, 4), STrees_MkNode(\u0027e\u0027, 5), STrees_MkNode(\u0027f\u0027, 6), STrees_MkNode(\u0027g\u0027, 7), STrees_MkNode(\u0027h\u0027, 8), STrees_MkNode(\u0027i\u0027, 9), STrees_MkNode(\u0027j\u0027, 10), STrees_MkNode(\u0027k\u0027, 11), STrees_MkNode(\u0027l\u0027, 12), STrees_MkNode(\u0027m\u0027, 13), STrees_MkNode(\u0027n\u0027, 14), STrees_MkNode(\u0027o\u0027, 15), STrees_MkNode(\u0027p\u0027, 16), STrees_MkNode(\u0027q\u0027, 17), STrees_MkNode(\u0027r\u0027, 18), STrees_MkNode(\u0027s\u0027, 19), STrees_MkNode(\u0027t\u0027, 20), STrees_MkNode(\u0027u\u0027, 21), STrees_MkNode(\u0027v\u0027, 22), STrees_MkNode(\u0027w\u0027, 23), STrees_MkNode(\u0027x\u0027, 24), STrees_MkNode(\u0027y\u0027, 25), STrees_MkNode(\u0027z\u0027, 26)})","legal function application obligation:pre_STrees_MkTree({STrees_MkNode(\u0027a\u0027, 1), STrees_MkNode(\u0027d\u0027, 2), STrees_MkNode(\u0027c\u0027, 3), STrees_MkNode(\u0027h\u0027, 4), STrees_MkNode(\u0027i\u0027, 5), STrees_MkNode(\u0027f\u0027, 6), STrees_MkNode(\u0027o\u0027, 7), STrees_MkNode(\u0027p\u0027, 8), STrees_MkNode(\u0027r\u0027, 10), STrees_MkNode(\u0027s\u0027, 11), STrees_MkNode(\u0027l\u0027, 12), STrees_MkNode(\u0027z\u0027, 13), STrees_MkNode(\u0027j\u0027, 23), STrees_MkNode(\u0027x\u0027, 24), STrees_MkNode(\u0027y\u0027, 25), STrees_MkNode(\u0027t\u0027, 46), STrees_MkNode(\u0027u\u0027, 47), STrees_MkNode(\u0027k\u0027, 95), STrees_MkNode(\u0027v\u0027, 190), STrees_MkNode(\u0027w\u0027, 191)})","legal function application obligation:pre_STrees_MkTree({STrees_MkNode(\u0027a\u0027, 1), STrees_MkNode(\u0027a\u0027, 2), STrees_MkNode(\u0027a\u0027, 3), STrees_MkNode(\u0027a\u0027, 4), STrees_MkNode(\u0027a\u0027, 5), STrees_MkNode(\u0027a\u0027, 6), STrees_MkNode(\u0027b\u0027, 7), STrees_MkNode(\u0027b\u0027, 8), STrees_MkNode(\u0027b\u0027, 10), STrees_MkNode(\u0027b\u0027, 11), STrees_MkNode(\u0027b\u0027, 12), STrees_MkNode(\u0027b\u0027, 13), STrees_MkNode(\u0027a\u0027, 23), STrees_MkNode(\u0027b\u0027, 24), STrees_MkNode(\u0027b\u0027, 25), STrees_MkNode(\u0027b\u0027, 46), STrees_MkNode(\u0027b\u0027, 47), STrees_MkNode(\u0027b\u0027, 95), STrees_MkNode(\u0027b\u0027, 190), STrees_MkNode(\u0027b\u0027, 191)})","legal function application obligation:pre_STrees_Insert(stree, \u0027a\u0027, \u003cToRoot\u003e)","legal function application obligation:pre_STrees_Insert(stree, \u0027b\u0027, \u003cToLeft\u003e)","legal function application obligation:pre_STrees_MoveToParent(stree)","legal function application obligation:pre_STrees_Insert(stree, \u0027c\u0027, \u003cToRight\u003e)","legal function application obligation:pre_STrees_MoveToParent(stree)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToLeft\u003e)","legal function application obligation:pre_STrees_Insert(stree, \u0027d\u0027, \u003cToLeft\u003e)","legal function application obligation:pre_STrees_MoveToParent(stree)","legal function application obligation:pre_STrees_Insert(stree, \u0027e\u0027, \u003cToRight\u003e)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToRoot\u003e)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToRight\u003e)","legal function application obligation:pre_STrees_Insert(stree, \u0027f\u0027, \u003cToLeft\u003e)","legal function application obligation:pre_STrees_MoveToParent(stree)","legal function application obligation:pre_STrees_Insert(stree, \u0027g\u0027, \u003cToRight\u003e)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToRoot\u003e)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToLeft\u003e)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToLeft\u003e)","legal function application obligation:pre_STrees_Insert(stree, \u0027h\u0027, \u003cToLeft\u003e)","legal function application obligation:pre_STrees_MoveToParent(stree)","legal function application obligation:pre_STrees_Insert(stree, \u0027i\u0027, \u003cToRight\u003e)","legal function application obligation:pre_STrees_MoveToAnscestor(stree, 2)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToRight\u003e)","legal function application obligation:pre_STrees_Insert(stree, \u0027j\u0027, \u003cToLeft\u003e)","legal function application obligation:pre_STrees_MoveToParent(stree)","legal function application obligation:pre_STrees_Insert(stree, \u0027k\u0027, \u003cToRight\u003e)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToRoot\u003e)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToRight\u003e)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToLeft\u003e)","legal function application obligation:pre_STrees_Insert(stree, \u0027l\u0027, \u003cToLeft\u003e)","legal function application obligation:pre_STrees_MoveToParent(stree)","legal function application obligation:pre_STrees_Insert(stree, \u0027m\u0027, \u003cToRight\u003e)","legal function application obligation:pre_STrees_MoveToAnscestor(stree, 2)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToRight\u003e)","legal function application obligation:pre_STrees_Insert(stree, \u0027n\u0027, \u003cToLeft\u003e)","legal function application obligation:pre_STrees_MoveToParent(stree)","legal function application obligation:pre_STrees_Insert(stree, \u0027o\u0027, \u003cToRight\u003e)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToRoot\u003e)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToLeft\u003e)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToLeft\u003e)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToLeft\u003e)","legal function application obligation:pre_STrees_Insert(stree, \u0027p\u0027, \u003cToLeft\u003e)","legal function application obligation:pre_STrees_MoveToParent(stree)","legal function application obligation:pre_STrees_Insert(stree, \u0027q\u0027, \u003cToRight\u003e)","legal function application obligation:pre_STrees_MoveToAnscestor(stree, 2)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToRight\u003e)","legal function application obligation:pre_STrees_Insert(stree, \u0027r\u0027, \u003cToLeft\u003e)","legal function application obligation:pre_STrees_MoveToParent(stree)","legal function application obligation:pre_STrees_Insert(stree, \u0027s\u0027, \u003cToRight\u003e)","legal function application obligation:pre_STrees_MoveToAnscestor(stree, 3)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToRight\u003e)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToLeft\u003e)","legal function application obligation:pre_STrees_Insert(stree, \u0027t\u0027, \u003cToLeft\u003e)","legal function application obligation:pre_STrees_MoveToParent(stree)","legal function application obligation:pre_STrees_Insert(stree, \u0027u\u0027, \u003cToRight\u003e)","legal function application obligation:pre_STrees_MoveToAnscestor(stree, 2)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToRight\u003e)","legal function application obligation:pre_STrees_Insert(stree, \u0027v\u0027, \u003cToLeft\u003e)","legal function application obligation:pre_STrees_MoveToParent(stree)","legal function application obligation:pre_STrees_Insert(stree, \u0027w\u0027, \u003cToRight\u003e)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToRoot\u003e)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToRight\u003e)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToLeft\u003e)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToLeft\u003e)","legal function application obligation:pre_STrees_Insert(stree, \u0027x\u0027, \u003cToLeft\u003e)","legal function application obligation:pre_STrees_MoveToParent(stree)","legal function application obligation:pre_STrees_Insert(stree, \u0027y\u0027, \u003cToRight\u003e)","legal function application obligation:pre_STrees_MoveToAnscestor(stree, 2)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToRight\u003e)","legal function application obligation:pre_STrees_Insert(stree, \u0027z\u0027, \u003cToLeft\u003e)","legal function application obligation:pre_STrees_MoveToNode(stree, 14)","legal function application obligation:pre_STrees_Delete(stree)","legal function application obligation:pre_STrees_MoveToNode(stree, 17)","legal function application obligation:pre_STrees_Delete(stree)","legal function application obligation:pre_STrees_MoveToNode(stree, 13)","legal function application obligation:pre_STrees_Delete(stree)","legal function application obligation:pre_STrees_MoveToNode(stree, 7)","legal function application obligation:pre_STrees_Delete(stree)","legal function application obligation:pre_STrees_MoveToNode(stree, 5)","legal function application obligation:pre_STrees_Delete(stree)","legal function application obligation:pre_STrees_MoveToNode(stree, 2)","legal function application obligation:pre_STrees_Delete(stree)","legal function application obligation:pre_STrees_MoveToNode(stree, 3)","legal function application obligation:pre_STrees_GetData(stree, 13)","legal function application obligation:pre_STrees_SetCurrentNode(stree, STrees_MkNode(\u0027z\u0027, 13))","legal function application obligation:pre_STrees_StoreCurrentData(stree, \u0027Z\u0027)","legal function application obligation:pre_STrees_GetCurrentData(stree)"] \ No newline at end of file +["value binding obligation:(forall node:Nodes_Node \u0026 ((is_(node, Nodes_SingleLink) or (is_(node, Nodes_DoubleLink) or is_(node, Nodes_BinaryTree))) \u003d\u003e ((not is_(node, Nodes_SingleLink)) \u003d\u003e ((not is_(node, Nodes_DoubleLink)) \u003d\u003e (exists mk_Nodes_BinaryTree(data, -, -, -):Nodes_Node \u0026 (mk_Nodes_BinaryTree(data, any1, any2, any3) \u003d node))))))","type compatibility obligation:(forall node:Nodes_Node \u0026 ((is_(node, Nodes_SingleLink) or (is_(node, Nodes_DoubleLink) or is_(node, Nodes_BinaryTree))) \u003d\u003e ((not is_(node, Nodes_SingleLink)) \u003d\u003e ((not is_(node, Nodes_DoubleLink)) \u003d\u003e is_(node, Nodes_BinaryTree)))))","value binding obligation:(forall node:Nodes_Node, data:Nodes_Data \u0026 ((is_(node, Nodes_SingleLink) or (is_(node, Nodes_DoubleLink) or is_(node, Nodes_BinaryTree))) \u003d\u003e ((not is_(node, Nodes_SingleLink)) \u003d\u003e ((not is_(node, Nodes_DoubleLink)) \u003d\u003e (exists mk_Nodes_BinaryTree(-, right, left, parent):Nodes_Node \u0026 (mk_Nodes_BinaryTree(any1, right, left, parent) \u003d node))))))","type compatibility obligation:(forall node:Nodes_Node, data:Nodes_Data \u0026 ((is_(node, Nodes_SingleLink) or (is_(node, Nodes_DoubleLink) or is_(node, Nodes_BinaryTree))) \u003d\u003e ((not is_(node, Nodes_SingleLink)) \u003d\u003e ((not is_(node, Nodes_DoubleLink)) \u003d\u003e is_(node, Nodes_BinaryTree)))))","value binding obligation:(forall node:Nodes_Node \u0026 ((is_(node, Nodes_SingleLink) or is_(node, Nodes_DoubleLink)) \u003d\u003e ((not is_(node, Nodes_SingleLink)) \u003d\u003e (exists mk_Nodes_DoubleLink(-, next, -):Nodes_Node \u0026 (mk_Nodes_DoubleLink(any1, next, any2) \u003d node)))))","type compatibility obligation:(forall node:Nodes_Node \u0026 ((is_(node, Nodes_SingleLink) or is_(node, Nodes_DoubleLink)) \u003d\u003e ((not is_(node, Nodes_SingleLink)) \u003d\u003e is_(node, Nodes_DoubleLink))))","value binding obligation:(forall node:Nodes_Node, next:Nodes_NodePtr \u0026 ((is_(node, Nodes_SingleLink) or is_(node, Nodes_DoubleLink)) \u003d\u003e ((not is_(node, Nodes_SingleLink)) \u003d\u003e (exists mk_Nodes_DoubleLink(data, -, prev):Nodes_Node \u0026 (mk_Nodes_DoubleLink(data, any1, prev) \u003d node)))))","type compatibility obligation:(forall node:Nodes_Node, next:Nodes_NodePtr \u0026 ((is_(node, Nodes_SingleLink) or is_(node, Nodes_DoubleLink)) \u003d\u003e ((not is_(node, Nodes_SingleLink)) \u003d\u003e is_(node, Nodes_DoubleLink))))","type invariant satisfiable obligation:(exists mk_Heaps_Location(d, a):Heaps_Location \u0026 ((a \u003d true) \u003c\u003d\u003e (d \u003c\u003e nil)))","type invariant satisfiable obligation:(exists mk_Heaps_Heap(s):Heaps_Heap \u0026 ((len s) \u003d Heaps_Size))","type compatibility obligation:(forall length:nat1 \u0026 ((length \u003e 1) \u003d\u003e inv_Heaps_Location(mk_Heaps_Location(nil, false))))","type compatibility obligation:(forall length:nat1 \u0026 ((length \u003e 1) \u003d\u003e ((length - 1) \u003e 0)))","type compatibility obligation:(forall length:nat1 \u0026 ((not (length \u003e 1)) \u003d\u003e inv_Heaps_Location(mk_Heaps_Location(nil, false))))","type compatibility obligation:inv_Heaps_Heap(mk_Heaps_Heap(Heaps_InitSequence(Heaps_Size)))","legal sequence application obligation:(forall heap:Heaps_Heap \u0026 let store:seq of (Heaps_Location) \u003d (heap.storage) in (forall i in set (inds store) \u0026 (((store(i).allocated) \u003d true) \u003d\u003e (i in set (inds store)))))","legal sequence application obligation:(forall heap:Heaps_Heap \u0026 let store:seq of (Heaps_Location) \u003d (heap.storage) in (forall i in set (inds store) \u0026 (i in set (inds store))))","sequence modification obligation:(forall heap:Heaps_Heap, address:ADDRESS, location:Heaps_Location \u0026 ((address in set (inds (heap.storage))) \u003d\u003e ((dom {address |-\u003e location}) subset (inds (heap.storage)))))","type compatibility obligation:(forall heap:Heaps_Heap, address:ADDRESS, location:Heaps_Location \u0026 ((address in set (inds (heap.storage))) \u003d\u003e inv_Heaps_Heap(mk_Heaps_Heap(((heap.storage) ++ {address |-\u003e location})))))","legal sequence application obligation:(forall heap:Heaps_Heap, address:ADDRESS, data:Heaps_Data \u0026 let store:seq of (Heaps_Location) \u003d (heap.storage) in ((address in set (inds store)) \u003d\u003e (address in set (inds store))))","legal function application obligation:(forall heap:Heaps_Heap, address:ADDRESS, data:Heaps_Data \u0026 (let store:seq of (Heaps_Location) \u003d (heap.storage) in ((address in set (inds store)) and ((store(address).allocated) \u003d true)) \u003d\u003e pre_Heaps_ModifyLoc(heap, address, mk_Heaps_Location(data, true))))","type compatibility obligation:(forall heap:Heaps_Heap, address:ADDRESS, data:Heaps_Data \u0026 (let store:seq of (Heaps_Location) \u003d (heap.storage) in ((address in set (inds store)) and ((store(address).allocated) \u003d true)) \u003d\u003e inv_Heaps_Location(mk_Heaps_Location(data, true))))","legal sequence application obligation:(forall heap:Heaps_Heap, address:ADDRESS \u0026 let store:seq of (Heaps_Location) \u003d (heap.storage) in ((address in set (inds store)) \u003d\u003e (address in set (inds store))))","legal sequence application obligation:(forall heap:Heaps_Heap, address:ADDRESS \u0026 (let store:seq of (Heaps_Location) \u003d (heap.storage) in ((address in set (inds store)) and ((store(address).allocated) \u003d true)) \u003d\u003e (address in set (inds (heap.storage)))))","legal sequence application obligation:(forall heap:Heaps_Heap \u0026 let store:seq of (Heaps_Location) \u003d (heap.storage) in (forall i in set (inds store) \u0026 (i in set (inds store))))","unique existence binding obligation:(forall heap:Heaps_Heap \u0026 (Heaps_Available(heap) \u003d\u003e (exists1 new in set Heaps_UnallocatedAddresses(heap) \u0026 (forall i in set Heaps_UnallocatedAddresses(heap) \u0026 (new \u003c\u003d i)))))","legal function application obligation:(forall data:Heaps_Data, oldstate:SystemState \u0026 (Heaps_Available(heap) \u003d\u003e pre_Heaps_UnallocatedAddress(heap)))","type compatibility obligation:(forall data:Heaps_Data, oldstate:SystemState \u0026 (Heaps_Available(heap) \u003d\u003e inv_Heaps_Location(mk_Heaps_Location(data, true))))","legal function application obligation:(forall data:Heaps_Data, oldstate:SystemState \u0026 (Heaps_Available(heap) \u003d\u003e pre_Heaps_ModifyLoc(heap, newAddress, newLoc)))","type compatibility obligation:(forall address:ADDRESS, oldstate:SystemState \u0026 (pre_Heaps_ModifyLoc(heap, address, mk_Heaps_Location(nil, false)) \u003d\u003e inv_Heaps_Location(mk_Heaps_Location(nil, false))))","legal function application obligation:(forall address:ADDRESS, oldstate:SystemState \u0026 (pre_Heaps_ModifyLoc(heap, address, mk_Heaps_Location(nil, false)) \u003d\u003e pre_Heaps_ModifyLoc(heap, address, mk_Heaps_Location(nil, false))))","type compatibility obligation:(forall address:ADDRESS, oldstate:SystemState \u0026 (pre_Heaps_ModifyLoc(heap, address, mk_Heaps_Location(nil, false)) \u003d\u003e inv_Heaps_Location(mk_Heaps_Location(nil, false))))","legal function application obligation:(forall ptr:ADDRESS, data:Data, oldstate:SystemState \u0026 pre_Heaps_Modify(heap, ptr, Nodes_SetData(Heaps_Retrieve(heap, ptr), data)))","legal function application obligation:(forall ptr:ADDRESS, data:Data, oldstate:SystemState \u0026 pre_Nodes_SetData(Heaps_Retrieve(heap, ptr), data))","type compatibility obligation:(forall ptr:ADDRESS, data:Data, oldstate:SystemState \u0026 ((is_(Heaps_Retrieve(heap, ptr), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, ptr), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, ptr), Nodes_SingleLink)))","legal function application obligation:(forall ptr:ADDRESS, data:Data, oldstate:SystemState \u0026 pre_Heaps_Retrieve(heap, ptr))","legal function application obligation:(forall ptr:ADDRESS, next:ADDRESS, oldstate:SystemState \u0026 pre_Heaps_Modify(heap, ptr, Nodes_SetNext(Heaps_Retrieve(heap, ptr), next)))","legal function application obligation:(forall ptr:ADDRESS, next:ADDRESS, oldstate:SystemState \u0026 pre_Nodes_SetNext(Heaps_Retrieve(heap, ptr), next))","type compatibility obligation:(forall ptr:ADDRESS, next:ADDRESS, oldstate:SystemState \u0026 ((is_(Heaps_Retrieve(heap, ptr), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, ptr), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, ptr), Nodes_SingleLink)))","legal function application obligation:(forall ptr:ADDRESS, next:ADDRESS, oldstate:SystemState \u0026 pre_Heaps_Retrieve(heap, ptr))","legal function application obligation:(forall ptr:ADDRESS, left:ADDRESS, oldstate:SystemState \u0026 pre_Heaps_Modify(heap, ptr, Nodes_SetLeft(Heaps_Retrieve(heap, ptr), left)))","legal function application obligation:(forall ptr:ADDRESS, left:ADDRESS, oldstate:SystemState \u0026 pre_Nodes_SetLeft(Heaps_Retrieve(heap, ptr), left))","type compatibility obligation:(forall ptr:ADDRESS, left:ADDRESS, oldstate:SystemState \u0026 ((is_(Heaps_Retrieve(heap, ptr), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, ptr), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, ptr), Nodes_SingleLink)))","legal function application obligation:(forall ptr:ADDRESS, left:ADDRESS, oldstate:SystemState \u0026 pre_Heaps_Retrieve(heap, ptr))","legal function application obligation:(forall ptr:ADDRESS, right:ADDRESS, oldstate:SystemState \u0026 pre_Heaps_Modify(heap, ptr, Nodes_SetRight(Heaps_Retrieve(heap, ptr), right)))","legal function application obligation:(forall ptr:ADDRESS, right:ADDRESS, oldstate:SystemState \u0026 pre_Nodes_SetRight(Heaps_Retrieve(heap, ptr), right))","type compatibility obligation:(forall ptr:ADDRESS, right:ADDRESS, oldstate:SystemState \u0026 ((is_(Heaps_Retrieve(heap, ptr), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, ptr), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, ptr), Nodes_SingleLink)))","legal function application obligation:(forall ptr:ADDRESS, right:ADDRESS, oldstate:SystemState \u0026 pre_Heaps_Retrieve(heap, ptr))","legal function application obligation:(forall ptr:ADDRESS, prev:ADDRESS, oldstate:SystemState \u0026 pre_Heaps_Modify(heap, ptr, Nodes_SetPrev(Heaps_Retrieve(heap, ptr), prev)))","legal function application obligation:(forall ptr:ADDRESS, prev:ADDRESS, oldstate:SystemState \u0026 pre_Nodes_SetPrev(Heaps_Retrieve(heap, ptr), prev))","type compatibility obligation:(forall ptr:ADDRESS, prev:ADDRESS, oldstate:SystemState \u0026 ((is_(Heaps_Retrieve(heap, ptr), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, ptr), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, ptr), Nodes_SingleLink)))","legal function application obligation:(forall ptr:ADDRESS, prev:ADDRESS, oldstate:SystemState \u0026 pre_Heaps_Retrieve(heap, ptr))","legal function application obligation:(forall ptr:ADDRESS, parent:ADDRESS, oldstate:SystemState \u0026 pre_Heaps_Modify(heap, ptr, Nodes_SetParent(Heaps_Retrieve(heap, ptr), parent)))","legal function application obligation:(forall ptr:ADDRESS, parent:ADDRESS, oldstate:SystemState \u0026 pre_Nodes_SetParent(Heaps_Retrieve(heap, ptr), parent))","type compatibility obligation:(forall ptr:ADDRESS, parent:ADDRESS, oldstate:SystemState \u0026 ((is_(Heaps_Retrieve(heap, ptr), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, ptr), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, ptr), Nodes_SingleLink)))","legal function application obligation:(forall ptr:ADDRESS, parent:ADDRESS, oldstate:SystemState \u0026 pre_Heaps_Retrieve(heap, ptr))","legal function application obligation:(forall ptr:ADDRESS, oldstate:SystemState \u0026 pre_Nodes_GetData(Heaps_Retrieve(heap, ptr)))","type compatibility obligation:(forall ptr:ADDRESS, oldstate:SystemState \u0026 ((is_(Heaps_Retrieve(heap, ptr), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, ptr), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, ptr), Nodes_SingleLink)))","legal function application obligation:(forall ptr:ADDRESS, oldstate:SystemState \u0026 pre_Heaps_Retrieve(heap, ptr))","legal function application obligation:(forall ptr:ADDRESS, oldstate:SystemState \u0026 pre_Nodes_GetNext(Heaps_Retrieve(heap, ptr)))","type compatibility obligation:(forall ptr:ADDRESS, oldstate:SystemState \u0026 ((is_(Heaps_Retrieve(heap, ptr), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, ptr), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, ptr), Nodes_SingleLink)))","legal function application obligation:(forall ptr:ADDRESS, oldstate:SystemState \u0026 pre_Heaps_Retrieve(heap, ptr))","legal function application obligation:(forall ptr:ADDRESS, oldstate:SystemState \u0026 pre_Nodes_GetLeft(Heaps_Retrieve(heap, ptr)))","type compatibility obligation:(forall ptr:ADDRESS, oldstate:SystemState \u0026 ((is_(Heaps_Retrieve(heap, ptr), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, ptr), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, ptr), Nodes_SingleLink)))","legal function application obligation:(forall ptr:ADDRESS, oldstate:SystemState \u0026 pre_Heaps_Retrieve(heap, ptr))","legal function application obligation:(forall ptr:ADDRESS, oldstate:SystemState \u0026 pre_Nodes_GetRight(Heaps_Retrieve(heap, ptr)))","type compatibility obligation:(forall ptr:ADDRESS, oldstate:SystemState \u0026 ((is_(Heaps_Retrieve(heap, ptr), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, ptr), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, ptr), Nodes_SingleLink)))","legal function application obligation:(forall ptr:ADDRESS, oldstate:SystemState \u0026 pre_Heaps_Retrieve(heap, ptr))","legal function application obligation:(forall ptr:ADDRESS, oldstate:SystemState \u0026 pre_Nodes_GetParent(Heaps_Retrieve(heap, ptr)))","type compatibility obligation:(forall ptr:ADDRESS, oldstate:SystemState \u0026 ((is_(Heaps_Retrieve(heap, ptr), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, ptr), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, ptr), Nodes_SingleLink)))","legal function application obligation:(forall ptr:ADDRESS, oldstate:SystemState \u0026 pre_Heaps_Retrieve(heap, ptr))","legal function application obligation:(forall heap:Heaps_Heap, list:SList_List \u0026 ((not SList_IsEmpty(list)) \u003d\u003e pre_Heaps_Retrieve(heap, list)))","legal function application obligation:(forall heap:Heaps_Heap, list:SList_List \u0026 ((not SList_IsEmpty(list)) \u003d\u003e let node:[Heaps_Data] \u003d Heaps_Retrieve(heap, list) in pre_Nodes_GetData(node)))","type compatibility obligation:(forall heap:Heaps_Heap, list:SList_List \u0026 ((not SList_IsEmpty(list)) \u003d\u003e let node:[Heaps_Data] \u003d Heaps_Retrieve(heap, list) in ((is_(node, Nodes_BinaryTree) or is_(node, Nodes_DoubleLink)) or is_(node, Nodes_SingleLink))))","legal function application obligation:(forall heap:Heaps_Heap, list:SList_List \u0026 ((not SList_IsEmpty(list)) \u003d\u003e let node:[Heaps_Data] \u003d Heaps_Retrieve(heap, list) in let data:Nodes_Data \u003d Nodes_GetData(node) in pre_Nodes_GetNext(node)))","type compatibility obligation:(forall heap:Heaps_Heap, list:SList_List \u0026 ((not SList_IsEmpty(list)) \u003d\u003e let node:[Heaps_Data] \u003d Heaps_Retrieve(heap, list) in let data:Nodes_Data \u003d Nodes_GetData(node) in ((is_(node, Nodes_BinaryTree) or is_(node, Nodes_DoubleLink)) or is_(node, Nodes_SingleLink))))","function establishes postcondition obligation:(forall heap:Heaps_Heap, list:SList_List \u0026 post_SList_Lengthf(heap, list, (if (not SList_IsEmpty(list))\nthen let tail:Nodes_NodePtr \u003d Nodes_GetNext(Heaps_Retrieve(heap, list)) in (1 + SList_Lengthf(heap, tail))\nelse 0)))","legal function application obligation:(forall heap:Heaps_Heap, list:SList_List \u0026 ((not SList_IsEmpty(list)) \u003d\u003e pre_Nodes_GetNext(Heaps_Retrieve(heap, list))))","type compatibility obligation:(forall heap:Heaps_Heap, list:SList_List \u0026 ((not SList_IsEmpty(list)) \u003d\u003e ((is_(Heaps_Retrieve(heap, list), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, list), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, list), Nodes_SingleLink))))","legal function application obligation:(forall heap:Heaps_Heap, list:SList_List \u0026 ((not SList_IsEmpty(list)) \u003d\u003e pre_Heaps_Retrieve(heap, list)))","function establishes postcondition obligation:(forall heap:Heaps_Heap, list:SList_List, position:nat1 \u0026 (pre_SList_PtrToNode(heap, list, position) \u003d\u003e post_SList_PtrToNode(heap, list, position, let tail:Nodes_NodePtr \u003d Nodes_GetNext(Heaps_Retrieve(heap, list)) in (if (position \u003e 1)\nthen SList_PtrToNode(heap, tail, (position - 1))\nelse list))))","legal function application obligation:(forall heap:Heaps_Heap, list:SList_List, position:nat1 \u0026 ((position \u003c\u003d SList_Lengthf(heap, list)) \u003d\u003e let RESULT \u003d let tail:Nodes_NodePtr \u003d Nodes_GetNext(Heaps_Retrieve(heap, list)) in (if (position \u003e 1)\nthen SList_PtrToNode(heap, tail, (position - 1))\nelse list) in pre_Nodes_GetData(Heaps_Retrieve(heap, RESULT))))","type compatibility obligation:(forall heap:Heaps_Heap, list:SList_List, position:nat1 \u0026 ((position \u003c\u003d SList_Lengthf(heap, list)) \u003d\u003e let RESULT \u003d let tail:Nodes_NodePtr \u003d Nodes_GetNext(Heaps_Retrieve(heap, list)) in (if (position \u003e 1)\nthen SList_PtrToNode(heap, tail, (position - 1))\nelse list) in ((is_(Heaps_Retrieve(heap, RESULT), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, RESULT), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, RESULT), Nodes_SingleLink))))","legal function application obligation:(forall heap:Heaps_Heap, list:SList_List, position:nat1 \u0026 ((position \u003c\u003d SList_Lengthf(heap, list)) \u003d\u003e let RESULT \u003d let tail:Nodes_NodePtr \u003d Nodes_GetNext(Heaps_Retrieve(heap, list)) in (if (position \u003e 1)\nthen SList_PtrToNode(heap, tail, (position - 1))\nelse list) in pre_Heaps_Retrieve(heap, RESULT)))","legal sequence application obligation:(forall heap:Heaps_Heap, list:SList_List, position:nat1 \u0026 ((position \u003c\u003d SList_Lengthf(heap, list)) \u003d\u003e let RESULT \u003d let tail:Nodes_NodePtr \u003d Nodes_GetNext(Heaps_Retrieve(heap, list)) in (if (position \u003e 1)\nthen SList_PtrToNode(heap, tail, (position - 1))\nelse list) in let data:Nodes_Data \u003d Nodes_GetData(Heaps_Retrieve(heap, RESULT)), listSeq:seq of (SList_Data) \u003d SList_Seq(heap, list) in (position in set (inds listSeq))))","legal function application obligation:(forall heap:Heaps_Heap, list:SList_List, position:nat1 \u0026 ((position \u003c\u003d SList_Lengthf(heap, list)) \u003d\u003e pre_Nodes_GetNext(Heaps_Retrieve(heap, list))))","type compatibility obligation:(forall heap:Heaps_Heap, list:SList_List, position:nat1 \u0026 ((position \u003c\u003d SList_Lengthf(heap, list)) \u003d\u003e ((is_(Heaps_Retrieve(heap, list), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, list), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, list), Nodes_SingleLink))))","legal function application obligation:(forall heap:Heaps_Heap, list:SList_List, position:nat1 \u0026 ((position \u003c\u003d SList_Lengthf(heap, list)) \u003d\u003e pre_Heaps_Retrieve(heap, list)))","legal function application obligation:(forall heap:Heaps_Heap, list:SList_List, position:nat1 \u0026 ((position \u003c\u003d SList_Lengthf(heap, list)) \u003d\u003e let tail:Nodes_NodePtr \u003d Nodes_GetNext(Heaps_Retrieve(heap, list)) in ((position \u003e 1) \u003d\u003e pre_SList_PtrToNode(heap, tail, (position - 1)))))","type compatibility obligation:(forall heap:Heaps_Heap, list:SList_List, position:nat1 \u0026 ((position \u003c\u003d SList_Lengthf(heap, list)) \u003d\u003e let tail:Nodes_NodePtr \u003d Nodes_GetNext(Heaps_Retrieve(heap, list)) in ((position \u003e 1) \u003d\u003e ((position - 1) \u003e 0))))","operation establishes postcondition obligation:(forall list:SList_List, data:SList_Data, oldstate:SystemState \u0026 (([data] ^ SList_Seq(heap~, list)) \u003d SList_Seq(heap, RESULT)))","legal sequence application obligation:(forall list:SList_List, ptr:Nodes_NodePtr, data:SList_Data, oldstate:SystemState \u0026 (true \u003d\u003e let old:seq of (SList_Data) \u003d SList_Seq(heap~, ptr) in (1 in set (inds old))))","non-empty sequence obligation:(forall list:SList_List, ptr:Nodes_NodePtr, data:SList_Data, oldstate:SystemState \u0026 (true \u003d\u003e let old:seq of (SList_Data) \u003d SList_Seq(heap~, ptr) in (old \u003c\u003e [])))","operation establishes postcondition obligation:(forall list:SList_List, ptr:Nodes_NodePtr, data:SList_Data, oldstate:SystemState \u0026 (true \u003d\u003e let old:seq of (SList_Data) \u003d SList_Seq(heap~, ptr) in ((([old(1)] ^ [data]) ^ (tl old)) \u003d SList_Seq(heap, ptr))))","legal function application obligation:(forall list:SList_List, data:SList_Data, position:nat1, oldstate:SystemState \u0026 (((position \u003c\u003d (SList_Lengthf(heap, list) + 1)) and Heaps_Available(heap)) \u003d\u003e pre_SList_PtrToNode(heap, list, (position - 1))))","type compatibility obligation:(forall list:SList_List, data:SList_Data, position:nat1, oldstate:SystemState \u0026 (((position \u003c\u003d (SList_Lengthf(heap, list) + 1)) and Heaps_Available(heap)) \u003d\u003e ((position - 1) \u003e 0)))","legal sequence application obligation:(forall list:SList_List, data:SList_Data, position:nat1, oldstate:SystemState \u0026 (((position \u003c\u003d (SList_Lengthf(heap, list) + 1)) and Heaps_Available(heap)) \u003d\u003e let new:seq of (SList_Data) \u003d SList_Seq(heap, RESULT) in (forall i in set (inds new) \u0026 ((i \u003c\u003e position) \u003d\u003e (i in set (inds new))))))","legal sequence application obligation:(forall list:SList_List, data:SList_Data, position:nat1, oldstate:SystemState \u0026 (((position \u003c\u003d (SList_Lengthf(heap, list) + 1)) and Heaps_Available(heap)) \u003d\u003e let new:seq of (SList_Data) \u003d SList_Seq(heap, RESULT) in ((SList_Seq(heap~, list) \u003d [new(i) | i in set (inds new) \u0026 (i \u003c\u003e position)]) \u003d\u003e (position in set (inds new)))))","operation establishes postcondition obligation:(forall list:SList_List, data:SList_Data, position:nat1, oldstate:SystemState \u0026 (((position \u003c\u003d (SList_Lengthf(heap, list) + 1)) and Heaps_Available(heap)) \u003d\u003e let new:seq of (SList_Data) \u003d SList_Seq(heap, RESULT) in ((SList_Seq(heap~, list) \u003d [new(i) | i in set (inds new) \u0026 (i \u003c\u003e position)]) and ((new(position) \u003d data) and ((Heaps_AmountUsed(heap~) + 1) \u003d Heaps_AmountUsed(heap))))))","while loop termination obligation:...","operation establishes postcondition obligation:(forall list:SList_List, data:SList_Data, oldstate:SystemState \u0026 (Heaps_Available(heap) \u003d\u003e (((SList_Seq(heap~, list) ^ [data]) \u003d SList_Seq(heap, RESULT)) and ((Heaps_AmountUsed(heap~) + 1) \u003d Heaps_AmountUsed(heap)))))","legal function application obligation:(forall list:SList_List, data:SList_Data, position:nat1, oldstate:SystemState \u0026 ((position \u003c\u003d SList_Lengthf(heap, list)) \u003d\u003e pre_SList_PtrToNode(heap, list, position)))","sequence modification obligation:(forall list:SList_List, data:SList_Data, position:nat1, oldstate:SystemState \u0026 ((position \u003c\u003d SList_Lengthf(heap, list)) \u003d\u003e (true \u003d\u003e ((dom {position |-\u003e data}) subset (inds SList_Seq(heap~, list))))))","operation establishes postcondition obligation:(forall list:SList_List, data:SList_Data, position:nat1, oldstate:SystemState \u0026 ((position \u003c\u003d SList_Lengthf(heap, list)) \u003d\u003e (true \u003d\u003e (((SList_Seq(heap~, list) ++ {position |-\u003e data}) \u003d SList_Seq(heap, RESULT)) and (Heaps_AmountUsed(heap~) \u003d Heaps_AmountUsed(heap))))))","operation call obligation:(forall list:SList_List, oldstate:SystemState \u0026 pre_Heaps_ModifyLoc(heap, address, mk_Heaps_Location(nil, false)))","non-empty sequence obligation:(forall list:SList_List, oldstate:SystemState \u0026 (true \u003d\u003e (SList_Seq(heap~, list) \u003c\u003e [])))","operation establishes postcondition obligation:(forall list:SList_List, oldstate:SystemState \u0026 (true \u003d\u003e ((tl SList_Seq(heap~, list)) \u003d SList_Seq(heap, RESULT))))","operation call obligation:(forall list:SList_List, ptr:Nodes_NodePtr, oldstate:SystemState \u0026 (true \u003d\u003e pre_Heaps_ModifyLoc(heap, address, mk_Heaps_Location(nil, false))))","legal sequence application obligation:(forall list:SList_List, ptr:Nodes_NodePtr, oldstate:SystemState \u0026 (true \u003d\u003e (true \u003d\u003e let old:seq of (SList_Data) \u003d SList_Seq(heap~, ptr) in (1 in set (inds old)))))","non-empty sequence obligation:(forall list:SList_List, ptr:Nodes_NodePtr, oldstate:SystemState \u0026 (true \u003d\u003e (true \u003d\u003e let old:seq of (SList_Data) \u003d SList_Seq(heap~, ptr) in (old \u003c\u003e []))))","non-empty sequence obligation:(forall list:SList_List, ptr:Nodes_NodePtr, oldstate:SystemState \u0026 (true \u003d\u003e (true \u003d\u003e let old:seq of (SList_Data) \u003d SList_Seq(heap~, ptr) in ((tl old) \u003c\u003e []))))","operation establishes postcondition obligation:(forall list:SList_List, ptr:Nodes_NodePtr, oldstate:SystemState \u0026 (true \u003d\u003e (true \u003d\u003e let old:seq of (SList_Data) \u003d SList_Seq(heap~, ptr) in (([old(1)] ^ (tl (tl old))) \u003d SList_Seq(heap, ptr)))))","legal function application obligation:(forall list:SList_List, position:nat1, oldstate:SystemState \u0026 ((position \u003c\u003d SList_Lengthf(heap, list)) \u003d\u003e pre_SList_PtrToNode(heap, list, (position - 1))))","type compatibility obligation:(forall list:SList_List, position:nat1, oldstate:SystemState \u0026 ((position \u003c\u003d SList_Lengthf(heap, list)) \u003d\u003e ((position - 1) \u003e 0)))","legal sequence application obligation:(forall list:SList_List, position:nat1, oldstate:SystemState \u0026 ((position \u003c\u003d SList_Lengthf(heap, list)) \u003d\u003e let old:seq of (SList_Data) \u003d SList_Seq(heap~, list) in (forall i in set (inds old) \u0026 ((i \u003c\u003e position) \u003d\u003e (i in set (inds old))))))","operation establishes postcondition obligation:(forall list:SList_List, position:nat1, oldstate:SystemState \u0026 ((position \u003c\u003d SList_Lengthf(heap, list)) \u003d\u003e let old:seq of (SList_Data) \u003d SList_Seq(heap~, list) in (([old(i) | i in set (inds old) \u0026 (i \u003c\u003e position)] \u003d SList_Seq(heap, RESULT)) and (Heaps_AmountUsed(heap~) \u003d (Heaps_AmountUsed(heap) + 1)))))","while loop termination obligation:...","legal function application obligation:(forall list:SList_List, traversal:(SList_Data -\u003e SList_Data), oldstate:SystemState \u0026 pre_(traversalDATA(ptr)))","legal function application obligation:(forall list:SList_List, traversal:(SList_Data -\u003e SList_Data), oldstate:SystemState \u0026 (true \u003d\u003e let old:seq of (SList_Data) \u003d SList_Seq(heap~, list) in ((old \u003c\u003e []) \u003d\u003e (forall i in set (inds old) \u0026 pre_(traversalold(i))))))","legal sequence application obligation:(forall list:SList_List, traversal:(SList_Data -\u003e SList_Data), oldstate:SystemState \u0026 (true \u003d\u003e let old:seq of (SList_Data) \u003d SList_Seq(heap~, list) in ((old \u003c\u003e []) \u003d\u003e (forall i in set (inds old) \u0026 (i in set (inds old))))))","operation establishes postcondition obligation:(forall list:SList_List, traversal:(SList_Data -\u003e SList_Data), oldstate:SystemState \u0026 (true \u003d\u003e let old:seq of (SList_Data) \u003d SList_Seq(heap~, list) in ((old \u003c\u003e []) \u003d\u003e ([traversal(old(i)) | i in set (inds old)] \u003d SList_Seq(heap, RESULT)))))","legal function application obligation:(forall list:SList_List, position:nat1, oldstate:SystemState \u0026 pre_SList_PtrToNode(heap, list, position))","legal function application obligation:(forall heap:Heaps_Heap, list:DList_List \u0026 pre_Nodes_GetNext(Heaps_Retrieve(heap, list)))","type compatibility obligation:(forall heap:Heaps_Heap, list:DList_List \u0026 ((is_(Heaps_Retrieve(heap, list), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, list), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, list), Nodes_SingleLink)))","legal function application obligation:(forall heap:Heaps_Heap, list:DList_List \u0026 pre_Heaps_Retrieve(heap, list))","legal function application obligation:(forall heap:Heaps_Heap, list:DList_List \u0026 ((list \u003c\u003e NIL) \u003d\u003e pre_Nodes_GetPrev(Heaps_Retrieve(heap, list))))","type compatibility obligation:(forall heap:Heaps_Heap, list:DList_List \u0026 ((list \u003c\u003e NIL) \u003d\u003e ((is_(Heaps_Retrieve(heap, list), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, list), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, list), Nodes_SingleLink))))","legal function application obligation:(forall heap:Heaps_Heap, list:DList_List \u0026 ((list \u003c\u003e NIL) \u003d\u003e pre_Heaps_Retrieve(heap, list)))","legal function application obligation:(forall heap:Heaps_Heap, list:DList_List \u0026 ((list \u003c\u003e NIL) \u003d\u003e let prev:Nodes_NodePtr \u003d Nodes_GetPrev(Heaps_Retrieve(heap, list)) in pre_Nodes_GetData(Heaps_Retrieve(heap, list))))","type compatibility obligation:(forall heap:Heaps_Heap, list:DList_List \u0026 ((list \u003c\u003e NIL) \u003d\u003e let prev:Nodes_NodePtr \u003d Nodes_GetPrev(Heaps_Retrieve(heap, list)) in ((is_(Heaps_Retrieve(heap, list), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, list), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, list), Nodes_SingleLink))))","legal function application obligation:(forall heap:Heaps_Heap, list:DList_List \u0026 ((list \u003c\u003e NIL) \u003d\u003e let prev:Nodes_NodePtr \u003d Nodes_GetPrev(Heaps_Retrieve(heap, list)) in pre_Heaps_Retrieve(heap, list)))","operation establishes postcondition obligation:(forall list:DList_List, data:DList_Data, oldstate:SystemState \u0026 (true \u003d\u003e (([data] ^ SList_Seq(heap~, list)) \u003d SList_Seq(heap, RESULT))))","legal sequence application obligation:(forall list:DList_List, ptr:Nodes_NodePtr, data:DList_Data, oldstate:SystemState \u0026 (true \u003d\u003e (true \u003d\u003e let old:seq of (SList_Data) \u003d SList_Seq(heap~, ptr) in (1 in set (inds old)))))","non-empty sequence obligation:(forall list:DList_List, ptr:Nodes_NodePtr, data:DList_Data, oldstate:SystemState \u0026 (true \u003d\u003e (true \u003d\u003e let old:seq of (SList_Data) \u003d SList_Seq(heap~, ptr) in (old \u003c\u003e []))))","operation establishes postcondition obligation:(forall list:DList_List, ptr:Nodes_NodePtr, data:DList_Data, oldstate:SystemState \u0026 (true \u003d\u003e (true \u003d\u003e let old:seq of (SList_Data) \u003d SList_Seq(heap~, ptr) in ((([old(1)] ^ [data]) ^ (tl old)) \u003d SList_Seq(heap, ptr)))))","legal function application obligation:(forall list:DList_List, data:DList_Data, position:nat1, oldstate:SystemState \u0026 (((position \u003c\u003d (SList_Lengthf(heap, list) + 1)) and (Heaps_Available(heap) and DList_IsList(heap, list))) \u003d\u003e pre_SList_PtrToNode(heap, list, (position - 1))))","type compatibility obligation:(forall list:DList_List, data:DList_Data, position:nat1, oldstate:SystemState \u0026 (((position \u003c\u003d (SList_Lengthf(heap, list) + 1)) and (Heaps_Available(heap) and DList_IsList(heap, list))) \u003d\u003e ((position - 1) \u003e 0)))","legal sequence application obligation:(forall list:DList_List, data:DList_Data, position:nat1, oldstate:SystemState \u0026 (((position \u003c\u003d (SList_Lengthf(heap, list) + 1)) and (Heaps_Available(heap) and DList_IsList(heap, list))) \u003d\u003e (DList_IsList(heap, RESULT) \u003d\u003e let new:seq of (SList_Data) \u003d SList_Seq(heap, RESULT) in (forall i in set (inds new) \u0026 ((i \u003c\u003e position) \u003d\u003e (i in set (inds new)))))))","legal sequence application obligation:(forall list:DList_List, data:DList_Data, position:nat1, oldstate:SystemState \u0026 (((position \u003c\u003d (SList_Lengthf(heap, list) + 1)) and (Heaps_Available(heap) and DList_IsList(heap, list))) \u003d\u003e (DList_IsList(heap, RESULT) \u003d\u003e let new:seq of (SList_Data) \u003d SList_Seq(heap, RESULT) in ((SList_Seq(heap~, list) \u003d [new(i) | i in set (inds new) \u0026 (i \u003c\u003e position)]) \u003d\u003e (position in set (inds new))))))","operation establishes postcondition obligation:(forall list:DList_List, data:DList_Data, position:nat1, oldstate:SystemState \u0026 (((position \u003c\u003d (SList_Lengthf(heap, list) + 1)) and (Heaps_Available(heap) and DList_IsList(heap, list))) \u003d\u003e (DList_IsList(heap, RESULT) and let new:seq of (SList_Data) \u003d SList_Seq(heap, RESULT) in ((SList_Seq(heap~, list) \u003d [new(i) | i in set (inds new) \u0026 (i \u003c\u003e position)]) and (new(position) \u003d data)))))","operation call obligation:(forall list:DList_List, oldstate:SystemState \u0026 (true \u003d\u003e pre_Heaps_ModifyLoc(heap, address, mk_Heaps_Location(nil, false))))","non-empty sequence obligation:(forall list:DList_List, oldstate:SystemState \u0026 (true \u003d\u003e (true \u003d\u003e (SList_Seq(heap~, list) \u003c\u003e []))))","operation establishes postcondition obligation:(forall list:DList_List, oldstate:SystemState \u0026 (true \u003d\u003e (true \u003d\u003e ((tl SList_Seq(heap~, list)) \u003d SList_Seq(heap, RESULT)))))","operation call obligation:(forall list:DList_List, ptr:Nodes_NodePtr, oldstate:SystemState \u0026 (true \u003d\u003e (true \u003d\u003e pre_Heaps_ModifyLoc(heap, address, mk_Heaps_Location(nil, false)))))","legal sequence application obligation:(forall list:DList_List, ptr:Nodes_NodePtr, oldstate:SystemState \u0026 (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e let old:seq of (SList_Data) \u003d SList_Seq(heap~, ptr) in (1 in set (inds old))))))","non-empty sequence obligation:(forall list:DList_List, ptr:Nodes_NodePtr, oldstate:SystemState \u0026 (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e let old:seq of (SList_Data) \u003d SList_Seq(heap~, ptr) in (old \u003c\u003e [])))))","non-empty sequence obligation:(forall list:DList_List, ptr:Nodes_NodePtr, oldstate:SystemState \u0026 (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e let old:seq of (SList_Data) \u003d SList_Seq(heap~, ptr) in ((tl old) \u003c\u003e [])))))","operation establishes postcondition obligation:(forall list:DList_List, ptr:Nodes_NodePtr, oldstate:SystemState \u0026 (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e let old:seq of (SList_Data) \u003d SList_Seq(heap~, ptr) in (([old(1)] ^ (tl (tl old))) \u003d SList_Seq(heap, ptr))))))","legal function application obligation:(forall list:DList_List, position:nat1, oldstate:SystemState \u0026 (((position \u003c\u003d SList_Lengthf(heap, list)) and DList_IsList(heap, list)) \u003d\u003e pre_SList_PtrToNode(heap, list, (position - 1))))","type compatibility obligation:(forall list:DList_List, position:nat1, oldstate:SystemState \u0026 (((position \u003c\u003d SList_Lengthf(heap, list)) and DList_IsList(heap, list)) \u003d\u003e ((position - 1) \u003e 0)))","legal sequence application obligation:(forall list:DList_List, position:nat1, oldstate:SystemState \u0026 (((position \u003c\u003d SList_Lengthf(heap, list)) and DList_IsList(heap, list)) \u003d\u003e (DList_IsList(heap, RESULT) \u003d\u003e let old:seq of (SList_Data) \u003d SList_Seq(heap~, list) in (forall i in set (inds old) \u0026 ((i \u003c\u003e position) \u003d\u003e (i in set (inds old)))))))","operation establishes postcondition obligation:(forall list:DList_List, position:nat1, oldstate:SystemState \u0026 (((position \u003c\u003d SList_Lengthf(heap, list)) and DList_IsList(heap, list)) \u003d\u003e (DList_IsList(heap, RESULT) and let old:seq of (SList_Data) \u003d SList_Seq(heap~, list) in (([old(i) | i in set (inds old) \u0026 (i \u003c\u003e position)] \u003d SList_Seq(heap, RESULT)) and (Heaps_AmountUsed(heap~) \u003d (Heaps_AmountUsed(heap) + 1))))))","while loop termination obligation:...","operation establishes postcondition obligation:(forall list:DList_List, data:DList_Data, oldstate:SystemState \u0026 ((Heaps_Available(heap) and DList_IsList(heap, list)) \u003d\u003e (((SList_Seq(heap~, list) ^ [data]) \u003d SList_Seq(heap, RESULT)) and (((Heaps_AmountUsed(heap~) + 1) \u003d Heaps_AmountUsed(heap)) and DList_IsList(heap, RESULT)))))","operation call obligation:(forall list:DList_List, data:DList_Data, position:nat1, oldstate:SystemState \u0026 (list \u003c\u003d SList_Lengthf(heap, list)))","type compatibility obligation:(forall queue:Queues_Queue, oldstate:SystemState \u0026 is_(RESULT, (Queues_Queue * Queues_Data)))","type compatibility obligation:(forall stack:Stacks_Stack, oldstate:SystemState \u0026 is_(RESULT, (Stacks_Stack * Stacks_Data)))","legal function application obligation:(forall tree:set of (STrees_Node) \u0026 (forall node in set tree \u0026 pre_STrees_IsRoot(tree, node)))","legal function application obligation:(forall tree:set of (STrees_Node) \u0026 (forall node in set tree \u0026 pre_STrees_IsChild(tree, node)))","legal function application obligation:(forall tree:set of (STrees_Node) \u0026 ((forall node in set tree \u0026 ((not STrees_IsRoot(tree, node)) \u003c\u003d\u003e (STrees_IsChild(tree, node) and STrees_IsUnique(tree, node)))) \u003d\u003e (forall node in set tree \u0026 pre_STrees_IsRoot(tree, node))))","type invariant satisfiable obligation:(exists tree:STrees_Tree \u0026 ((forall node in set tree \u0026 ((not STrees_IsRoot(tree, node)) \u003c\u003d\u003e (STrees_IsChild(tree, node) and STrees_IsUnique(tree, node)))) and ((tree \u003c\u003e {}) \u003c\u003d\u003e (exists1 node in set tree \u0026 STrees_IsRoot(tree, node)))))","legal function application obligation:(forall mk_STrees_Info(t, c):STrees_Info \u0026 (((c \u003d nil) \u003c\u003d\u003e (t \u003d {})) \u003d\u003e ((c in set t) \u003d\u003e pre_STrees_Root(t))))","type invariant satisfiable obligation:(exists mk_STrees_Info(t, c):STrees_Info \u0026 (((c \u003d nil) \u003c\u003d\u003e (t \u003d {})) and ((c \u003c\u003e nil) \u003c\u003d\u003e ((c in set t) and let r:STrees_Node \u003d STrees_Root(t) in ((r.position) \u003d 1)))))","type compatibility obligation:(forall tree:set of (STrees_Node) \u0026 (inv_STrees_Tree(tree) \u003d\u003e inv_STrees_Tree(tree)))","type compatibility obligation:(forall tree:STrees_Tree, current:STrees_Node \u0026 inv_STrees_Info(mk_STrees_Info(tree, current)))","type compatibility obligation:(forall tree:STrees_Tree, current:STrees_Node \u0026 (inv_STrees_Info(mk_STrees_Info(tree, current)) \u003d\u003e inv_STrees_Info(mk_STrees_Info(tree, current))))","type compatibility obligation:inv_STrees_Tree({})","type compatibility obligation:(inv_STrees_Info(mk_STrees_Info({}, nil)) and inv_STrees_Tree({}))","legal function application obligation:(forall tree:set of (STrees_Node), mk_STrees_Node(dr, pr):STrees_Node \u0026 ((mk_STrees_Node(dr, pr) in set tree) \u003d\u003e pre_STrees_IsChild(tree, mk_STrees_Node(dr, pr))))","legal function application obligation:(forall tree:STrees_Tree, node:STrees_Node \u0026 ((node in set tree) \u003d\u003e (forall child in set tree \u0026 pre_STrees_IsParentOf(tree, node, child))))","legal function application obligation:(forall tree:set of (STrees_Node), node:STrees_Node \u0026 ((node in set tree) \u003d\u003e (forall parent in set tree \u0026 pre_STrees_IsParentOf(tree, parent, node))))","legal function application obligation:(forall tree:set of (STrees_Node), node:STrees_Node \u0026 ((node in set tree) \u003d\u003e ((exists parent in set tree \u0026 STrees_IsParentOf(tree, parent, node)) \u003d\u003e (forall parent in set tree \u0026 pre_STrees_IsParentOf(tree, parent, node)))))","legal function application obligation:(forall tree:set of (STrees_Node), node1:STrees_Node, node2:STrees_Node \u0026 (((node1 in set tree) and (node2 in set tree)) \u003d\u003e pre_STrees_IsRightChildOf(tree, node2, node1)))","legal function application obligation:(forall tree:set of (STrees_Node), node1:STrees_Node, node2:STrees_Node \u0026 (((node1 in set tree) and (node2 in set tree)) \u003d\u003e ((not STrees_IsRightChildOf(tree, node2, node1)) \u003d\u003e pre_STrees_IsLeftChildOf(tree, node2, node1))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info, data:STrees_Data, direction:STrees_Direction \u0026 (((direction \u003d \u003cToRoot\u003e) \u003d\u003e (tree \u003d {})) \u003d\u003e ((direction \u003d \u003cToLeft\u003e) \u003d\u003e pre_STrees_HasLeftChild(tree, current))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info, data:STrees_Data, direction:STrees_Direction \u0026 (((direction \u003d \u003cToRoot\u003e) \u003d\u003e (tree \u003d {})) \u003d\u003e ((direction \u003d \u003cToLeft\u003e) \u003d\u003e is_(current, STrees_Node))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info, data:STrees_Data, direction:STrees_Direction \u0026 (((direction \u003d \u003cToRoot\u003e) \u003d\u003e (tree \u003d {})) \u003d\u003e (((direction \u003d \u003cToLeft\u003e) \u003d\u003e (not STrees_HasLeftChild(tree, current))) \u003d\u003e ((direction \u003d \u003cToRight\u003e) \u003d\u003e pre_STrees_HasRightChild(tree, current)))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info, data:STrees_Data, direction:STrees_Direction \u0026 (((direction \u003d \u003cToRoot\u003e) \u003d\u003e (tree \u003d {})) \u003d\u003e (((direction \u003d \u003cToLeft\u003e) \u003d\u003e (not STrees_HasLeftChild(tree, current))) \u003d\u003e ((direction \u003d \u003cToRight\u003e) \u003d\u003e is_(current, STrees_Node)))))","function establishes postcondition obligation:(forall mk_STrees_Info(tree, current):STrees_Info, data:STrees_Data, direction:STrees_Direction \u0026 (pre_STrees_Insert(mk_STrees_Info(tree, current), data, direction) \u003d\u003e post_STrees_Insert(mk_STrees_Info(tree, current), data, direction, (cases mk_(current, direction) :\nmk_(nil, \u003cToRoot\u003e) -\u003e STrees_InsertRoot(data),\nmk_(-, \u003cToLeft\u003e) -\u003e STrees_InsertLeft(tree, current, data),\nmk_(-, \u003cToRight\u003e) -\u003e STrees_InsertRight(tree, current, data)\n end))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info, data:STrees_Data, direction:STrees_Direction \u0026 ((((direction \u003d \u003cToRoot\u003e) \u003d\u003e (tree \u003d {})) and (((direction \u003d \u003cToLeft\u003e) \u003d\u003e (not STrees_HasLeftChild(tree, current))) and ((direction \u003d \u003cToRight\u003e) \u003d\u003e (not STrees_HasRightChild(tree, current))))) \u003d\u003e ((not (mk_(nil, \u003cToRoot\u003e) \u003d mk_(current, direction))) \u003d\u003e (exists mk_(-, \u003cToLeft\u003e):([STrees_Node] * STrees_Direction) \u0026 ((mk_(any1, \u003cToLeft\u003e) \u003d mk_(current, direction)) \u003d\u003e let mk_(-, \u003cToLeft\u003e) \u003d mk_(current, direction) in pre_STrees_InsertLeft(tree, current, data))))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info, data:STrees_Data, direction:STrees_Direction \u0026 ((((direction \u003d \u003cToRoot\u003e) \u003d\u003e (tree \u003d {})) and (((direction \u003d \u003cToLeft\u003e) \u003d\u003e (not STrees_HasLeftChild(tree, current))) and ((direction \u003d \u003cToRight\u003e) \u003d\u003e (not STrees_HasRightChild(tree, current))))) \u003d\u003e ((not (mk_(nil, \u003cToRoot\u003e) \u003d mk_(current, direction))) \u003d\u003e (exists mk_(-, \u003cToLeft\u003e):([STrees_Node] * STrees_Direction) \u0026 ((mk_(any1, \u003cToLeft\u003e) \u003d mk_(current, direction)) \u003d\u003e let mk_(-, \u003cToLeft\u003e) \u003d mk_(current, direction) in is_(current, STrees_Node))))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info, data:STrees_Data, direction:STrees_Direction \u0026 ((((direction \u003d \u003cToRoot\u003e) \u003d\u003e (tree \u003d {})) and (((direction \u003d \u003cToLeft\u003e) \u003d\u003e (not STrees_HasLeftChild(tree, current))) and ((direction \u003d \u003cToRight\u003e) \u003d\u003e (not STrees_HasRightChild(tree, current))))) \u003d\u003e ((not (mk_(nil, \u003cToRoot\u003e) \u003d mk_(current, direction))) \u003d\u003e ((not (exists mk_(-, \u003cToLeft\u003e):([STrees_Node] * STrees_Direction) \u0026 (mk_(any1, \u003cToLeft\u003e) \u003d mk_(current, direction)))) \u003d\u003e (exists mk_(-, \u003cToRight\u003e):([STrees_Node] * STrees_Direction) \u0026 ((mk_(any1, \u003cToRight\u003e) \u003d mk_(current, direction)) \u003d\u003e let mk_(-, \u003cToRight\u003e) \u003d mk_(current, direction) in pre_STrees_InsertRight(tree, current, data)))))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info, data:STrees_Data, direction:STrees_Direction \u0026 ((((direction \u003d \u003cToRoot\u003e) \u003d\u003e (tree \u003d {})) and (((direction \u003d \u003cToLeft\u003e) \u003d\u003e (not STrees_HasLeftChild(tree, current))) and ((direction \u003d \u003cToRight\u003e) \u003d\u003e (not STrees_HasRightChild(tree, current))))) \u003d\u003e ((not (mk_(nil, \u003cToRoot\u003e) \u003d mk_(current, direction))) \u003d\u003e ((not (exists mk_(-, \u003cToLeft\u003e):([STrees_Node] * STrees_Direction) \u0026 (mk_(any1, \u003cToLeft\u003e) \u003d mk_(current, direction)))) \u003d\u003e (exists mk_(-, \u003cToRight\u003e):([STrees_Node] * STrees_Direction) \u0026 ((mk_(any1, \u003cToRight\u003e) \u003d mk_(current, direction)) \u003d\u003e let mk_(-, \u003cToRight\u003e) \u003d mk_(current, direction) in is_(current, STrees_Node)))))))","cases exhaustive obligation:(forall mk_STrees_Info(tree, current):STrees_Info, data:STrees_Data, direction:STrees_Direction \u0026 ((((direction \u003d \u003cToRoot\u003e) \u003d\u003e (tree \u003d {})) and (((direction \u003d \u003cToLeft\u003e) \u003d\u003e (not STrees_HasLeftChild(tree, current))) and ((direction \u003d \u003cToRight\u003e) \u003d\u003e (not STrees_HasRightChild(tree, current))))) \u003d\u003e (((mk_(current, direction) \u003d mk_(nil, \u003cToRoot\u003e)) or (exists mk_(-, \u003cToLeft\u003e):([STrees_Node] * STrees_Direction) \u0026 (mk_(current, direction) \u003d mk_(any1, \u003cToLeft\u003e)))) or (exists mk_(-, \u003cToRight\u003e):([STrees_Node] * STrees_Direction) \u0026 (mk_(current, direction) \u003d mk_(any1, \u003cToRight\u003e))))))","type compatibility obligation:(forall data:STrees_Data \u0026 let root:STrees_Node \u003d mk_STrees_Node(data, 1) in inv_STrees_Tree({root}))","type compatibility obligation:(forall data:STrees_Data \u0026 let root:STrees_Node \u003d mk_STrees_Node(data, 1) in (inv_STrees_Info(mk_STrees_Info({root}, root)) and inv_STrees_Tree({root})))","legal function application obligation:(forall tree:STrees_Tree, current:STrees_Node, data:STrees_Data \u0026 pre_STrees_HasLeftChild(tree, current))","type compatibility obligation:(forall tree:STrees_Tree, current:STrees_Node, data:STrees_Data \u0026 ((not STrees_HasLeftChild(tree, current)) \u003d\u003e let mk_STrees_Node(-, position):STrees_Node \u003d current in let new:STrees_Node \u003d mk_STrees_Node(data, (2 * position)) in inv_STrees_Tree((tree union {new}))))","type compatibility obligation:(forall tree:STrees_Tree, current:STrees_Node, data:STrees_Data \u0026 ((not STrees_HasLeftChild(tree, current)) \u003d\u003e let mk_STrees_Node(-, position):STrees_Node \u003d current in let new:STrees_Node \u003d mk_STrees_Node(data, (2 * position)) in (inv_STrees_Info(mk_STrees_Info((tree union {new}), new)) and inv_STrees_Tree((tree union {new})))))","legal function application obligation:(forall tree:STrees_Tree, current:STrees_Node, data:STrees_Data \u0026 pre_STrees_HasRightChild(tree, current))","type compatibility obligation:(forall tree:STrees_Tree, current:STrees_Node, data:STrees_Data \u0026 ((not STrees_HasRightChild(tree, current)) \u003d\u003e let mk_STrees_Node(-, position):STrees_Node \u003d current in let new:STrees_Node \u003d mk_STrees_Node(data, ((2 * position) + 1)) in inv_STrees_Tree((tree union {new}))))","type compatibility obligation:(forall tree:STrees_Tree, current:STrees_Node, data:STrees_Data \u0026 ((not STrees_HasRightChild(tree, current)) \u003d\u003e let mk_STrees_Node(-, position):STrees_Node \u003d current in let new:STrees_Node \u003d mk_STrees_Node(data, ((2 * position) + 1)) in (inv_STrees_Info(mk_STrees_Info((tree union {new}), new)) and inv_STrees_Tree((tree union {new})))))","legal function application obligation:(forall treeinfo:STrees_Info, traversal:(STrees_Data -\u003e STrees_Data) \u0026 let mk_STrees_Info(tree, current):STrees_Info \u003d treeinfo in ((current \u003c\u003e nil) \u003d\u003e let mk_STrees_Node(data, position):[STrees_Node] \u003d current in (forall mk_STrees_Node(data, position) in set tree \u0026 pre_(traversaldata))))","legal function application obligation:(forall treeinfo:STrees_Info, traversal:(STrees_Data -\u003e STrees_Data) \u0026 let mk_STrees_Info(tree, current):STrees_Info \u003d treeinfo in ((current \u003c\u003e nil) \u003d\u003e let mk_STrees_Node(data, position):[STrees_Node] \u003d current in let newtree:set of (STrees_Node) \u003d {mk_STrees_Node(traversal(data), position) | mk_STrees_Node(data, position) in set tree} in pre_(traversaldata)))","type compatibility obligation:(forall treeinfo:STrees_Info, traversal:(STrees_Data -\u003e STrees_Data) \u0026 let mk_STrees_Info(tree, current):STrees_Info \u003d treeinfo in ((current \u003c\u003e nil) \u003d\u003e let mk_STrees_Node(data, position):[STrees_Node] \u003d current in let newtree:set of (STrees_Node) \u003d {mk_STrees_Node(traversal(data), position) | mk_STrees_Node(data, position) in set tree} in inv_STrees_Tree(newtree)))","type compatibility obligation:(forall treeinfo:STrees_Info, traversal:(STrees_Data -\u003e STrees_Data) \u0026 let mk_STrees_Info(tree, current):STrees_Info \u003d treeinfo in ((current \u003c\u003e nil) \u003d\u003e let mk_STrees_Node(data, position):[STrees_Node] \u003d current in let newtree:set of (STrees_Node) \u003d {mk_STrees_Node(traversal(data), position) | mk_STrees_Node(data, position) in set tree} in (inv_STrees_Info(mk_STrees_Info(newtree, mk_STrees_Node(traversal(data), position))) and inv_STrees_Tree(newtree))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info, direction:STrees_Direction \u0026 inv_STrees_Info(mk_STrees_Info(tree, current)))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info, direction:STrees_Direction \u0026 (STrees_ExistsDirection(mk_STrees_Info(tree, current), direction) \u003d\u003e ((\u003cToRoot\u003e \u003d direction) \u003d\u003e pre_STrees_Root(tree))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info, direction:STrees_Direction \u0026 (STrees_ExistsDirection(mk_STrees_Info(tree, current), direction) \u003d\u003e ((\u003cToRoot\u003e \u003d direction) \u003d\u003e inv_STrees_Info(mk_STrees_Info(tree, STrees_Root(tree))))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info, direction:STrees_Direction \u0026 (STrees_ExistsDirection(mk_STrees_Info(tree, current), direction) \u003d\u003e ((not (\u003cToRoot\u003e \u003d direction)) \u003d\u003e ((\u003cToLeft\u003e \u003d direction) \u003d\u003e pre_STrees_LeftChild(tree, current)))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info, direction:STrees_Direction \u0026 (STrees_ExistsDirection(mk_STrees_Info(tree, current), direction) \u003d\u003e ((not (\u003cToRoot\u003e \u003d direction)) \u003d\u003e ((\u003cToLeft\u003e \u003d direction) \u003d\u003e is_(current, STrees_Node)))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info, direction:STrees_Direction \u0026 (STrees_ExistsDirection(mk_STrees_Info(tree, current), direction) \u003d\u003e ((not (\u003cToRoot\u003e \u003d direction)) \u003d\u003e ((\u003cToLeft\u003e \u003d direction) \u003d\u003e inv_STrees_Info(mk_STrees_Info(tree, STrees_LeftChild(tree, current)))))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info, direction:STrees_Direction \u0026 (STrees_ExistsDirection(mk_STrees_Info(tree, current), direction) \u003d\u003e ((not (\u003cToRoot\u003e \u003d direction)) \u003d\u003e ((not (\u003cToLeft\u003e \u003d direction)) \u003d\u003e ((\u003cToRight\u003e \u003d direction) \u003d\u003e pre_STrees_RightChild(tree, current))))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info, direction:STrees_Direction \u0026 (STrees_ExistsDirection(mk_STrees_Info(tree, current), direction) \u003d\u003e ((not (\u003cToRoot\u003e \u003d direction)) \u003d\u003e ((not (\u003cToLeft\u003e \u003d direction)) \u003d\u003e ((\u003cToRight\u003e \u003d direction) \u003d\u003e is_(current, STrees_Node))))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info, direction:STrees_Direction \u0026 (STrees_ExistsDirection(mk_STrees_Info(tree, current), direction) \u003d\u003e ((not (\u003cToRoot\u003e \u003d direction)) \u003d\u003e ((not (\u003cToLeft\u003e \u003d direction)) \u003d\u003e ((\u003cToRight\u003e \u003d direction) \u003d\u003e inv_STrees_Info(mk_STrees_Info(tree, STrees_RightChild(tree, current))))))))","cases exhaustive obligation:(forall mk_STrees_Info(tree, current):STrees_Info, direction:STrees_Direction \u0026 (STrees_ExistsDirection(mk_STrees_Info(tree, current), direction) \u003d\u003e (((direction \u003d \u003cToRoot\u003e) or (direction \u003d \u003cToLeft\u003e)) or (direction \u003d \u003cToRight\u003e))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info, position:nat1 \u0026 inv_STrees_Info(mk_STrees_Info(tree, current)))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info, position:nat1 \u0026 (STrees_ExistsNode(mk_STrees_Info(tree, current), position) \u003d\u003e pre_STrees_GetNode(tree, position)))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info, position:nat1 \u0026 (STrees_ExistsNode(mk_STrees_Info(tree, current), position) \u003d\u003e inv_STrees_Info(mk_STrees_Info(tree, STrees_GetNode(tree, position)))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 pre_STrees_IsRoot(tree, current))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 is_(current, STrees_Node))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((not STrees_IsRoot(tree, current)) \u003d\u003e pre_STrees_Parent(tree, current)))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((not STrees_IsRoot(tree, current)) \u003d\u003e is_(current, STrees_Node)))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((not STrees_IsRoot(tree, current)) \u003d\u003e inv_STrees_Info(mk_STrees_Info(tree, STrees_Parent(tree, current)))))","legal function application obligation:(forall treeinfo:STrees_Info, pathlength:nat1 \u0026 (pre_STrees_MoveToParent(treeinfo) \u003d\u003e ((pathlength \u003e 1) \u003d\u003e pre_STrees_MoveToAnscestor(STrees_MoveToParent(treeinfo), (pathlength - 1)))))","type compatibility obligation:(forall treeinfo:STrees_Info, pathlength:nat1 \u0026 (pre_STrees_MoveToParent(treeinfo) \u003d\u003e ((pathlength \u003e 1) \u003d\u003e ((pathlength - 1) \u003e 0))))","legal function application obligation:(forall treeinfo:STrees_Info, pathlength:nat1 \u0026 (pre_STrees_MoveToParent(treeinfo) \u003d\u003e ((pathlength \u003e 1) \u003d\u003e pre_STrees_MoveToParent(treeinfo))))","legal function application obligation:(forall treeinfo:STrees_Info, pathlength:nat1 \u0026 (pre_STrees_MoveToParent(treeinfo) \u003d\u003e ((not (pathlength \u003e 1)) \u003d\u003e pre_STrees_MoveToParent(treeinfo))))","unique existence binding obligation:(forall tree:STrees_Tree \u0026 ((tree \u003c\u003e {}) \u003d\u003e (exists1 root in set tree \u0026 STrees_IsRoot(tree, root))))","legal function application obligation:(forall tree:STrees_Tree \u0026 ((tree \u003c\u003e {}) \u003d\u003e (forall root in set tree \u0026 pre_STrees_IsRoot(tree, root))))","legal function application obligation:(forall tree:STrees_Tree, node:STrees_Node \u0026 ((node in set tree) \u003d\u003e pre_STrees_IsRoot(tree, node)))","unique existence binding obligation:(forall tree:STrees_Tree, node:STrees_Node \u0026 (((node in set tree) and (not STrees_IsRoot(tree, node))) \u003d\u003e (exists1 parent in set tree \u0026 STrees_IsParentOf(tree, parent, node))))","legal function application obligation:(forall tree:STrees_Tree, node:STrees_Node \u0026 (((node in set tree) and (not STrees_IsRoot(tree, node))) \u003d\u003e (forall parent in set tree \u0026 pre_STrees_IsParentOf(tree, parent, node))))","legal function application obligation:(forall tree:STrees_Tree, parent:STrees_Node \u0026 ((parent in set tree) \u003d\u003e pre_STrees_HasLeftChild(tree, parent)))","unique existence binding obligation:(forall tree:STrees_Tree, parent:STrees_Node \u0026 (((parent in set tree) and STrees_HasLeftChild(tree, parent)) \u003d\u003e (exists1 leftchild in set tree \u0026 STrees_IsLeftChildOf(tree, leftchild, parent))))","legal function application obligation:(forall tree:STrees_Tree, parent:STrees_Node \u0026 (((parent in set tree) and STrees_HasLeftChild(tree, parent)) \u003d\u003e (forall leftchild in set tree \u0026 pre_STrees_IsLeftChildOf(tree, leftchild, parent))))","legal function application obligation:(forall tree:STrees_Tree, parent:STrees_Node \u0026 ((parent in set tree) \u003d\u003e pre_STrees_HasRightChild(tree, parent)))","unique existence binding obligation:(forall tree:STrees_Tree, parent:STrees_Node \u0026 (((parent in set tree) and STrees_HasRightChild(tree, parent)) \u003d\u003e (exists1 rightchild in set tree \u0026 STrees_IsRightChildOf(tree, rightchild, parent))))","legal function application obligation:(forall tree:STrees_Tree, parent:STrees_Node \u0026 (((parent in set tree) and STrees_HasRightChild(tree, parent)) \u003d\u003e (forall rightchild in set tree \u0026 pre_STrees_IsRightChildOf(tree, rightchild, parent))))","unique existence binding obligation:(forall tree:STrees_Tree, position:nat1 \u0026 ((exists node in set tree \u0026 ((node.position) \u003d position)) \u003d\u003e (exists1 node in set tree \u0026 ((node.position) \u003d position))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info, position:nat1 \u0026 inv_STrees_Info(mk_STrees_Info(tree, current)))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info, position:nat1 \u0026 (STrees_ExistsNode(mk_STrees_Info(tree, current), position) \u003d\u003e pre_STrees_GetNode(tree, position)))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info, data:STrees_Data \u0026 ((current \u003c\u003e nil) \u003d\u003e let mk_STrees_Node(-, position):[STrees_Node] \u003d current in let newcurrent:STrees_Node \u003d mk_STrees_Node(data, position) in inv_STrees_Tree(((tree \\ {current}) union {newcurrent}))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info, data:STrees_Data \u0026 ((current \u003c\u003e nil) \u003d\u003e let mk_STrees_Node(-, position):[STrees_Node] \u003d current in let newcurrent:STrees_Node \u003d mk_STrees_Node(data, position) in (inv_STrees_Info(mk_STrees_Info(((tree \\ {current}) union {newcurrent}), newcurrent)) and inv_STrees_Tree(((tree \\ {current}) union {newcurrent})))))","type compatibility obligation:(forall mk_STrees_Info(-, current):STrees_Info \u0026 is_(current, STrees_Node))","type compatibility obligation:(forall mk_STrees_Info(tree, -):STrees_Info, newcurrent:STrees_Node \u0026 ((newcurrent in set tree) \u003d\u003e inv_STrees_Info(mk_STrees_Info(tree, newcurrent))))","legal function application obligation:(forall tree:STrees_Tree, parent:STrees_Node \u0026 ((parent in set tree) \u003d\u003e (forall child in set tree \u0026 pre_STrees_IsLeftChildOf(tree, child, parent))))","legal function application obligation:(forall tree:STrees_Tree, parent:STrees_Node \u0026 ((parent in set tree) \u003d\u003e (forall child in set tree \u0026 pre_STrees_IsRightChildOf(tree, child, parent))))","legal function application obligation:(forall tree:STrees_Tree, node:STrees_Node \u0026 ((node in set tree) \u003d\u003e pre_STrees_HasLeftChild(tree, node)))","legal function application obligation:(forall tree:STrees_Tree, node:STrees_Node \u0026 (((node in set tree) and STrees_HasLeftChild(tree, node)) \u003d\u003e pre_STrees_LeftChild(tree, node)))","legal function application obligation:(forall tree:STrees_Tree, node:STrees_Node \u0026 (((node in set tree) and STrees_HasLeftChild(tree, node)) \u003d\u003e let leftchild:STrees_Node \u003d STrees_LeftChild(tree, node) in pre_STrees_Subtree(tree, leftchild)))","unique existence binding obligation:(forall tree:STrees_Tree, node:STrees_Node \u0026 (((node in set tree) and STrees_HasLeftChild(tree, node)) \u003d\u003e let leftchild:STrees_Node \u003d STrees_LeftChild(tree, node) in let left:STrees_Tree \u003d STrees_Subtree(tree, leftchild) in let rightpath:set of (STrees_Node) \u003d {n | n in set left \u0026 (exists p in set {0, ... ,(card left)} \u0026 ((n.position) \u003d ((((leftchild.position) + 1) * (2 ** p)) - 1)))} in (exists1 pred in set rightpath \u0026 (forall n in set rightpath \u0026 ((n.position) \u003c\u003d (pred.position))))))","function establishes postcondition obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 (pre_STrees_Delete(mk_STrees_Info(tree, current)) \u003d\u003e post_STrees_Delete(mk_STrees_Info(tree, current), let old:STrees_Tree \u003d STrees_Subtree(tree, current) in (if (STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current))\nthen let leftchild:STrees_Node \u003d STrees_LeftChild(tree, current), rightchild:STrees_Node \u003d STrees_RightChild(tree, current), left:STrees_Tree \u003d STrees_Subtree(old, leftchild), mk_STrees_Node(-, position):STrees_Node \u003d STrees_InOrderPredecessor(old, current), newright:STrees_Tree \u003d STrees_MoveSubtree(old, rightchild, ((2 * position) + 1)), newleft:STrees_Tree \u003d (left union newright), new:STrees_Tree \u003d STrees_MoveSubtree(newleft, STrees_Root(newleft), (current.position)) in mk_STrees_Info(((tree \\ old) union new), STrees_Root(new))\nelseif STrees_HasLeftChild(tree, current)\nthen let leftchild:STrees_Node \u003d STrees_LeftChild(tree, current), new:STrees_Tree \u003d STrees_MoveSubtree(old, leftchild, (current.position)) in mk_STrees_Info(((tree \\ old) union new), STrees_Root(new))\nelseif STrees_HasRightChild(tree, current)\nthen let rightchild:STrees_Node \u003d STrees_RightChild(tree, current), new:STrees_Tree \u003d STrees_MoveSubtree(old, rightchild, (current.position)) in mk_STrees_Info(((tree \\ old) union new), STrees_Root(new))\nelse mk_STrees_Info((tree \\ {current}), STrees_Parent(tree, current))))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e pre_STrees_Subtree(tree, current)))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e is_(current, STrees_Node)))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in pre_STrees_HasRightChild(tree, current)))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in is_(current, STrees_Node)))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in (STrees_HasRightChild(tree, current) \u003d\u003e pre_STrees_HasLeftChild(tree, current))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in (STrees_HasRightChild(tree, current) \u003d\u003e is_(current, STrees_Node))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current)) \u003d\u003e pre_STrees_LeftChild(tree, current))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current)) \u003d\u003e is_(current, STrees_Node))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current)) \u003d\u003e pre_STrees_RightChild(tree, current))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current)) \u003d\u003e is_(current, STrees_Node))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current)) \u003d\u003e pre_STrees_Subtree(old, leftchild))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current)) \u003d\u003e pre_STrees_InOrderPredecessor(old, current))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current)) \u003d\u003e is_(current, STrees_Node))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current)) \u003d\u003e pre_STrees_MoveSubtree(old, rightchild, ((2 * position) + 1)))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current)) \u003d\u003e pre_STrees_MoveSubtree(newleft, STrees_Root(newleft), (current.position)))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current)) \u003d\u003e pre_STrees_Root(newleft))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current)) \u003d\u003e let leftchild:STrees_Node \u003d STrees_LeftChild(tree, current), rightchild:STrees_Node \u003d STrees_RightChild(tree, current), left:STrees_Tree \u003d STrees_Subtree(old, leftchild), mk_STrees_Node(-, position):STrees_Node \u003d STrees_InOrderPredecessor(old, current), newright:STrees_Tree \u003d STrees_MoveSubtree(old, rightchild, ((2 * position) + 1)), newleft:STrees_Tree \u003d (left union newright), new:STrees_Tree \u003d STrees_MoveSubtree(newleft, STrees_Root(newleft), (current.position)) in pre_STrees_Root(new))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current)) \u003d\u003e let leftchild:STrees_Node \u003d STrees_LeftChild(tree, current), rightchild:STrees_Node \u003d STrees_RightChild(tree, current), left:STrees_Tree \u003d STrees_Subtree(old, leftchild), mk_STrees_Node(-, position):STrees_Node \u003d STrees_InOrderPredecessor(old, current), newright:STrees_Tree \u003d STrees_MoveSubtree(old, rightchild, ((2 * position) + 1)), newleft:STrees_Tree \u003d (left union newright), new:STrees_Tree \u003d STrees_MoveSubtree(newleft, STrees_Root(newleft), (current.position)) in inv_STrees_Info(mk_STrees_Info(((tree \\ old) union new), STrees_Root(new))))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((not (STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current))) \u003d\u003e (STrees_HasLeftChild(tree, current) \u003d\u003e pre_STrees_LeftChild(tree, current)))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((not (STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current))) \u003d\u003e (STrees_HasLeftChild(tree, current) \u003d\u003e is_(current, STrees_Node)))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((not (STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current))) \u003d\u003e (STrees_HasLeftChild(tree, current) \u003d\u003e pre_STrees_MoveSubtree(old, leftchild, (current.position))))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((not (STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current))) \u003d\u003e (STrees_HasLeftChild(tree, current) \u003d\u003e let leftchild:STrees_Node \u003d STrees_LeftChild(tree, current), new:STrees_Tree \u003d STrees_MoveSubtree(old, leftchild, (current.position)) in pre_STrees_Root(new)))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((not (STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current))) \u003d\u003e (STrees_HasLeftChild(tree, current) \u003d\u003e let leftchild:STrees_Node \u003d STrees_LeftChild(tree, current), new:STrees_Tree \u003d STrees_MoveSubtree(old, leftchild, (current.position)) in inv_STrees_Info(mk_STrees_Info(((tree \\ old) union new), STrees_Root(new)))))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((not (STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current))) \u003d\u003e ((not STrees_HasLeftChild(tree, current)) \u003d\u003e (STrees_HasRightChild(tree, current) \u003d\u003e pre_STrees_RightChild(tree, current))))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((not (STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current))) \u003d\u003e ((not STrees_HasLeftChild(tree, current)) \u003d\u003e (STrees_HasRightChild(tree, current) \u003d\u003e is_(current, STrees_Node))))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((not (STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current))) \u003d\u003e ((not STrees_HasLeftChild(tree, current)) \u003d\u003e (STrees_HasRightChild(tree, current) \u003d\u003e pre_STrees_MoveSubtree(old, rightchild, (current.position)))))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((not (STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current))) \u003d\u003e ((not STrees_HasLeftChild(tree, current)) \u003d\u003e (STrees_HasRightChild(tree, current) \u003d\u003e let rightchild:STrees_Node \u003d STrees_RightChild(tree, current), new:STrees_Tree \u003d STrees_MoveSubtree(old, rightchild, (current.position)) in pre_STrees_Root(new))))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((not (STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current))) \u003d\u003e ((not STrees_HasLeftChild(tree, current)) \u003d\u003e (STrees_HasRightChild(tree, current) \u003d\u003e let rightchild:STrees_Node \u003d STrees_RightChild(tree, current), new:STrees_Tree \u003d STrees_MoveSubtree(old, rightchild, (current.position)) in inv_STrees_Info(mk_STrees_Info(((tree \\ old) union new), STrees_Root(new))))))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((not (STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current))) \u003d\u003e ((not STrees_HasLeftChild(tree, current)) \u003d\u003e ((not STrees_HasRightChild(tree, current)) \u003d\u003e pre_STrees_Parent(tree, current))))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((not (STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current))) \u003d\u003e ((not STrees_HasLeftChild(tree, current)) \u003d\u003e ((not STrees_HasRightChild(tree, current)) \u003d\u003e is_(current, STrees_Node))))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info \u0026 ((current \u003c\u003e nil) \u003d\u003e let old:STrees_Tree \u003d STrees_Subtree(tree, current) in ((not (STrees_HasRightChild(tree, current) and STrees_HasLeftChild(tree, current))) \u003d\u003e ((not STrees_HasLeftChild(tree, current)) \u003d\u003e ((not STrees_HasRightChild(tree, current)) \u003d\u003e inv_STrees_Info(mk_STrees_Info((tree \\ {current}), STrees_Parent(tree, current))))))))","type compatibility obligation:(forall tree:STrees_Tree, mk_STrees_Node(rootdata, rootpos):STrees_Node \u0026 ((mk_STrees_Node(rootdata, rootpos) in set tree) \u003d\u003e inv_STrees_Tree({mk_STrees_Node(d, p) | mk_STrees_Node(d, p) in set tree \u0026 (exists1 n in set {0, ... ,(card tree)} \u0026 ((p \u003e\u003d (rootpos * (2 ** n))) and (p \u003c ((rootpos + 1) * (2 ** n)))))})))","legal function application obligation:(forall tree:STrees_Tree, subtreeRoot:STrees_Node, newRootPos:nat1 \u0026 ((subtreeRoot in set tree) \u003d\u003e pre_STrees_Subtree(tree, subtreeRoot)))","type compatibility obligation:(forall tree:STrees_Tree, subtreeRoot:STrees_Node, newRootPos:nat1 \u0026 ((subtreeRoot in set tree) \u003d\u003e inv_STrees_Tree(let subtree:STrees_Tree \u003d STrees_Subtree(tree, subtreeRoot), mk_STrees_Node(-, oldRootPos):STrees_Node \u003d subtreeRoot in {STrees_MoveNode(tree, node, oldRootPos, newRootPos) | node in set subtree})))","unique existence binding obligation:(forall tree:STrees_Tree, mk_STrees_Node(d, p):STrees_Node, oldRootPos:nat1, newRootPos:nat1 \u0026 (exists1 n in set {0, ... ,(card tree)} \u0026 ((p \u003e\u003d (oldRootPos * (2 ** n))) and (p \u003c ((oldRootPos + 1) * (2 ** n))))))","type compatibility obligation:(forall tree:STrees_Tree, mk_STrees_Node(d, p):STrees_Node, oldRootPos:nat1, newRootPos:nat1 \u0026 let n:nat \u003d (iota n in set {0, ... ,(card tree)} \u0026 ((p \u003e\u003d (oldRootPos * (2 ** n))) and (p \u003c ((oldRootPos + 1) * (2 ** n))))) in ((((newRootPos * (2 ** n)) + p) - (oldRootPos * (2 ** n))) \u003e 0))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info, direction:STrees_Direction \u0026 ((not (\u003cToRoot\u003e \u003d direction)) \u003d\u003e ((\u003cToLeft\u003e \u003d direction) \u003d\u003e ((current \u003c\u003e nil) \u003d\u003e pre_STrees_HasLeftChild(tree, current)))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info, direction:STrees_Direction \u0026 ((not (\u003cToRoot\u003e \u003d direction)) \u003d\u003e ((\u003cToLeft\u003e \u003d direction) \u003d\u003e ((current \u003c\u003e nil) \u003d\u003e is_(current, STrees_Node)))))","legal function application obligation:(forall mk_STrees_Info(tree, current):STrees_Info, direction:STrees_Direction \u0026 ((not (\u003cToRoot\u003e \u003d direction)) \u003d\u003e ((not (\u003cToLeft\u003e \u003d direction)) \u003d\u003e ((\u003cToRight\u003e \u003d direction) \u003d\u003e ((current \u003c\u003e nil) \u003d\u003e pre_STrees_HasRightChild(tree, current))))))","type compatibility obligation:(forall mk_STrees_Info(tree, current):STrees_Info, direction:STrees_Direction \u0026 ((not (\u003cToRoot\u003e \u003d direction)) \u003d\u003e ((not (\u003cToLeft\u003e \u003d direction)) \u003d\u003e ((\u003cToRight\u003e \u003d direction) \u003d\u003e ((current \u003c\u003e nil) \u003d\u003e is_(current, STrees_Node))))))","cases exhaustive obligation:(forall mk_STrees_Info(tree, current):STrees_Info, direction:STrees_Direction \u0026 (((direction \u003d \u003cToRoot\u003e) or (direction \u003d \u003cToLeft\u003e)) or (direction \u003d \u003cToRight\u003e)))","legal function application obligation:(forall heap:Heaps_Heap, child:Nodes_NodePtr \u0026 ((child \u003c\u003e NIL) \u003d\u003e pre_Nodes_GetParent(Heaps_Retrieve(heap, child))))","type compatibility obligation:(forall heap:Heaps_Heap, child:Nodes_NodePtr \u0026 ((child \u003c\u003e NIL) \u003d\u003e ((is_(Heaps_Retrieve(heap, child), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, child), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, child), Nodes_SingleLink))))","legal function application obligation:(forall heap:Heaps_Heap, child:Nodes_NodePtr \u0026 ((child \u003c\u003e NIL) \u003d\u003e pre_Heaps_Retrieve(heap, child)))","legal function application obligation:(forall heap:Heaps_Heap, child:Nodes_NodePtr \u0026 ((child \u003c\u003e NIL) \u003d\u003e let parent:Nodes_NodePtr \u003d Nodes_GetParent(Heaps_Retrieve(heap, child)) in ((not (parent \u003d NIL)) \u003d\u003e (Trees_IsRightChildOf(heap, child, parent) \u003d\u003e pre_Trees_Position(heap, parent)))))","legal function application obligation:(forall heap:Heaps_Heap, child:Nodes_NodePtr \u0026 ((child \u003c\u003e NIL) \u003d\u003e let parent:Nodes_NodePtr \u003d Nodes_GetParent(Heaps_Retrieve(heap, child)) in ((not (parent \u003d NIL)) \u003d\u003e ((not Trees_IsRightChildOf(heap, child, parent)) \u003d\u003e pre_Trees_Position(heap, parent)))))","legal function application obligation:(forall heap:Heaps_Heap, mk_Trees_Tree(treePtr, current):Trees_Tree \u0026 ((treePtr \u003c\u003e NIL) \u003d\u003e pre_STrees_MkTree(Trees_SubtreeToSet(heap, treePtr, 1))))","legal function application obligation:(forall heap:Heaps_Heap, mk_Trees_Tree(treePtr, current):Trees_Tree \u0026 ((treePtr \u003c\u003e NIL) \u003d\u003e let treeset:STrees_Tree \u003d STrees_MkTree(Trees_SubtreeToSet(heap, treePtr, 1)) in pre_Nodes_GetData(Heaps_Retrieve(heap, current))))","type compatibility obligation:(forall heap:Heaps_Heap, mk_Trees_Tree(treePtr, current):Trees_Tree \u0026 ((treePtr \u003c\u003e NIL) \u003d\u003e let treeset:STrees_Tree \u003d STrees_MkTree(Trees_SubtreeToSet(heap, treePtr, 1)) in ((is_(Heaps_Retrieve(heap, current), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, current), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, current), Nodes_SingleLink))))","legal function application obligation:(forall heap:Heaps_Heap, mk_Trees_Tree(treePtr, current):Trees_Tree \u0026 ((treePtr \u003c\u003e NIL) \u003d\u003e let treeset:STrees_Tree \u003d STrees_MkTree(Trees_SubtreeToSet(heap, treePtr, 1)) in pre_Heaps_Retrieve(heap, current)))","legal function application obligation:(forall heap:Heaps_Heap, mk_Trees_Tree(treePtr, current):Trees_Tree \u0026 ((treePtr \u003c\u003e NIL) \u003d\u003e let treeset:STrees_Tree \u003d STrees_MkTree(Trees_SubtreeToSet(heap, treePtr, 1)) in let data:Nodes_Data \u003d Nodes_GetData(Heaps_Retrieve(heap, current)) in pre_Trees_Position(heap, current)))","legal function application obligation:(forall heap:Heaps_Heap, mk_Trees_Tree(treePtr, current):Trees_Tree \u0026 ((treePtr \u003c\u003e NIL) \u003d\u003e let treeset:STrees_Tree \u003d STrees_MkTree(Trees_SubtreeToSet(heap, treePtr, 1)) in let data:Nodes_Data \u003d Nodes_GetData(Heaps_Retrieve(heap, current)) in let position:nat1 \u003d Trees_Position(heap, current) in let currentnode:STrees_Node \u003d STrees_MkNode(data, position) in pre_STrees_MkInfo(treeset, currentnode)))","legal function application obligation:(forall heap:Heaps_Heap, subtree:Nodes_NodePtr, position:nat1 \u0026 ((subtree \u003c\u003e NIL) \u003d\u003e pre_Nodes_GetData(Heaps_Retrieve(heap, subtree))))","type compatibility obligation:(forall heap:Heaps_Heap, subtree:Nodes_NodePtr, position:nat1 \u0026 ((subtree \u003c\u003e NIL) \u003d\u003e ((is_(Heaps_Retrieve(heap, subtree), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, subtree), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, subtree), Nodes_SingleLink))))","legal function application obligation:(forall heap:Heaps_Heap, subtree:Nodes_NodePtr, position:nat1 \u0026 ((subtree \u003c\u003e NIL) \u003d\u003e pre_Heaps_Retrieve(heap, subtree)))","legal function application obligation:(forall heap:Heaps_Heap, subtree:Nodes_NodePtr, position:nat1 \u0026 ((subtree \u003c\u003e NIL) \u003d\u003e pre_Nodes_GetLeft(Heaps_Retrieve(heap, subtree))))","type compatibility obligation:(forall heap:Heaps_Heap, subtree:Nodes_NodePtr, position:nat1 \u0026 ((subtree \u003c\u003e NIL) \u003d\u003e ((is_(Heaps_Retrieve(heap, subtree), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, subtree), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, subtree), Nodes_SingleLink))))","legal function application obligation:(forall heap:Heaps_Heap, subtree:Nodes_NodePtr, position:nat1 \u0026 ((subtree \u003c\u003e NIL) \u003d\u003e pre_Heaps_Retrieve(heap, subtree)))","legal function application obligation:(forall heap:Heaps_Heap, subtree:Nodes_NodePtr, position:nat1 \u0026 ((subtree \u003c\u003e NIL) \u003d\u003e pre_Nodes_GetRight(Heaps_Retrieve(heap, subtree))))","type compatibility obligation:(forall heap:Heaps_Heap, subtree:Nodes_NodePtr, position:nat1 \u0026 ((subtree \u003c\u003e NIL) \u003d\u003e ((is_(Heaps_Retrieve(heap, subtree), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, subtree), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, subtree), Nodes_SingleLink))))","legal function application obligation:(forall heap:Heaps_Heap, subtree:Nodes_NodePtr, position:nat1 \u0026 ((subtree \u003c\u003e NIL) \u003d\u003e pre_Heaps_Retrieve(heap, subtree)))","legal function application obligation:(forall heap:Heaps_Heap, ptr:Nodes_NodePtr \u0026 (((ptr \u003c\u003e NIL) \u003d\u003e pre_Heaps_Retrieve(heap, ptr)) \u003d\u003e ((ptr \u003c\u003e NIL) \u003d\u003e pre_Nodes_GetLeft(Heaps_Retrieve(heap, ptr)))))","type compatibility obligation:(forall heap:Heaps_Heap, ptr:Nodes_NodePtr \u0026 (((ptr \u003c\u003e NIL) \u003d\u003e pre_Heaps_Retrieve(heap, ptr)) \u003d\u003e ((ptr \u003c\u003e NIL) \u003d\u003e ((is_(Heaps_Retrieve(heap, ptr), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, ptr), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, ptr), Nodes_SingleLink)))))","legal function application obligation:(forall heap:Heaps_Heap, ptr:Nodes_NodePtr \u0026 (((ptr \u003c\u003e NIL) \u003d\u003e pre_Heaps_Retrieve(heap, ptr)) \u003d\u003e ((ptr \u003c\u003e NIL) \u003d\u003e pre_Heaps_Retrieve(heap, ptr))))","legal function application obligation:(forall heap:Heaps_Heap, ptr:Nodes_NodePtr \u0026 (((ptr \u003c\u003e NIL) \u003d\u003e pre_Heaps_Retrieve(heap, ptr)) \u003d\u003e ((ptr \u003c\u003e NIL) \u003d\u003e pre_Nodes_GetRight(Heaps_Retrieve(heap, ptr)))))","type compatibility obligation:(forall heap:Heaps_Heap, ptr:Nodes_NodePtr \u0026 (((ptr \u003c\u003e NIL) \u003d\u003e pre_Heaps_Retrieve(heap, ptr)) \u003d\u003e ((ptr \u003c\u003e NIL) \u003d\u003e ((is_(Heaps_Retrieve(heap, ptr), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, ptr), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, ptr), Nodes_SingleLink)))))","legal function application obligation:(forall heap:Heaps_Heap, ptr:Nodes_NodePtr \u0026 (((ptr \u003c\u003e NIL) \u003d\u003e pre_Heaps_Retrieve(heap, ptr)) \u003d\u003e ((ptr \u003c\u003e NIL) \u003d\u003e pre_Heaps_Retrieve(heap, ptr))))","legal function application obligation:(forall heap:Heaps_Heap, child:Nodes_NodePtr, parent:Nodes_NodePtr \u0026 ((pre_Heaps_Retrieve(heap, parent) and pre_Heaps_Retrieve(heap, child)) \u003d\u003e pre_Nodes_GetRight(Heaps_Retrieve(heap, parent))))","type compatibility obligation:(forall heap:Heaps_Heap, child:Nodes_NodePtr, parent:Nodes_NodePtr \u0026 ((pre_Heaps_Retrieve(heap, parent) and pre_Heaps_Retrieve(heap, child)) \u003d\u003e ((is_(Heaps_Retrieve(heap, parent), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, parent), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, parent), Nodes_SingleLink))))","legal function application obligation:(forall heap:Heaps_Heap, child:Nodes_NodePtr, parent:Nodes_NodePtr \u0026 ((pre_Heaps_Retrieve(heap, parent) and pre_Heaps_Retrieve(heap, child)) \u003d\u003e pre_Heaps_Retrieve(heap, parent)))","legal function application obligation:(forall heap:Heaps_Heap, child:Nodes_NodePtr, parent:Nodes_NodePtr \u0026 ((pre_Heaps_Retrieve(heap, parent) and pre_Heaps_Retrieve(heap, child)) \u003d\u003e ((child \u003d Nodes_GetRight(Heaps_Retrieve(heap, parent))) \u003d\u003e pre_Nodes_GetParent(Heaps_Retrieve(heap, child)))))","type compatibility obligation:(forall heap:Heaps_Heap, child:Nodes_NodePtr, parent:Nodes_NodePtr \u0026 ((pre_Heaps_Retrieve(heap, parent) and pre_Heaps_Retrieve(heap, child)) \u003d\u003e ((child \u003d Nodes_GetRight(Heaps_Retrieve(heap, parent))) \u003d\u003e ((is_(Heaps_Retrieve(heap, child), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, child), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, child), Nodes_SingleLink)))))","legal function application obligation:(forall heap:Heaps_Heap, child:Nodes_NodePtr, parent:Nodes_NodePtr \u0026 ((pre_Heaps_Retrieve(heap, parent) and pre_Heaps_Retrieve(heap, child)) \u003d\u003e ((child \u003d Nodes_GetRight(Heaps_Retrieve(heap, parent))) \u003d\u003e pre_Heaps_Retrieve(heap, child))))","legal function application obligation:(forall heap:Heaps_Heap, child:Nodes_NodePtr, parent:Nodes_NodePtr \u0026 ((pre_Heaps_Retrieve(heap, parent) and pre_Heaps_Retrieve(heap, child)) \u003d\u003e pre_Nodes_GetLeft(Heaps_Retrieve(heap, parent))))","type compatibility obligation:(forall heap:Heaps_Heap, child:Nodes_NodePtr, parent:Nodes_NodePtr \u0026 ((pre_Heaps_Retrieve(heap, parent) and pre_Heaps_Retrieve(heap, child)) \u003d\u003e ((is_(Heaps_Retrieve(heap, parent), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, parent), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, parent), Nodes_SingleLink))))","legal function application obligation:(forall heap:Heaps_Heap, child:Nodes_NodePtr, parent:Nodes_NodePtr \u0026 ((pre_Heaps_Retrieve(heap, parent) and pre_Heaps_Retrieve(heap, child)) \u003d\u003e pre_Heaps_Retrieve(heap, parent)))","legal function application obligation:(forall heap:Heaps_Heap, child:Nodes_NodePtr, parent:Nodes_NodePtr \u0026 ((pre_Heaps_Retrieve(heap, parent) and pre_Heaps_Retrieve(heap, child)) \u003d\u003e ((child \u003d Nodes_GetLeft(Heaps_Retrieve(heap, parent))) \u003d\u003e pre_Nodes_GetParent(Heaps_Retrieve(heap, child)))))","type compatibility obligation:(forall heap:Heaps_Heap, child:Nodes_NodePtr, parent:Nodes_NodePtr \u0026 ((pre_Heaps_Retrieve(heap, parent) and pre_Heaps_Retrieve(heap, child)) \u003d\u003e ((child \u003d Nodes_GetLeft(Heaps_Retrieve(heap, parent))) \u003d\u003e ((is_(Heaps_Retrieve(heap, child), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, child), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, child), Nodes_SingleLink)))))","legal function application obligation:(forall heap:Heaps_Heap, child:Nodes_NodePtr, parent:Nodes_NodePtr \u0026 ((pre_Heaps_Retrieve(heap, parent) and pre_Heaps_Retrieve(heap, child)) \u003d\u003e ((child \u003d Nodes_GetLeft(Heaps_Retrieve(heap, parent))) \u003d\u003e pre_Heaps_Retrieve(heap, child))))","legal function application obligation:(forall heap:Heaps_Heap, ptr:Nodes_NodePtr \u0026 ((ptr \u003c\u003e NIL) \u003d\u003e pre_Nodes_GetParent(Heaps_Retrieve(heap, ptr))))","type compatibility obligation:(forall heap:Heaps_Heap, ptr:Nodes_NodePtr \u0026 ((ptr \u003c\u003e NIL) \u003d\u003e ((is_(Heaps_Retrieve(heap, ptr), Nodes_BinaryTree) or is_(Heaps_Retrieve(heap, ptr), Nodes_DoubleLink)) or is_(Heaps_Retrieve(heap, ptr), Nodes_SingleLink))))","legal function application obligation:(forall heap:Heaps_Heap, ptr:Nodes_NodePtr \u0026 ((ptr \u003c\u003e NIL) \u003d\u003e pre_Heaps_Retrieve(heap, ptr)))","legal function application obligation:(forall tree:Trees_Tree, data:Trees_Data, direction:Trees_Direction, oldstate:SystemState \u0026 ((Heaps_Available(heap) and let mk_Trees_Tree(treePtr, current):Trees_Tree \u003d tree in (((direction \u003d \u003cToRoot\u003e) \u003d\u003e (treePtr \u003d NIL)) and (((direction \u003d \u003cToRight\u003e) \u003d\u003e (not Trees_HasRightChild(heap, current))) and ((direction \u003d \u003cToLeft\u003e) \u003d\u003e (not Trees_HasLeftChild(heap, current)))))) \u003d\u003e (Heaps_Available(heap) \u003d\u003e let mk_Trees_Tree(treePtr, current):Trees_Tree \u003d tree in (((direction \u003d \u003cToRoot\u003e) \u003d\u003e (treePtr \u003d NIL)) \u003d\u003e ((direction \u003d \u003cToRight\u003e) \u003d\u003e pre_Trees_HasRightChild(heap, current))))))","legal function application obligation:(forall tree:Trees_Tree, data:Trees_Data, direction:Trees_Direction, oldstate:SystemState \u0026 ((Heaps_Available(heap) and let mk_Trees_Tree(treePtr, current):Trees_Tree \u003d tree in (((direction \u003d \u003cToRoot\u003e) \u003d\u003e (treePtr \u003d NIL)) and (((direction \u003d \u003cToRight\u003e) \u003d\u003e (not Trees_HasRightChild(heap, current))) and ((direction \u003d \u003cToLeft\u003e) \u003d\u003e (not Trees_HasLeftChild(heap, current)))))) \u003d\u003e (Heaps_Available(heap) \u003d\u003e let mk_Trees_Tree(treePtr, current):Trees_Tree \u003d tree in (((direction \u003d \u003cToRoot\u003e) \u003d\u003e (treePtr \u003d NIL)) \u003d\u003e (((direction \u003d \u003cToRight\u003e) \u003d\u003e (not Trees_HasRightChild(heap, current))) \u003d\u003e ((direction \u003d \u003cToLeft\u003e) \u003d\u003e pre_Trees_HasLeftChild(heap, current)))))))","legal function application obligation:(forall tree:Trees_Tree, data:Trees_Data, direction:Trees_Direction, oldstate:SystemState \u0026 ((Heaps_Available(heap) and let mk_Trees_Tree(treePtr, current):Trees_Tree \u003d tree in (((direction \u003d \u003cToRoot\u003e) \u003d\u003e (treePtr \u003d NIL)) and (((direction \u003d \u003cToRight\u003e) \u003d\u003e (not Trees_HasRightChild(heap, current))) and ((direction \u003d \u003cToLeft\u003e) \u003d\u003e (not Trees_HasLeftChild(heap, current)))))) \u003d\u003e (((Heaps_AmountUsed(heap~) + 1) \u003d Heaps_AmountUsed(heap)) \u003d\u003e let old:STrees_Info \u003d Trees_Set(heap~, tree) in pre_STrees_Insert(old, data, direction))))","operation establishes postcondition obligation:(forall tree:Trees_Tree, data:Trees_Data, direction:Trees_Direction, oldstate:SystemState \u0026 ((Heaps_Available(heap) and let mk_Trees_Tree(treePtr, current):Trees_Tree \u003d tree in (((direction \u003d \u003cToRoot\u003e) \u003d\u003e (treePtr \u003d NIL)) and (((direction \u003d \u003cToRight\u003e) \u003d\u003e (not Trees_HasRightChild(heap, current))) and ((direction \u003d \u003cToLeft\u003e) \u003d\u003e (not Trees_HasLeftChild(heap, current)))))) \u003d\u003e (((Heaps_AmountUsed(heap~) + 1) \u003d Heaps_AmountUsed(heap)) and let old:STrees_Info \u003d Trees_Set(heap~, tree) in (STrees_Insert(old, data, direction) \u003d Trees_Set(heap, RESULT)))))","legal function application obligation:(forall ptr:Nodes_NodePtr, oldstate:SystemState \u0026 (Trees_HasLeftChild(heap, ptr) \u003d\u003e pre_Trees_HasLeftChild(heap, ptr)))","while loop termination obligation:...","legal function application obligation:(forall ptr:Nodes_NodePtr, oldstate:SystemState \u0026 (Trees_HasLeftChild(heap, ptr) \u003d\u003e pre_Trees_HasRightChild(heap, pred)))","legal function application obligation:(forall mk_Trees_Tree(treePtr, current):Trees_Tree, oldstate:SystemState \u0026 ((treePtr \u003c\u003e NIL) \u003d\u003e pre_Trees_HasLeftChild(heap, current)))","legal function application obligation:(forall mk_Trees_Tree(treePtr, current):Trees_Tree, oldstate:SystemState \u0026 ((treePtr \u003c\u003e NIL) \u003d\u003e pre_Trees_HasRightChild(heap, current)))","legal function application obligation:(forall mk_Trees_Tree(treePtr, current):Trees_Tree, oldstate:SystemState \u0026 ((treePtr \u003c\u003e NIL) \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e pre_Trees_IsRoot(heap, current))))))","legal function application obligation:(forall mk_Trees_Tree(treePtr, current):Trees_Tree, oldstate:SystemState \u0026 ((treePtr \u003c\u003e NIL) \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e pre_Trees_IsRightChildOf(heap, current, parent))))))","operation call obligation:(forall mk_Trees_Tree(treePtr, current):Trees_Tree, oldstate:SystemState \u0026 ((treePtr \u003c\u003e NIL) \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e pre_Heaps_ModifyLoc(heap, address, mk_Heaps_Location(nil, false)))))))))","legal function application obligation:(forall mk_Trees_Tree(treePtr, current):Trees_Tree, oldstate:SystemState \u0026 ((treePtr \u003c\u003e NIL) \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e ((Heaps_AmountUsed(heap~) \u003d (Heaps_AmountUsed(heap) + 1)) \u003d\u003e let old:STrees_Info \u003d Trees_Set(heap~, mk_Trees_Tree(treePtr, current)) in pre_STrees_Delete(old))))))))))","operation establishes postcondition obligation:(forall mk_Trees_Tree(treePtr, current):Trees_Tree, oldstate:SystemState \u0026 ((treePtr \u003c\u003e NIL) \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e ((Heaps_AmountUsed(heap~) \u003d (Heaps_AmountUsed(heap) + 1)) and let old:STrees_Info \u003d Trees_Set(heap~, mk_Trees_Tree(treePtr, current)) in (STrees_Delete(old) \u003d Trees_Set(heap, RESULT)))))))))))","operation establishes postcondition obligation:(forall tree:Trees_Tree, data:Trees_Data, oldstate:SystemState \u0026 (true \u003d\u003e (STrees_ExistsData(Trees_Set(heap, tree), data) \u003d RESULT)))","legal function application obligation:(forall tree:Trees_Tree, direction:Trees_Direction, oldstate:SystemState \u0026 (((tree.current) \u003c\u003e NIL) \u003d\u003e pre_Trees_HasLeftChild(heap, (tree.current))))","legal function application obligation:(forall tree:Trees_Tree, direction:Trees_Direction, oldstate:SystemState \u0026 (((tree.current) \u003c\u003e NIL) \u003d\u003e pre_Trees_HasRightChild(heap, (tree.current))))","operation establishes postcondition obligation:(forall tree:Trees_Tree, direction:Trees_Direction, oldstate:SystemState \u0026 (STrees_ExistsDirection(Trees_Set(heap, tree), direction) \u003d RESULT))","legal function application obligation:(forall tree:Trees_Tree, oldstate:SystemState \u0026 (((tree.treePtr) \u003c\u003e NIL) \u003d\u003e (true \u003d\u003e pre_STrees_GetCurrentData(Trees_Set(heap, tree)))))","operation establishes postcondition obligation:(forall tree:Trees_Tree, oldstate:SystemState \u0026 (((tree.treePtr) \u003c\u003e NIL) \u003d\u003e (true \u003d\u003e (STrees_GetCurrentData(Trees_Set(heap, tree)) \u003d RESULT))))","legal function application obligation:(forall tree:Trees_Tree, data:Trees_Data, oldstate:SystemState \u0026 (((tree.treePtr) \u003c\u003e NIL) \u003d\u003e (true \u003d\u003e pre_STrees_StoreCurrentData(Trees_Set(heap~, tree), data))))","operation establishes postcondition obligation:(forall tree:Trees_Tree, data:Trees_Data, oldstate:SystemState \u0026 (((tree.treePtr) \u003c\u003e NIL) \u003d\u003e (true \u003d\u003e (STrees_StoreCurrentData(Trees_Set(heap~, tree), data) \u003d Trees_Set(heap, RESULT)))))","legal function application obligation:(forall tree:Trees_Tree, direction:Trees_Direction, oldstate:SystemState \u0026 ((((tree.treePtr) \u003c\u003e NIL) and (((direction \u003d \u003cToLeft\u003e) \u003d\u003e Trees_HasLeftChild(heap, (tree.current))) and ((direction \u003d \u003cToRight\u003e) \u003d\u003e Trees_HasRightChild(heap, (tree.current))))) \u003d\u003e (((tree.treePtr) \u003c\u003e NIL) \u003d\u003e ((direction \u003d \u003cToLeft\u003e) \u003d\u003e pre_Trees_HasLeftChild(heap, (tree.current))))))","legal function application obligation:(forall tree:Trees_Tree, direction:Trees_Direction, oldstate:SystemState \u0026 ((((tree.treePtr) \u003c\u003e NIL) and (((direction \u003d \u003cToLeft\u003e) \u003d\u003e Trees_HasLeftChild(heap, (tree.current))) and ((direction \u003d \u003cToRight\u003e) \u003d\u003e Trees_HasRightChild(heap, (tree.current))))) \u003d\u003e (((tree.treePtr) \u003c\u003e NIL) \u003d\u003e (((direction \u003d \u003cToLeft\u003e) \u003d\u003e Trees_HasLeftChild(heap, (tree.current))) \u003d\u003e ((direction \u003d \u003cToRight\u003e) \u003d\u003e pre_Trees_HasRightChild(heap, (tree.current)))))))","legal function application obligation:(forall tree:Trees_Tree, direction:Trees_Direction, oldstate:SystemState \u0026 ((((tree.treePtr) \u003c\u003e NIL) and (((direction \u003d \u003cToLeft\u003e) \u003d\u003e Trees_HasLeftChild(heap, (tree.current))) and ((direction \u003d \u003cToRight\u003e) \u003d\u003e Trees_HasRightChild(heap, (tree.current))))) \u003d\u003e pre_STrees_MoveInDir(Trees_Set(heap~, tree), direction)))","operation establishes postcondition obligation:(forall tree:Trees_Tree, direction:Trees_Direction, oldstate:SystemState \u0026 ((((tree.treePtr) \u003c\u003e NIL) and (((direction \u003d \u003cToLeft\u003e) \u003d\u003e Trees_HasLeftChild(heap, (tree.current))) and ((direction \u003d \u003cToRight\u003e) \u003d\u003e Trees_HasRightChild(heap, (tree.current))))) \u003d\u003e (STrees_MoveInDir(Trees_Set(heap~, tree), direction) \u003d Trees_Set(heap, RESULT))))","legal function application obligation:(forall tree:Trees_Tree, oldstate:SystemState \u0026 ((not Trees_IsRoot(heap, (tree.current))) \u003d\u003e pre_Trees_IsRoot(heap, (tree.current))))","legal function application obligation:(forall tree:Trees_Tree, oldstate:SystemState \u0026 ((not Trees_IsRoot(heap, (tree.current))) \u003d\u003e pre_STrees_MoveToParent(Trees_Set(heap~, tree))))","operation establishes postcondition obligation:(forall tree:Trees_Tree, oldstate:SystemState \u0026 ((not Trees_IsRoot(heap, (tree.current))) \u003d\u003e (STrees_MoveToParent(Trees_Set(heap~, tree)) \u003d Trees_Set(heap, RESULT))))","operation establishes postcondition obligation:(forall tree:Trees_Tree, oldstate:SystemState \u0026 (true \u003d\u003e (STrees_Size(Trees_Set(heap~, tree)) \u003d RESULT)))","operation establishes postcondition obligation:(forall tree:Trees_Tree, traversal:(Trees_Data -\u003e Trees_Data), oldstate:SystemState \u0026 (true \u003d\u003e (STrees_Traverse(Trees_Set(heap~, tree), traversal) \u003d Trees_Set(heap, RESULT))))","legal function application obligation:(forall subtree:Nodes_NodePtr, traversal:(Trees_Data -\u003e Trees_Data), oldstate:SystemState \u0026 pre_(traversalDATA(subtree)))","legal function application obligation:pre_STrees_MkTree({STrees_MkNode(\u0027a\u0027, 1), STrees_MkNode(\u0027b\u0027, 2), STrees_MkNode(\u0027c\u0027, 3), STrees_MkNode(\u0027d\u0027, 4), STrees_MkNode(\u0027e\u0027, 5), STrees_MkNode(\u0027f\u0027, 6), STrees_MkNode(\u0027g\u0027, 7), STrees_MkNode(\u0027h\u0027, 8), STrees_MkNode(\u0027i\u0027, 9), STrees_MkNode(\u0027j\u0027, 10), STrees_MkNode(\u0027k\u0027, 11), STrees_MkNode(\u0027l\u0027, 12), STrees_MkNode(\u0027m\u0027, 13), STrees_MkNode(\u0027n\u0027, 14), STrees_MkNode(\u0027o\u0027, 15), STrees_MkNode(\u0027p\u0027, 16), STrees_MkNode(\u0027q\u0027, 17), STrees_MkNode(\u0027r\u0027, 18), STrees_MkNode(\u0027s\u0027, 19), STrees_MkNode(\u0027t\u0027, 20), STrees_MkNode(\u0027u\u0027, 21), STrees_MkNode(\u0027v\u0027, 22), STrees_MkNode(\u0027w\u0027, 23), STrees_MkNode(\u0027x\u0027, 24), STrees_MkNode(\u0027y\u0027, 25), STrees_MkNode(\u0027z\u0027, 26)})","legal function application obligation:pre_STrees_MkTree({STrees_MkNode(\u0027a\u0027, 1), STrees_MkNode(\u0027d\u0027, 2), STrees_MkNode(\u0027c\u0027, 3), STrees_MkNode(\u0027h\u0027, 4), STrees_MkNode(\u0027i\u0027, 5), STrees_MkNode(\u0027f\u0027, 6), STrees_MkNode(\u0027o\u0027, 7), STrees_MkNode(\u0027p\u0027, 8), STrees_MkNode(\u0027r\u0027, 10), STrees_MkNode(\u0027s\u0027, 11), STrees_MkNode(\u0027l\u0027, 12), STrees_MkNode(\u0027z\u0027, 13), STrees_MkNode(\u0027j\u0027, 23), STrees_MkNode(\u0027x\u0027, 24), STrees_MkNode(\u0027y\u0027, 25), STrees_MkNode(\u0027t\u0027, 46), STrees_MkNode(\u0027u\u0027, 47), STrees_MkNode(\u0027k\u0027, 95), STrees_MkNode(\u0027v\u0027, 190), STrees_MkNode(\u0027w\u0027, 191)})","legal function application obligation:pre_STrees_MkTree({STrees_MkNode(\u0027a\u0027, 1), STrees_MkNode(\u0027a\u0027, 2), STrees_MkNode(\u0027a\u0027, 3), STrees_MkNode(\u0027a\u0027, 4), STrees_MkNode(\u0027a\u0027, 5), STrees_MkNode(\u0027a\u0027, 6), STrees_MkNode(\u0027b\u0027, 7), STrees_MkNode(\u0027b\u0027, 8), STrees_MkNode(\u0027b\u0027, 10), STrees_MkNode(\u0027b\u0027, 11), STrees_MkNode(\u0027b\u0027, 12), STrees_MkNode(\u0027b\u0027, 13), STrees_MkNode(\u0027a\u0027, 23), STrees_MkNode(\u0027b\u0027, 24), STrees_MkNode(\u0027b\u0027, 25), STrees_MkNode(\u0027b\u0027, 46), STrees_MkNode(\u0027b\u0027, 47), STrees_MkNode(\u0027b\u0027, 95), STrees_MkNode(\u0027b\u0027, 190), STrees_MkNode(\u0027b\u0027, 191)})","legal function application obligation:pre_STrees_Insert(stree, \u0027a\u0027, \u003cToRoot\u003e)","legal function application obligation:pre_STrees_Insert(stree, \u0027b\u0027, \u003cToLeft\u003e)","legal function application obligation:pre_STrees_MoveToParent(stree)","legal function application obligation:pre_STrees_Insert(stree, \u0027c\u0027, \u003cToRight\u003e)","legal function application obligation:pre_STrees_MoveToParent(stree)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToLeft\u003e)","legal function application obligation:pre_STrees_Insert(stree, \u0027d\u0027, \u003cToLeft\u003e)","legal function application obligation:pre_STrees_MoveToParent(stree)","legal function application obligation:pre_STrees_Insert(stree, \u0027e\u0027, \u003cToRight\u003e)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToRoot\u003e)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToRight\u003e)","legal function application obligation:pre_STrees_Insert(stree, \u0027f\u0027, \u003cToLeft\u003e)","legal function application obligation:pre_STrees_MoveToParent(stree)","legal function application obligation:pre_STrees_Insert(stree, \u0027g\u0027, \u003cToRight\u003e)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToRoot\u003e)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToLeft\u003e)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToLeft\u003e)","legal function application obligation:pre_STrees_Insert(stree, \u0027h\u0027, \u003cToLeft\u003e)","legal function application obligation:pre_STrees_MoveToParent(stree)","legal function application obligation:pre_STrees_Insert(stree, \u0027i\u0027, \u003cToRight\u003e)","legal function application obligation:pre_STrees_MoveToAnscestor(stree, 2)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToRight\u003e)","legal function application obligation:pre_STrees_Insert(stree, \u0027j\u0027, \u003cToLeft\u003e)","legal function application obligation:pre_STrees_MoveToParent(stree)","legal function application obligation:pre_STrees_Insert(stree, \u0027k\u0027, \u003cToRight\u003e)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToRoot\u003e)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToRight\u003e)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToLeft\u003e)","legal function application obligation:pre_STrees_Insert(stree, \u0027l\u0027, \u003cToLeft\u003e)","legal function application obligation:pre_STrees_MoveToParent(stree)","legal function application obligation:pre_STrees_Insert(stree, \u0027m\u0027, \u003cToRight\u003e)","legal function application obligation:pre_STrees_MoveToAnscestor(stree, 2)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToRight\u003e)","legal function application obligation:pre_STrees_Insert(stree, \u0027n\u0027, \u003cToLeft\u003e)","legal function application obligation:pre_STrees_MoveToParent(stree)","legal function application obligation:pre_STrees_Insert(stree, \u0027o\u0027, \u003cToRight\u003e)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToRoot\u003e)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToLeft\u003e)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToLeft\u003e)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToLeft\u003e)","legal function application obligation:pre_STrees_Insert(stree, \u0027p\u0027, \u003cToLeft\u003e)","legal function application obligation:pre_STrees_MoveToParent(stree)","legal function application obligation:pre_STrees_Insert(stree, \u0027q\u0027, \u003cToRight\u003e)","legal function application obligation:pre_STrees_MoveToAnscestor(stree, 2)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToRight\u003e)","legal function application obligation:pre_STrees_Insert(stree, \u0027r\u0027, \u003cToLeft\u003e)","legal function application obligation:pre_STrees_MoveToParent(stree)","legal function application obligation:pre_STrees_Insert(stree, \u0027s\u0027, \u003cToRight\u003e)","legal function application obligation:pre_STrees_MoveToAnscestor(stree, 3)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToRight\u003e)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToLeft\u003e)","legal function application obligation:pre_STrees_Insert(stree, \u0027t\u0027, \u003cToLeft\u003e)","legal function application obligation:pre_STrees_MoveToParent(stree)","legal function application obligation:pre_STrees_Insert(stree, \u0027u\u0027, \u003cToRight\u003e)","legal function application obligation:pre_STrees_MoveToAnscestor(stree, 2)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToRight\u003e)","legal function application obligation:pre_STrees_Insert(stree, \u0027v\u0027, \u003cToLeft\u003e)","legal function application obligation:pre_STrees_MoveToParent(stree)","legal function application obligation:pre_STrees_Insert(stree, \u0027w\u0027, \u003cToRight\u003e)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToRoot\u003e)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToRight\u003e)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToLeft\u003e)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToLeft\u003e)","legal function application obligation:pre_STrees_Insert(stree, \u0027x\u0027, \u003cToLeft\u003e)","legal function application obligation:pre_STrees_MoveToParent(stree)","legal function application obligation:pre_STrees_Insert(stree, \u0027y\u0027, \u003cToRight\u003e)","legal function application obligation:pre_STrees_MoveToAnscestor(stree, 2)","legal function application obligation:pre_STrees_MoveInDir(stree, \u003cToRight\u003e)","legal function application obligation:pre_STrees_Insert(stree, \u0027z\u0027, \u003cToLeft\u003e)","legal function application obligation:pre_STrees_MoveToNode(stree, 14)","legal function application obligation:pre_STrees_Delete(stree)","legal function application obligation:pre_STrees_MoveToNode(stree, 17)","legal function application obligation:pre_STrees_Delete(stree)","legal function application obligation:pre_STrees_MoveToNode(stree, 13)","legal function application obligation:pre_STrees_Delete(stree)","legal function application obligation:pre_STrees_MoveToNode(stree, 7)","legal function application obligation:pre_STrees_Delete(stree)","legal function application obligation:pre_STrees_MoveToNode(stree, 5)","legal function application obligation:pre_STrees_Delete(stree)","legal function application obligation:pre_STrees_MoveToNode(stree, 2)","legal function application obligation:pre_STrees_Delete(stree)","legal function application obligation:pre_STrees_MoveToNode(stree, 3)","legal function application obligation:pre_STrees_GetData(stree, 13)","legal function application obligation:pre_STrees_SetCurrentNode(stree, STrees_MkNode(\u0027z\u0027, 13))","legal function application obligation:pre_STrees_StoreCurrentData(stree, \u0027Z\u0027)","legal function application obligation:pre_STrees_GetCurrentData(stree)"] \ No newline at end of file diff --git a/core/pog/src/test/resources/examples/AutomatedStockBrokerPP.result b/core/pog/src/test/resources/examples/AutomatedStockBrokerPP.result index 024334d0bc..f0b967c714 100644 --- a/core/pog/src/test/resources/examples/AutomatedStockBrokerPP.result +++ b/core/pog/src/test/resources/examples/AutomatedStockBrokerPP.result @@ -1 +1 @@ -["legal sequence application obligation:(forall sr:StockRecord, predefinedEvents:seq of (Event) \u0026 (let val:nat \u003d (predefinedEvents((len predefinedEvents)).Value) in IsInRegion(val, (sr.NoActionReg)) \u003d\u003e ((len predefinedEvents) in set (inds predefinedEvents))))","state invariant holds obligation:(forall sr:StockRecord, predefinedEvents:seq of (Event) \u0026 (let val:nat \u003d (predefinedEvents((len predefinedEvents)).Value) in IsInRegion(val, (sr.NoActionReg)) \u003d\u003e (((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) and (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) and (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e) or (((eventHistory((e + 1)).Type) \u003d \u003cValley\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cPeak\u003e))))))))))","state invariant holds obligation:(forall sr:StockRecord \u0026 ((((sr.Name) in set (World`stockMarket.GetStockNames)()) and let val:StockValue \u003d ((World`stockMarket.GetStock)((sr.Name)).GetCurrentValue)() in IsInRegion(val, (sr.NoActionReg))) \u003d\u003e (((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) and (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) and (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e) or (((eventHistory((e + 1)).Type) \u003d \u003cValley\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cPeak\u003e))))))))))","non-empty sequence obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e (stockHistory \u003c\u003e [])))","legal sequence application obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e (IsInRegion((hd stockHistory), reg) \u003d\u003e (2 in set (inds stockHistory)))))","state invariant holds obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e ((((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) and (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) and (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e) or (((eventHistory((e + 1)).Type) \u003d \u003cValley\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cPeak\u003e)))))))) \u003d\u003e (((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) and (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) and (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e) or (((eventHistory((e + 1)).Type) \u003d \u003cValley\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cPeak\u003e)))))))))))","non-empty sequence obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e (stockHistory \u003c\u003e [])))","legal sequence application obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e ((not IsInRegion((hd stockHistory), reg)) \u003d\u003e (2 in set (inds stockHistory)))))","state invariant holds obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e ((((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) and (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) and (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e) or (((eventHistory((e + 1)).Type) \u003d \u003cValley\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cPeak\u003e)))))))) \u003d\u003e (((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) and (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) and (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e) or (((eventHistory((e + 1)).Type) \u003d \u003cValley\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cPeak\u003e)))))))))))","non-empty sequence obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e (stockHistory \u003c\u003e [])))","legal sequence application obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e (((hd stockHistory) \u003d u) \u003d\u003e (2 in set (inds stockHistory)))))","state invariant holds obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e ((((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) and (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) and (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e) or (((eventHistory((e + 1)).Type) \u003d \u003cValley\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cPeak\u003e)))))))) \u003d\u003e (((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) and (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) and (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e) or (((eventHistory((e + 1)).Type) \u003d \u003cValley\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cPeak\u003e)))))))))))","non-empty sequence obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e (stockHistory \u003c\u003e [])))","legal sequence application obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e (((hd stockHistory) \u003d l) \u003d\u003e (2 in set (inds stockHistory)))))","state invariant holds obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e ((((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) and (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) and (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e) or (((eventHistory((e + 1)).Type) \u003d \u003cValley\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cPeak\u003e)))))))) \u003d\u003e (((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) and (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) and (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e) or (((eventHistory((e + 1)).Type) \u003d \u003cValley\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cPeak\u003e)))))))))))","non-empty sequence obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e (stockHistory \u003c\u003e [])))","state invariant holds obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e ((((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) and (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) and (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e) or (((eventHistory((e + 1)).Type) \u003d \u003cValley\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cPeak\u003e)))))))) \u003d\u003e (((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) and (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) and (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e) or (((eventHistory((e + 1)).Type) \u003d \u003cValley\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cPeak\u003e)))))))))))","non-empty sequence obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e (stockHistory \u003c\u003e [])))","state invariant holds obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e ((((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) and (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) and (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e) or (((eventHistory((e + 1)).Type) \u003d \u003cValley\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cPeak\u003e)))))))) \u003d\u003e (((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) and (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) and (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e) or (((eventHistory((e + 1)).Type) \u003d \u003cValley\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cPeak\u003e)))))))))))","legal sequence application obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e (true \u003d\u003e ((len ([mk_Event(\u003cValley\u003e, time, cv)] ^ ([mk_Event(\u003cPeak\u003e, time, cv)] ^ ([mk_Event(\u003cLowerLimit\u003e, time, cv)] ^ ([mk_Event(\u003cUpperLimit\u003e, time, cv)] ^ ([mk_Event(\u003cLeavesNoActionRegion\u003e, time, cv)] ^ ([mk_Event(\u003cEntersNoActionRegion\u003e, time, cv)] ^ eventHistory))))))) in set (inds ([mk_Event(\u003cValley\u003e, time, cv)] ^ ([mk_Event(\u003cPeak\u003e, time, cv)] ^ ([mk_Event(\u003cLowerLimit\u003e, time, cv)] ^ ([mk_Event(\u003cUpperLimit\u003e, time, cv)] ^ ([mk_Event(\u003cLeavesNoActionRegion\u003e, time, cv)] ^ ([mk_Event(\u003cEntersNoActionRegion\u003e, time, cv)] ^ eventHistory)))))))))))","legal sequence application obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e (true \u003d\u003e (((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e (e in set (inds eventHistory))))))))","legal sequence application obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e (true \u003d\u003e (((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e (((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e ((e + 1) in set (inds eventHistory)))))))))","legal sequence application obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e (true \u003d\u003e (((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e (((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e ((not ((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e)) \u003d\u003e ((e + 1) in set (inds eventHistory))))))))))","legal sequence application obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e (true \u003d\u003e (((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) \u003d\u003e (e in set (inds eventHistory)))))))))","legal sequence application obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e (true \u003d\u003e (((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) \u003d\u003e (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e ((e + 1) in set (inds eventHistory))))))))))","legal sequence application obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e (true \u003d\u003e (((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) \u003d\u003e (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e ((not ((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e)) \u003d\u003e ((e + 1) in set (inds eventHistory)))))))))))","legal sequence application obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e (true \u003d\u003e (((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) \u003d\u003e (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e ((not ((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e)) \u003d\u003e ((not ((eventHistory((e + 1)).Type) \u003d \u003cValley\u003e)) \u003d\u003e ((e + 1) in set (inds eventHistory))))))))))))","operation establishes postcondition obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e (true \u003d\u003e (((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) and (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) and (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e) or (((eventHistory((e + 1)).Type) \u003d \u003cValley\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cPeak\u003e)))))))))))","legal map application obligation:(forall tim:nat \u0026 ((stockRecord.State) in set (dom (stockRecord.Triggers))))","state invariant holds obligation:(forall tim:nat \u0026 ((((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) and (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) and (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e) or (((eventHistory((e + 1)).Type) \u003d \u003cValley\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cPeak\u003e)))))))) \u003d\u003e (((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) and (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) and (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e) or (((eventHistory((e + 1)).Type) \u003d \u003cValley\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cPeak\u003e))))))))))","operation call obligation:(forall time:nat \u0026 let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2))","operation establishes postcondition obligation:(forall time:nat \u0026 (forall eventHistory1:seq of (Event), stockRecord2:StockRecord, sm3:[StockMarket], currentlyTriggeredAction4:[ActionType] \u0026 (((((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) and (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) and (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e) or (((eventHistory((e + 1)).Type) \u003d \u003cValley\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cPeak\u003e)))))))) and (((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) and (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) and (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e) or (((eventHistory((e + 1)).Type) \u003d \u003cValley\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cPeak\u003e))))))))) \u003d\u003e (forall eventHistory5:seq of (Event), stockRecord6:StockRecord, sm7:[StockMarket], currentlyTriggeredAction8:[ActionType] \u0026 ((((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) and (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) and (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e) or (((eventHistory((e + 1)).Type) \u003d \u003cValley\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cPeak\u003e)))))))) \u003d\u003e NoActiveTriggerInNoActionRegion(GetStockValue(time), (stockRecord.NoActionReg), currentlyTriggeredAction))))))","state invariant holds obligation:(forall sr:StockRecord \u0026 ((((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) and (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) and (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e) or (((eventHistory((e + 1)).Type) \u003d \u003cValley\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cPeak\u003e)))))))) \u003d\u003e (((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) and (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) and (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e) or (((eventHistory((e + 1)).Type) \u003d \u003cValley\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cPeak\u003e))))))))))","legal sequence application obligation:(forall time:nat \u0026 (((len eventHistory) \u003e 0) \u003d\u003e (1 in set (inds eventHistory))))","legal sequence application obligation:(forall time:nat \u0026 (((len eventHistory) \u003e 0) \u003d\u003e (((len eventHistory) - time) in set (inds eventHistory))))","non-empty sequence obligation:(forall svs:seq of (StockValue) \u0026 (svs \u003c\u003e []))","legal sequence application obligation:(forall svs:seq of (StockValue) \u0026 let current:StockValue \u003d (hd svs) in (forall i in set (inds svs) \u0026 (i in set (inds svs))))","legal sequence application obligation:(forall svs:seq of (StockValue) \u0026 let current:StockValue \u003d (hd svs) in let indicesOneAbove:set of (nat1) \u003d {i | i in set (inds svs) \u0026 (((current + 1) \u003d svs(i)) and (i \u003c\u003e (len svs)))} in (forall i in set indicesOneAbove \u0026 (forall v in set {2, ... ,i} \u0026 (v in set (inds svs)))))","legal sequence application obligation:(forall svs:seq of (StockValue) \u0026 let current:StockValue \u003d (hd svs) in let indicesOneAbove:set of (nat1) \u003d {i | i in set (inds svs) \u0026 (((current + 1) \u003d svs(i)) and (i \u003c\u003e (len svs)))} in (forall i in set indicesOneAbove \u0026 (forall v in set {2, ... ,i} \u0026 (((current + 1) \u003d svs(v)) \u003d\u003e ((i + 1) in set (inds svs))))))","non-empty sequence obligation:(forall svs:seq of (StockValue) \u0026 (svs \u003c\u003e []))","legal sequence application obligation:(forall svs:seq of (StockValue) \u0026 let current:StockValue \u003d (hd svs) in (forall i in set (inds svs) \u0026 (i in set (inds svs))))","legal sequence application obligation:(forall svs:seq of (StockValue) \u0026 let current:StockValue \u003d (hd svs) in let indicesOneBelow:set of (nat1) \u003d {i | i in set (inds svs) \u0026 (((current - 1) \u003d svs(i)) and (i \u003c\u003e (len svs)))} in (forall i in set indicesOneBelow \u0026 (forall v in set {2, ... ,i} \u0026 (v in set (inds svs)))))","legal sequence application obligation:(forall svs:seq of (StockValue) \u0026 let current:StockValue \u003d (hd svs) in let indicesOneBelow:set of (nat1) \u003d {i | i in set (inds svs) \u0026 (((current - 1) \u003d svs(i)) and (i \u003c\u003e (len svs)))} in (forall i in set indicesOneBelow \u0026 (forall v in set {2, ... ,i} \u0026 (((current - 1) \u003d svs(v)) \u003d\u003e ((i + 1) in set (inds svs))))))","legal sequence application obligation:(forall time:nat, events:seq of (Event) \u0026 (forall x in set (inds events) \u0026 (x in set (inds events))))","let be st existence obligation:(forall time:nat, events:seq of (Event) \u0026 let pastEvents:set of (nat1) \u003d {x | x in set (inds events) \u0026 ((events(x).TimeStamp) \u003c\u003d time)} in (exists i, j in set pastEvents \u0026 ((i \u003c\u003e j) \u003d\u003e ((events(i).TimeStamp) \u003c\u003d (events(j).TimeStamp)))))","legal sequence application obligation:(forall time:nat, events:seq of (Event) \u0026 let pastEvents:set of (nat1) \u003d {x | x in set (inds events) \u0026 ((events(x).TimeStamp) \u003c\u003d time)} in (forall i, j in set pastEvents \u0026 ((i \u003c\u003e j) \u003d\u003e (i in set (inds events)))))","legal sequence application obligation:(forall time:nat, events:seq of (Event) \u0026 let pastEvents:set of (nat1) \u003d {x | x in set (inds events) \u0026 ((events(x).TimeStamp) \u003c\u003d time)} in (forall i, j in set pastEvents \u0026 ((i \u003c\u003e j) \u003d\u003e (j in set (inds events)))))","legal sequence application obligation:(forall time:nat, action:ActionTrigger, eventHistory:seq of (Event) \u0026 let tgr:seq of (EventType) \u003d (action.Trigger) in let index:nat1 \u003d FindLowestIndexFromTime(time, eventHistory), s:seq of (Event) \u003d (eventHistory(index, ... ,((index + (len tgr)) - 1))) in (forall i in set (inds s) \u0026 (i in set (inds s))))","legal sequence application obligation:(forall time:nat, action:ActionTrigger, eventHistory:seq of (Event) \u0026 let tgr:seq of (EventType) \u003d (action.Trigger) in let index:nat1 \u003d FindLowestIndexFromTime(time, eventHistory), s:seq of (Event) \u003d (eventHistory(index, ... ,((index + (len tgr)) - 1))) in (forall i in set (inds s) \u0026 (i in set (inds tgr))))","legal sequence application obligation:(forall time:nat, action:ActionTrigger, eventHistory:seq of (Event) \u0026 let tgr:seq of (EventType) \u003d (action.Trigger) in let index:nat1 \u003d FindLowestIndexFromTime(time, eventHistory), s:seq of (Event) \u003d (eventHistory(index, ... ,((index + (len tgr)) - 1))) in ((forall i in set (inds s) \u0026 ((s(i).Type) \u003d tgr(i))) \u003d\u003e (1 in set (inds s))))","enumeration map injectivity obligation:(forall m1, m2 in set {{\u003cPotentialBuy\u003e |-\u003e mk_ActionTrigger([\u003cLeavesNoActionRegion\u003e, \u003cLowerLimit\u003e], \u003cBuy\u003e)}, {\u003cBought\u003e |-\u003e mk_ActionTrigger([\u003cLeavesNoActionRegion\u003e, \u003cUpperLimit\u003e], \u003cSell\u003e)}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","type compatibility obligation:inv_Region(mk_Region(12, 8))","type compatibility obligation:inv_StockRecord(mk_StockRecord(mk_token(\"test\"), {\u003cPotentialBuy\u003e |-\u003e mk_ActionTrigger([\u003cLeavesNoActionRegion\u003e, \u003cLowerLimit\u003e], \u003cBuy\u003e), \u003cBought\u003e |-\u003e mk_ActionTrigger([\u003cLeavesNoActionRegion\u003e, \u003cUpperLimit\u003e], \u003cSell\u003e)}, mk_Region(12, 8), 10, \u003cBought\u003e))","enumeration map injectivity obligation:(forall m1, m2 in set {{\u003cPotentialBuy\u003e |-\u003e mk_ActionTrigger([\u003cLeavesNoActionRegion\u003e, \u003cLowerLimit\u003e], \u003cBuy\u003e)}, {\u003cBought\u003e |-\u003e mk_ActionTrigger([\u003cLeavesNoActionRegion\u003e, \u003cUpperLimit\u003e], \u003cSell\u003e)}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","type compatibility obligation:inv_Region(mk_Region(12, 8))","type compatibility obligation:inv_StockRecord(mk_StockRecord(mk_token(\"test12\"), {\u003cPotentialBuy\u003e |-\u003e mk_ActionTrigger([\u003cLeavesNoActionRegion\u003e, \u003cLowerLimit\u003e], \u003cBuy\u003e), \u003cBought\u003e |-\u003e mk_ActionTrigger([\u003cLeavesNoActionRegion\u003e, \u003cUpperLimit\u003e], \u003cSell\u003e)}, mk_Region(12, 8), 10, \u003cBought\u003e))","enumeration map injectivity obligation:(forall m1, m2 in set {{\u003cPotentialBuy\u003e |-\u003e mk_ActionTrigger([\u003cLeavesNoActionRegion\u003e, \u003cLowerLimit\u003e], \u003cBuy\u003e)}, {\u003cBought\u003e |-\u003e mk_ActionTrigger([\u003cLeavesNoActionRegion\u003e, \u003cUpperLimit\u003e], \u003cSell\u003e)}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","type compatibility obligation:inv_Region(mk_Region(12, 8))","type compatibility obligation:inv_StockRecord(mk_StockRecord(mk_token(\"test2\"), {\u003cPotentialBuy\u003e |-\u003e mk_ActionTrigger([\u003cLeavesNoActionRegion\u003e, \u003cLowerLimit\u003e], \u003cBuy\u003e), \u003cBought\u003e |-\u003e mk_ActionTrigger([\u003cLeavesNoActionRegion\u003e, \u003cUpperLimit\u003e], \u003cSell\u003e)}, mk_Region(12, 8), 0, \u003cPotentialBuy\u003e))","while loop termination obligation:NotYetImplemented","let be st existence obligation:(forall m:map (String) to (seq of (Event)) \u0026 (exists x, y in set {(len m(x)) | x in set (dom m)} \u0026 ((x \u003c\u003e y) \u003d\u003e (x \u003c\u003d y))))","legal map application obligation:(forall m:map (String) to (seq of (Event)) \u0026 (forall x in set (dom m) \u0026 (x in set (dom m))))","state invariant holds obligation:(forall startCash:nat \u0026 ((((startCash \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog)))","state invariant holds obligation:(forall sRecord:StockRecord, priority:nat1 \u0026 (((sRecord.Name) not in set {(x.Name) | x in set (elems stocks)}) \u003d\u003e (((((balance \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog)) \u003d\u003e ((((balance \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog)))))","state invariant holds obligation:(forall sRecord:StockRecord, priority:nat1 \u0026 (((sRecord.Name) not in set {(x.Name) | x in set (elems stocks)}) \u003d\u003e (((((balance \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog)) \u003d\u003e ((((balance \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog)))))","state invariant holds obligation:(forall sRecord:StockRecord, priority:nat1 \u0026 (((sRecord.Name) not in set {(x.Name) | x in set (elems stocks)}) \u003d\u003e (((((balance \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog)) \u003d\u003e ((((balance \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog)))))","legal map application obligation:(forall sRecord:StockRecord, priority:nat1 \u0026 (((sRecord.Name) not in set {(x.Name) | x in set (elems stocks)}) \u003d\u003e ((sRecord.Name) in set (dom testValues))))","legal sequence application obligation:(forall sRecord:StockRecord, priority:nat1 \u0026 (((sRecord.Name) not in set {(x.Name) | x in set (elems stocks)}) \u003d\u003e (((sRecord.Name) in set (dom stockWatchers)) \u003d\u003e (priority in set (inds (((stocks(1, ... ,(priority - 1))) ^ [sRecord]) ^ (stocks((priority + 1), ... ,(len stocks)))))))))","operation establishes postcondition obligation:(forall sRecord:StockRecord, priority:nat1 \u0026 (((sRecord.Name) not in set {(x.Name) | x in set (elems stocks)}) \u003d\u003e (((sRecord.Name) in set (dom stockWatchers)) and (sRecord \u003d stocks(priority)))))","legal sequence application obligation:(forall ss:StockState \u0026 (forall s in set (inds stocks) \u0026 ((((stockWatchers((stocks(s).Name)).GetTriggeredAction)() \u003c\u003e nil) and ((stocks(s).State) \u003d ss)) \u003d\u003e (s in set (inds stocks)))))","legal map application obligation:(forall ss:StockState \u0026 (forall s in set (inds stocks) \u0026 ((stocks(s).Name) in set (dom stockWatchers))))","legal sequence application obligation:(forall ss:StockState \u0026 (forall s in set (inds stocks) \u0026 (s in set (inds stocks))))","legal sequence application obligation:(forall ss:StockState \u0026 (forall s in set (inds stocks) \u0026 (((stockWatchers((stocks(s).Name)).GetTriggeredAction)() \u003c\u003e nil) \u003d\u003e (s in set (inds stocks)))))","legal sequence application obligation:(forall ss:StockState \u0026 let res:seq of (StockRecord) \u003d RESULT in (forall i in set (inds res) \u0026 (i in set (inds res))))","operation establishes postcondition obligation:(forall ss:StockState \u0026 let res:seq of (StockRecord) \u003d RESULT in (forall i in set (inds res) \u0026 ((res(i).State) \u003d ss)))","legal sequence application obligation:(forall potBuys:seq of (StockRecord), time:nat \u0026 (forall x in set (inds potBuys) \u0026 (CanAfford(potBuys(x), balance) \u003d\u003e (x in set (inds potBuys)))))","type compatibility obligation:(forall potBuys:seq of (StockRecord), time:nat \u0026 (forall x in set (inds potBuys) \u0026 (balance \u003e\u003d 0)))","legal sequence application obligation:(forall potBuys:seq of (StockRecord), time:nat \u0026 (forall x in set (inds potBuys) \u0026 (x in set (inds potBuys))))","let be st existence obligation:(forall potBuys:seq of (StockRecord), time:nat \u0026 let affordableStocks:seq of (StockRecord) \u003d [potBuys(x) | x in set (inds potBuys) \u0026 CanAfford(potBuys(x), balance)] in (((len affordableStocks) \u003e 0) \u003d\u003e (exists x in set (inds affordableStocks) \u0026 (forall y in set (inds affordableStocks) \u0026 ((stockWatchers((affordableStocks(x).Name)).GetStockValue)(time) \u003e\u003d (stockWatchers((affordableStocks(y).Name)).GetStockValue)(time))))))","legal map application obligation:(forall potBuys:seq of (StockRecord), time:nat \u0026 let affordableStocks:seq of (StockRecord) \u003d [potBuys(x) | x in set (inds potBuys) \u0026 CanAfford(potBuys(x), balance)] in (((len affordableStocks) \u003e 0) \u003d\u003e (forall x in set (inds affordableStocks) \u0026 (forall y in set (inds affordableStocks) \u0026 ((affordableStocks(x).Name) in set (dom stockWatchers))))))","legal sequence application obligation:(forall potBuys:seq of (StockRecord), time:nat \u0026 let affordableStocks:seq of (StockRecord) \u003d [potBuys(x) | x in set (inds potBuys) \u0026 CanAfford(potBuys(x), balance)] in (((len affordableStocks) \u003e 0) \u003d\u003e (forall x in set (inds affordableStocks) \u0026 (forall y in set (inds affordableStocks) \u0026 (x in set (inds affordableStocks))))))","legal map application obligation:(forall potBuys:seq of (StockRecord), time:nat \u0026 let affordableStocks:seq of (StockRecord) \u003d [potBuys(x) | x in set (inds potBuys) \u0026 CanAfford(potBuys(x), balance)] in (((len affordableStocks) \u003e 0) \u003d\u003e (forall x in set (inds affordableStocks) \u0026 (forall y in set (inds affordableStocks) \u0026 ((affordableStocks(y).Name) in set (dom stockWatchers))))))","legal sequence application obligation:(forall potBuys:seq of (StockRecord), time:nat \u0026 let affordableStocks:seq of (StockRecord) \u003d [potBuys(x) | x in set (inds potBuys) \u0026 CanAfford(potBuys(x), balance)] in (((len affordableStocks) \u003e 0) \u003d\u003e (forall x in set (inds affordableStocks) \u0026 (forall y in set (inds affordableStocks) \u0026 (y in set (inds affordableStocks))))))","legal sequence application obligation:(forall potBuys:seq of (StockRecord), time:nat \u0026 let affordableStocks:seq of (StockRecord) \u003d [potBuys(x) | x in set (inds potBuys) \u0026 CanAfford(potBuys(x), balance)] in (((len affordableStocks) \u003e 0) \u003d\u003e (forall x in set (inds affordableStocks) \u0026 ((forall y in set (inds affordableStocks) \u0026 ((stockWatchers((affordableStocks(x).Name)).GetStockValue)(time) \u003e\u003d (stockWatchers((affordableStocks(y).Name)).GetStockValue)(time))) \u003d\u003e (x in set (inds affordableStocks))))))","let be st existence obligation:(forall potSells:seq of (StockRecord), time:nat \u0026 (((len potSells) \u003e 0) \u003d\u003e (exists x in set (inds potSells) \u0026 (forall y in set (inds potSells) \u0026 (((stockWatchers((potSells(x).Name)).GetStockValue)(time) - (potSells(x).Cost)) \u003e\u003d ((stockWatchers((potSells(y).Name)).GetStockValue)(time) - (potSells(y).Cost)))))))","legal map application obligation:(forall potSells:seq of (StockRecord), time:nat \u0026 (((len potSells) \u003e 0) \u003d\u003e (forall x in set (inds potSells) \u0026 (forall y in set (inds potSells) \u0026 ((potSells(x).Name) in set (dom stockWatchers))))))","legal sequence application obligation:(forall potSells:seq of (StockRecord), time:nat \u0026 (((len potSells) \u003e 0) \u003d\u003e (forall x in set (inds potSells) \u0026 (forall y in set (inds potSells) \u0026 (x in set (inds potSells))))))","legal sequence application obligation:(forall potSells:seq of (StockRecord), time:nat \u0026 (((len potSells) \u003e 0) \u003d\u003e (forall x in set (inds potSells) \u0026 (forall y in set (inds potSells) \u0026 (x in set (inds potSells))))))","legal map application obligation:(forall potSells:seq of (StockRecord), time:nat \u0026 (((len potSells) \u003e 0) \u003d\u003e (forall x in set (inds potSells) \u0026 (forall y in set (inds potSells) \u0026 ((potSells(y).Name) in set (dom stockWatchers))))))","legal sequence application obligation:(forall potSells:seq of (StockRecord), time:nat \u0026 (((len potSells) \u003e 0) \u003d\u003e (forall x in set (inds potSells) \u0026 (forall y in set (inds potSells) \u0026 (y in set (inds potSells))))))","legal sequence application obligation:(forall potSells:seq of (StockRecord), time:nat \u0026 (((len potSells) \u003e 0) \u003d\u003e (forall x in set (inds potSells) \u0026 (forall y in set (inds potSells) \u0026 (y in set (inds potSells))))))","legal sequence application obligation:(forall potSells:seq of (StockRecord), time:nat \u0026 (((len potSells) \u003e 0) \u003d\u003e (forall x in set (inds potSells) \u0026 ((forall y in set (inds potSells) \u0026 (((stockWatchers((potSells(x).Name)).GetStockValue)(time) - (potSells(x).Cost)) \u003e\u003d ((stockWatchers((potSells(y).Name)).GetStockValue)(time) - (potSells(y).Cost)))) \u003d\u003e (x in set (inds potSells))))))","legal map application obligation:(forall potSells:seq of (StockRecord), time:nat \u0026 (((len potSells) \u003e 0) \u003d\u003e ((RESULT.Name) in set (dom stockWatchers))))","legal map application obligation:(forall potSells:seq of (StockRecord), time:nat \u0026 (((len potSells) \u003e 0) \u003d\u003e (forall x in set (elems potSells) \u0026 ((x.Name) in set (dom stockWatchers)))))","operation establishes postcondition obligation:(forall potSells:seq of (StockRecord), time:nat \u0026 (((len potSells) \u003e 0) \u003d\u003e IsGTAll(((stockWatchers((RESULT.Name)).GetStockValue)(time) - (RESULT.Cost)), {((stockWatchers((x.Name)).GetStockValue)(time) - (x.Cost)) | x in set (elems potSells)})))","legal map application obligation:(forall potAction:StockRecord, time:nat \u0026 ((((potAction.State) \u003d \u003cPotentialBuy\u003e) and ((stockWatchers((potAction.Name)).GetTriggeredAction)() \u003d \u003cBuy\u003e)) \u003d\u003e (((potAction.State) \u003d \u003cPotentialBuy\u003e) \u003d\u003e ((potAction.Name) in set (dom stockWatchers)))))","legal map application obligation:(forall potAction:StockRecord, time:nat \u0026 ((((potAction.State) \u003d \u003cPotentialBuy\u003e) and ((stockWatchers((potAction.Name)).GetTriggeredAction)() \u003d \u003cBuy\u003e)) \u003d\u003e ((potAction.Name) in set (dom stockWatchers))))","state invariant holds obligation:(forall potAction:StockRecord, time:nat \u0026 ((((potAction.State) \u003d \u003cPotentialBuy\u003e) and ((stockWatchers((potAction.Name)).GetTriggeredAction)() \u003d \u003cBuy\u003e)) \u003d\u003e (((((balance \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog)) \u003d\u003e ((((balance \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog)))))","state invariant holds obligation:(forall potAction:StockRecord, time:nat \u0026 ((((potAction.State) \u003d \u003cPotentialBuy\u003e) and ((stockWatchers((potAction.Name)).GetTriggeredAction)() \u003d \u003cBuy\u003e)) \u003d\u003e (((((balance \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog)) \u003d\u003e (((((balance - value) \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog)))))","let be st existence obligation:(forall potAction:StockRecord, time:nat \u0026 ((((potAction.State) \u003d \u003cPotentialBuy\u003e) and ((stockWatchers((potAction.Name)).GetTriggeredAction)() \u003d \u003cBuy\u003e)) \u003d\u003e (exists i in set (inds stocks) \u0026 ((stocks(i).Name) \u003d (potAction.Name)))))","legal sequence application obligation:(forall potAction:StockRecord, time:nat \u0026 ((((potAction.State) \u003d \u003cPotentialBuy\u003e) and ((stockWatchers((potAction.Name)).GetTriggeredAction)() \u003d \u003cBuy\u003e)) \u003d\u003e (i in set (inds stocks))))","state invariant holds obligation:(forall potAction:StockRecord, time:nat \u0026 ((((potAction.State) \u003d \u003cPotentialBuy\u003e) and ((stockWatchers((potAction.Name)).GetTriggeredAction)() \u003d \u003cBuy\u003e)) \u003d\u003e ((((((balance - value) \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog)) \u003d\u003e (((((balance - value) \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog)))))","legal sequence application obligation:(forall potAction:StockRecord, time:nat \u0026 ((((potAction.State) \u003d \u003cPotentialBuy\u003e) and ((stockWatchers((potAction.Name)).GetTriggeredAction)() \u003d \u003cBuy\u003e)) \u003d\u003e ((i \u003e 0) and (i \u003c\u003d ((len stocks) + 1)))))","legal sequence application obligation:(forall potAction:StockRecord, time:nat \u0026 ((((potAction.State) \u003d \u003cPotentialBuy\u003e) and ((stockWatchers((potAction.Name)).GetTriggeredAction)() \u003d \u003cBuy\u003e)) \u003d\u003e (i in set (inds stocks))))","operation establishes postcondition obligation:(forall potAction:StockRecord, time:nat \u0026 ((((potAction.State) \u003d \u003cPotentialBuy\u003e) and ((stockWatchers((potAction.Name)).GetTriggeredAction)() \u003d \u003cBuy\u003e)) \u003d\u003e ((balance - value) \u003e\u003d 0)))","legal map application obligation:(forall potAction:StockRecord, time:nat \u0026 ((((potAction.State) \u003d \u003cBought\u003e) and ((stockWatchers((potAction.Name)).GetTriggeredAction)() \u003d \u003cSell\u003e)) \u003d\u003e (((potAction.State) \u003d \u003cBought\u003e) \u003d\u003e ((potAction.Name) in set (dom stockWatchers)))))","legal map application obligation:(forall potAction:StockRecord, time:nat \u0026 ((((potAction.State) \u003d \u003cBought\u003e) and ((stockWatchers((potAction.Name)).GetTriggeredAction)() \u003d \u003cSell\u003e)) \u003d\u003e ((potAction.Name) in set (dom stockWatchers))))","state invariant holds obligation:(forall potAction:StockRecord, time:nat \u0026 ((((potAction.State) \u003d \u003cBought\u003e) and ((stockWatchers((potAction.Name)).GetTriggeredAction)() \u003d \u003cSell\u003e)) \u003d\u003e (((((balance \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog)) \u003d\u003e ((((balance \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog)))))","state invariant holds obligation:(forall potAction:StockRecord, time:nat \u0026 ((((potAction.State) \u003d \u003cBought\u003e) and ((stockWatchers((potAction.Name)).GetTriggeredAction)() \u003d \u003cSell\u003e)) \u003d\u003e (((((balance \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog)) \u003d\u003e (((((balance + value) \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog)))))","let be st existence obligation:(forall potAction:StockRecord, time:nat \u0026 ((((potAction.State) \u003d \u003cBought\u003e) and ((stockWatchers((potAction.Name)).GetTriggeredAction)() \u003d \u003cSell\u003e)) \u003d\u003e (exists i in set (inds stocks) \u0026 ((stocks(i).Name) \u003d (potAction.Name)))))","legal sequence application obligation:(forall potAction:StockRecord, time:nat \u0026 ((((potAction.State) \u003d \u003cBought\u003e) and ((stockWatchers((potAction.Name)).GetTriggeredAction)() \u003d \u003cSell\u003e)) \u003d\u003e (i in set (inds stocks))))","state invariant holds obligation:(forall potAction:StockRecord, time:nat \u0026 ((((potAction.State) \u003d \u003cBought\u003e) and ((stockWatchers((potAction.Name)).GetTriggeredAction)() \u003d \u003cSell\u003e)) \u003d\u003e ((((((balance + value) \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog)) \u003d\u003e (((((balance + value) \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog)))))","legal sequence application obligation:(forall potAction:StockRecord, time:nat \u0026 ((((potAction.State) \u003d \u003cBought\u003e) and ((stockWatchers((potAction.Name)).GetTriggeredAction)() \u003d \u003cSell\u003e)) \u003d\u003e ((i \u003e 0) and (i \u003c\u003d ((len stocks) + 1)))))","legal sequence application obligation:(forall potAction:StockRecord, time:nat \u0026 ((((potAction.State) \u003d \u003cBought\u003e) and ((stockWatchers((potAction.Name)).GetTriggeredAction)() \u003d \u003cSell\u003e)) \u003d\u003e (i in set (inds stocks))))","operation establishes postcondition obligation:(forall potAction:StockRecord, time:nat \u0026 ((((potAction.State) \u003d \u003cBought\u003e) and ((stockWatchers((potAction.Name)).GetTriggeredAction)() \u003d \u003cSell\u003e)) \u003d\u003e ((balance + value) \u003e\u003d 0)))","legal sequence application obligation:(forall time:nat \u0026 (i in set (inds stocks)))","legal map application obligation:(forall time:nat \u0026 ((stock.Name) in set (dom stockWatchers)))","operation call obligation:(forall time:nat \u0026 (forall stocks1:seq of (StockRecord), stockWatchers2:map (StockIdentifier) to (StockWatcher), actionLog3:seq of (ActionEvent), balance4:int \u0026 (((((balance4 \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog)) \u003d\u003e (((FindValidSell(potSells, time).State) \u003d \u003cBought\u003e) and ((stockWatchers((potAction.Name)).GetTriggeredAction)() \u003d \u003cSell\u003e)))))","operation call obligation:(forall time:nat \u0026 (forall stocks1:seq of (StockRecord), stockWatchers2:map (StockIdentifier) to (StockWatcher), actionLog3:seq of (ActionEvent), balance4:int \u0026 (((((balance4 \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog)) \u003d\u003e (forall stocks21:seq of (StockRecord), stockWatchers22:map (StockIdentifier) to (StockWatcher), actionLog23:seq of (ActionEvent), balance24:int \u0026 (((balance24 \u003e\u003d 0) and ((((balance24 \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog))) \u003d\u003e (true \u003d\u003e (true \u003d\u003e (((validBuy.State) \u003d \u003cPotentialBuy\u003e) and ((stockWatchers((potAction.Name)).GetTriggeredAction)() \u003d \u003cBuy\u003e)))))))))","operation establishes postcondition obligation:(forall time:nat \u0026 (forall stocks1:seq of (StockRecord), stockWatchers2:map (StockIdentifier) to (StockWatcher), actionLog3:seq of (ActionEvent), balance4:int \u0026 (((((balance4 \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog)) \u003d\u003e (forall stocks21:seq of (StockRecord), stockWatchers22:map (StockIdentifier) to (StockWatcher), actionLog23:seq of (ActionEvent), balance24:int \u0026 (((balance24 \u003e\u003d 0) and ((((balance24 \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog))) \u003d\u003e (true \u003d\u003e (true \u003d\u003e (forall stocks25:seq of (StockRecord), stockWatchers26:map (StockIdentifier) to (StockWatcher), actionLog27:seq of (ActionEvent), balance28:int \u0026 (((balance28 \u003e\u003d 0) and ((((balance28 \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog))) \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e MaxOneOfEachActionTypePerTime(actionLog))))))))))))))))))))","legal sequence application obligation:(forall actionLog:seq of (ActionEvent) \u0026 (forall x, y in set (inds actionLog) \u0026 ((x \u003c\u003e y) \u003d\u003e (x in set (inds actionLog)))))","legal sequence application obligation:(forall actionLog:seq of (ActionEvent) \u0026 (forall x, y in set (inds actionLog) \u0026 ((x \u003c\u003e y) \u003d\u003e (y in set (inds actionLog)))))","legal sequence application obligation:(forall actionLog:seq of (ActionEvent) \u0026 (forall x, y in set (inds actionLog) \u0026 (((x \u003c\u003e y) and ((actionLog(x).Time) \u003d (actionLog(y).Time))) \u003d\u003e (x in set (inds actionLog)))))","legal sequence application obligation:(forall actionLog:seq of (ActionEvent) \u0026 (forall x, y in set (inds actionLog) \u0026 (((x \u003c\u003e y) and ((actionLog(x).Time) \u003d (actionLog(y).Time))) \u003d\u003e (y in set (inds actionLog)))))","type invariant satisfiable obligation:(exists mk_Region(p1, p2):Region \u0026 (p1 \u003e\u003d p2))","legal map application obligation:(forall mk_StockRecord(p1, p2, p3, p4, p5):StockRecord \u0026 (\u003cPotentialBuy\u003e in set (dom p2)))","legal map application obligation:(forall mk_StockRecord(p1, p2, p3, p4, p5):StockRecord \u0026 (((p2(\u003cPotentialBuy\u003e).Action) \u003d \u003cBuy\u003e) \u003d\u003e (\u003cBought\u003e in set (dom p2))))","type invariant satisfiable obligation:(exists mk_StockRecord(p1, p2, p3, p4, p5):StockRecord \u0026 (((p2(\u003cPotentialBuy\u003e).Action) \u003d \u003cBuy\u003e) and ((p2(\u003cBought\u003e).Action) \u003d \u003cSell\u003e)))","enumeration map injectivity obligation:(forall m1, m2 in set {{mk_token(\"test\") |-\u003e [mk_Event(\u003cLeavesNoActionRegion\u003e, 6, 5), mk_Event(\u003cLowerLimit\u003e, 5, 8), mk_Event(\u003cUpperLimit\u003e, 4, 12), mk_Event(\u003cEntersNoActionRegion\u003e, 3, 11), mk_Event(\u003cLeavesNoActionRegion\u003e, 2, 13), mk_Event(\u003cUpperLimit\u003e, 1, 12), mk_Event(\u003cEntersNoActionRegion\u003e, 0, 10)]}, {mk_token(\"test12\") |-\u003e [mk_Event(\u003cLeavesNoActionRegion\u003e, 6, 5), mk_Event(\u003cLowerLimit\u003e, 5, 8), mk_Event(\u003cUpperLimit\u003e, 4, 12), mk_Event(\u003cEntersNoActionRegion\u003e, 3, 11), mk_Event(\u003cLeavesNoActionRegion\u003e, 2, 16), mk_Event(\u003cUpperLimit\u003e, 1, 12), mk_Event(\u003cEntersNoActionRegion\u003e, 0, 10)]}, {mk_token(\"test2\") |-\u003e [mk_Event(\u003cLeavesNoActionRegion\u003e, 6, 5), mk_Event(\u003cUpperLimit\u003e, 5, 8), mk_Event(\u003cLowerLimit\u003e, 4, 8), mk_Event(\u003cEntersNoActionRegion\u003e, 3, 11), mk_Event(\u003cLeavesNoActionRegion\u003e, 2, 6), mk_Event(\u003cLowerLimit\u003e, 1, 8), mk_Event(\u003cEntersNoActionRegion\u003e, 0, 10)]}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","non-empty sequence obligation:(((len valueHistory) \u003e\u003d 1) \u003d\u003e ((nil \u003d currentRateOfChange) \u003d\u003e (valueHistory \u003c\u003e [])))","type compatibility obligation:(((len valueHistory) \u003e\u003d 1) \u003d\u003e ((not (nil \u003d currentRateOfChange)) \u003d\u003e ((is_(currentRateOfChange, \u003cconstant\u003e) or is_(currentRateOfChange, \u003cnegative\u003e)) or is_(currentRateOfChange, \u003cpositive\u003e))))","non-empty sequence obligation:(((len valueHistory) \u003e\u003d 1) \u003d\u003e ((not (nil \u003d currentRateOfChange)) \u003d\u003e (valueHistory \u003c\u003e [])))","non-empty sequence obligation:(((len valueHistory) \u003e\u003d 1) \u003d\u003e (valueHistory \u003c\u003e []))","non-empty sequence obligation:(((len valueHistory) \u003e\u003d 1) \u003d\u003e (([((hd valueHistory) + 1)] ^ valueHistory) \u003c\u003e []))","type compatibility obligation:(((len valueHistory) \u003e\u003d 1) \u003d\u003e is_(([((hd valueHistory) - 1)] ^ valueHistory), seq of (StockValue)))","non-empty sequence obligation:(((len valueHistory) \u003e\u003d 1) \u003d\u003e (([((hd valueHistory) - 1)] ^ ([((hd valueHistory) + 1)] ^ valueHistory)) \u003c\u003e []))","legal sequence application obligation:(((len valueHistory) \u003e\u003d 1) \u003d\u003e (((cases currentRateOfChange :\nnil -\u003e InitialRateOfChange((hd valueHistory))\nothers NextRateOfChange(currentRateOfChange, (hd valueHistory))\n end) \u003d \u003cpositive\u003e) \u003d\u003e (1 in set (inds ([(hd valueHistory)] ^ ([((hd valueHistory) - 1)] ^ ([((hd valueHistory) + 1)] ^ valueHistory)))))))","legal sequence application obligation:(((len valueHistory) \u003e\u003d 1) \u003d\u003e (((cases currentRateOfChange :\nnil -\u003e InitialRateOfChange((hd valueHistory))\nothers NextRateOfChange(currentRateOfChange, (hd valueHistory))\n end) \u003d \u003cpositive\u003e) \u003d\u003e (2 in set (inds ([(hd valueHistory)] ^ ([((hd valueHistory) - 1)] ^ ([((hd valueHistory) + 1)] ^ valueHistory)))))))","legal sequence application obligation:(((len valueHistory) \u003e\u003d 1) \u003d\u003e ((((cases currentRateOfChange :\nnil -\u003e InitialRateOfChange((hd valueHistory))\nothers NextRateOfChange(currentRateOfChange, (hd valueHistory))\n end) \u003d \u003cpositive\u003e) \u003d\u003e (valueHistory(1) \u003e valueHistory(2))) \u003d\u003e (((cases currentRateOfChange :\nnil -\u003e InitialRateOfChange((hd valueHistory))\nothers NextRateOfChange(currentRateOfChange, (hd valueHistory))\n end) \u003d \u003cnegative\u003e) \u003d\u003e (1 in set (inds ([(hd valueHistory)] ^ ([((hd valueHistory) - 1)] ^ ([((hd valueHistory) + 1)] ^ valueHistory))))))))","legal sequence application obligation:(((len valueHistory) \u003e\u003d 1) \u003d\u003e ((((cases currentRateOfChange :\nnil -\u003e InitialRateOfChange((hd valueHistory))\nothers NextRateOfChange(currentRateOfChange, (hd valueHistory))\n end) \u003d \u003cpositive\u003e) \u003d\u003e (valueHistory(1) \u003e valueHistory(2))) \u003d\u003e (((cases currentRateOfChange :\nnil -\u003e InitialRateOfChange((hd valueHistory))\nothers NextRateOfChange(currentRateOfChange, (hd valueHistory))\n end) \u003d \u003cnegative\u003e) \u003d\u003e (2 in set (inds ([(hd valueHistory)] ^ ([((hd valueHistory) - 1)] ^ ([((hd valueHistory) + 1)] ^ valueHistory))))))))","legal sequence application obligation:(((len valueHistory) \u003e\u003d 1) \u003d\u003e ((((cases currentRateOfChange :\nnil -\u003e InitialRateOfChange((hd valueHistory))\nothers NextRateOfChange(currentRateOfChange, (hd valueHistory))\n end) \u003d \u003cpositive\u003e) \u003d\u003e (valueHistory(1) \u003e valueHistory(2))) \u003d\u003e ((((cases currentRateOfChange :\nnil -\u003e InitialRateOfChange((hd valueHistory))\nothers NextRateOfChange(currentRateOfChange, (hd valueHistory))\n end) \u003d \u003cnegative\u003e) \u003d\u003e (valueHistory(1) \u003c valueHistory(2))) \u003d\u003e (((cases currentRateOfChange :\nnil -\u003e InitialRateOfChange((hd valueHistory))\nothers NextRateOfChange(currentRateOfChange, (hd valueHistory))\n end) \u003d \u003cconstant\u003e) \u003d\u003e (1 in set (inds ([(hd valueHistory)] ^ ([((hd valueHistory) - 1)] ^ ([((hd valueHistory) + 1)] ^ valueHistory)))))))))","legal sequence application obligation:(((len valueHistory) \u003e\u003d 1) \u003d\u003e ((((cases currentRateOfChange :\nnil -\u003e InitialRateOfChange((hd valueHistory))\nothers NextRateOfChange(currentRateOfChange, (hd valueHistory))\n end) \u003d \u003cpositive\u003e) \u003d\u003e (valueHistory(1) \u003e valueHistory(2))) \u003d\u003e ((((cases currentRateOfChange :\nnil -\u003e InitialRateOfChange((hd valueHistory))\nothers NextRateOfChange(currentRateOfChange, (hd valueHistory))\n end) \u003d \u003cnegative\u003e) \u003d\u003e (valueHistory(1) \u003c valueHistory(2))) \u003d\u003e (((cases currentRateOfChange :\nnil -\u003e InitialRateOfChange((hd valueHistory))\nothers NextRateOfChange(currentRateOfChange, (hd valueHistory))\n end) \u003d \u003cconstant\u003e) \u003d\u003e (2 in set (inds ([(hd valueHistory)] ^ ([((hd valueHistory) - 1)] ^ ([((hd valueHistory) + 1)] ^ valueHistory)))))))))","non-empty sequence obligation:(((len valueHistory) \u003e\u003d 1) \u003d\u003e ((((cases currentRateOfChange :\nnil -\u003e InitialRateOfChange((hd valueHistory))\nothers NextRateOfChange(currentRateOfChange, (hd valueHistory))\n end) \u003d \u003cpositive\u003e) \u003d\u003e (valueHistory(1) \u003e valueHistory(2))) \u003d\u003e ((((cases currentRateOfChange :\nnil -\u003e InitialRateOfChange((hd valueHistory))\nothers NextRateOfChange(currentRateOfChange, (hd valueHistory))\n end) \u003d \u003cnegative\u003e) \u003d\u003e (valueHistory(1) \u003c valueHistory(2))) \u003d\u003e ((((cases currentRateOfChange :\nnil -\u003e InitialRateOfChange((hd valueHistory))\nothers NextRateOfChange(currentRateOfChange, (hd valueHistory))\n end) \u003d \u003cconstant\u003e) \u003d\u003e (valueHistory(1) \u003d valueHistory(2))) \u003d\u003e (([(hd valueHistory)] ^ ([((hd valueHistory) - 1)] ^ ([((hd valueHistory) + 1)] ^ valueHistory))) \u003c\u003e [])))))","operation establishes postcondition obligation:(((len valueHistory) \u003e\u003d 1) \u003d\u003e ((((cases currentRateOfChange :\nnil -\u003e InitialRateOfChange((hd valueHistory))\nothers NextRateOfChange(currentRateOfChange, (hd valueHistory))\n end) \u003d \u003cpositive\u003e) \u003d\u003e (valueHistory(1) \u003e valueHistory(2))) and ((((cases currentRateOfChange :\nnil -\u003e InitialRateOfChange((hd valueHistory))\nothers NextRateOfChange(currentRateOfChange, (hd valueHistory))\n end) \u003d \u003cnegative\u003e) \u003d\u003e (valueHistory(1) \u003c valueHistory(2))) and ((((cases currentRateOfChange :\nnil -\u003e InitialRateOfChange((hd valueHistory))\nothers NextRateOfChange(currentRateOfChange, (hd valueHistory))\n end) \u003d \u003cconstant\u003e) \u003d\u003e (valueHistory(1) \u003d valueHistory(2))) and ((hd ([(hd valueHistory)] ^ ([((hd valueHistory) - 1)] ^ ([((hd valueHistory) + 1)] ^ valueHistory)))) \u003e\u003d 0)))))","non-empty sequence obligation:(valueHistory \u003c\u003e [])","cases exhaustive obligation:(forall sv:StockValue \u0026 let r:int \u003d (MATH`rand(21) mod 3) in ((sv \u003e 0) \u003d\u003e (((r \u003d 0) or (r \u003d 1)) or (r \u003d 2))))","cases exhaustive obligation:(forall sv:StockValue \u0026 let r:int \u003d (MATH`rand(21) mod 3) in ((not (sv \u003e 0)) \u003d\u003e (((r \u003d 0) or (r \u003d 1)) or (r \u003d 2))))","finite set obligation:(forall roc:RateOfChange, sv:StockValue \u0026 (exists finmap1:map (nat) to (RateOfChange) \u0026 (forall x:RateOfChange \u0026 (((x \u003c\u003e roc) and ((x \u003d \u003cnegative\u003e) \u003d\u003e (sv \u003e 0))) \u003d\u003e (exists findex2 in set (dom finmap1) \u0026 (finmap1(findex2) \u003d x))))))","legal sequence application obligation:(forall roc:RateOfChange, sv:StockValue \u0026 let r:int \u003d MATH`rand(10), other:seq of (RateOfChange) \u003d MakelistFromSet({x | x:RateOfChange \u0026 ((x \u003c\u003e roc) and ((x \u003d \u003cnegative\u003e) \u003d\u003e (sv \u003e 0)))}) in ((not ((r \u003e\u003d 0) and ((r \u003c\u003d 7) and ((roc \u003d \u003cnegative\u003e) \u003d\u003e (sv \u003e 0))))) \u003d\u003e (((MATH`rand(20) mod (len other)) + 1) in set (inds other))))","let be st existence obligation:(forall roc:set of (RateOfChange) \u0026 (((card roc) \u003e 0) \u003d\u003e (exists r in set roc \u0026 true)))","map compatible obligation:(forall stock:Stock \u0026 (((stock.GetName)() not in set (dom stocks)) \u003d\u003e (forall ldom1 in set (dom {(stock.GetName)() |-\u003e stock}), rdom2 in set (dom stocks) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e ({(stock.GetName)() |-\u003e stock}(ldom1) \u003d stocks(rdom2))))))","operation establishes postcondition obligation:(forall stock:Stock \u0026 (((stock.GetName)() not in set (dom stocks)) \u003d\u003e ((stock.GetName)() in set (dom ({(stock.GetName)() |-\u003e stock} munion stocks)))))","operation establishes postcondition obligation:(forall stock:Stock \u0026 (((stock.GetName)() in set (dom stocks)) \u003d\u003e ((stock.GetName)() not in set (dom ({(stock.GetName)()} \u003c-: stocks)))))","legal map application obligation:(forall name:StockIdentifier \u0026 ((name in set (dom stocks)) \u003d\u003e (name in set (dom stocks))))","operation call obligation:(forall text:seq of (char) \u0026 ((\"\" \u003d \"\") \u003c\u003d\u003e (\"\" \u003d nil)))","non-zero obligation:(forall a:real \u0026 ((a \u003c\u003e 0) \u003d\u003e (a \u003c\u003e 0)))"] \ No newline at end of file +["legal sequence application obligation:(forall sr:StockRecord, predefinedEvents:seq of (Event) \u0026 (let val:nat \u003d (predefinedEvents((len predefinedEvents)).Value) in IsInRegion(val, (sr.NoActionReg)) \u003d\u003e ((len predefinedEvents) in set (inds predefinedEvents))))","state invariant holds obligation:(forall sr:StockRecord, predefinedEvents:seq of (Event) \u0026 (let val:nat \u003d (predefinedEvents((len predefinedEvents)).Value) in IsInRegion(val, (sr.NoActionReg)) \u003d\u003e (((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) and (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) and (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e) or (((eventHistory((e + 1)).Type) \u003d \u003cValley\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cPeak\u003e))))))))))","state invariant holds obligation:(forall sr:StockRecord \u0026 ((((sr.Name) in set (World`stockMarket.GetStockNames)()) and let val:StockValue \u003d ((World`stockMarket.GetStock)((sr.Name)).GetCurrentValue)() in IsInRegion(val, (sr.NoActionReg))) \u003d\u003e (((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) and (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) and (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e) or (((eventHistory((e + 1)).Type) \u003d \u003cValley\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cPeak\u003e))))))))))","non-empty sequence obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e (stockHistory \u003c\u003e [])))","legal sequence application obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e (IsInRegion((hd stockHistory), reg) \u003d\u003e (2 in set (inds stockHistory)))))","state invariant holds obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e ((((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) and (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) and (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e) or (((eventHistory((e + 1)).Type) \u003d \u003cValley\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cPeak\u003e)))))))) \u003d\u003e (((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) and (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) and (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e) or (((eventHistory((e + 1)).Type) \u003d \u003cValley\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cPeak\u003e)))))))))))","non-empty sequence obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e (stockHistory \u003c\u003e [])))","legal sequence application obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e ((not IsInRegion((hd stockHistory), reg)) \u003d\u003e (2 in set (inds stockHistory)))))","state invariant holds obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e ((((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) and (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) and (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e) or (((eventHistory((e + 1)).Type) \u003d \u003cValley\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cPeak\u003e)))))))) \u003d\u003e (((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) and (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) and (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e) or (((eventHistory((e + 1)).Type) \u003d \u003cValley\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cPeak\u003e)))))))))))","non-empty sequence obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e (stockHistory \u003c\u003e [])))","legal sequence application obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e (((hd stockHistory) \u003d u) \u003d\u003e (2 in set (inds stockHistory)))))","state invariant holds obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e ((((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) and (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) and (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e) or (((eventHistory((e + 1)).Type) \u003d \u003cValley\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cPeak\u003e)))))))) \u003d\u003e (((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) and (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) and (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e) or (((eventHistory((e + 1)).Type) \u003d \u003cValley\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cPeak\u003e)))))))))))","non-empty sequence obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e (stockHistory \u003c\u003e [])))","legal sequence application obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e (((hd stockHistory) \u003d l) \u003d\u003e (2 in set (inds stockHistory)))))","state invariant holds obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e ((((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) and (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) and (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e) or (((eventHistory((e + 1)).Type) \u003d \u003cValley\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cPeak\u003e)))))))) \u003d\u003e (((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) and (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) and (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e) or (((eventHistory((e + 1)).Type) \u003d \u003cValley\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cPeak\u003e)))))))))))","non-empty sequence obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e (stockHistory \u003c\u003e [])))","state invariant holds obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e ((((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) and (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) and (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e) or (((eventHistory((e + 1)).Type) \u003d \u003cValley\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cPeak\u003e)))))))) \u003d\u003e (((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) and (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) and (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e) or (((eventHistory((e + 1)).Type) \u003d \u003cValley\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cPeak\u003e)))))))))))","non-empty sequence obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e (stockHistory \u003c\u003e [])))","state invariant holds obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e ((((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) and (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) and (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e) or (((eventHistory((e + 1)).Type) \u003d \u003cValley\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cPeak\u003e)))))))) \u003d\u003e (((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) and (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) and (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e) or (((eventHistory((e + 1)).Type) \u003d \u003cValley\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cPeak\u003e)))))))))))","legal sequence application obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e (true \u003d\u003e ((len ([mk_Event(\u003cValley\u003e, time, cv)] ^ ([mk_Event(\u003cPeak\u003e, time, cv)] ^ ([mk_Event(\u003cLowerLimit\u003e, time, cv)] ^ ([mk_Event(\u003cUpperLimit\u003e, time, cv)] ^ ([mk_Event(\u003cLeavesNoActionRegion\u003e, time, cv)] ^ ([mk_Event(\u003cEntersNoActionRegion\u003e, time, cv)] ^ eventHistory))))))) in set (inds ([mk_Event(\u003cValley\u003e, time, cv)] ^ ([mk_Event(\u003cPeak\u003e, time, cv)] ^ ([mk_Event(\u003cLowerLimit\u003e, time, cv)] ^ ([mk_Event(\u003cUpperLimit\u003e, time, cv)] ^ ([mk_Event(\u003cLeavesNoActionRegion\u003e, time, cv)] ^ ([mk_Event(\u003cEntersNoActionRegion\u003e, time, cv)] ^ eventHistory)))))))))))","legal sequence application obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e (true \u003d\u003e (((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e (e in set (inds eventHistory))))))))","legal sequence application obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e (true \u003d\u003e (((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e (((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e ((e + 1) in set (inds eventHistory)))))))))","legal sequence application obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e (true \u003d\u003e (((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e (((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e ((not ((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e)) \u003d\u003e ((e + 1) in set (inds eventHistory))))))))))","legal sequence application obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e (true \u003d\u003e (((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) \u003d\u003e (e in set (inds eventHistory)))))))))","legal sequence application obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e (true \u003d\u003e (((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) \u003d\u003e (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e ((e + 1) in set (inds eventHistory))))))))))","legal sequence application obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e (true \u003d\u003e (((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) \u003d\u003e (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e ((not ((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e)) \u003d\u003e ((e + 1) in set (inds eventHistory)))))))))))","legal sequence application obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e (true \u003d\u003e (((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) \u003d\u003e (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e ((not ((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e)) \u003d\u003e ((not ((eventHistory((e + 1)).Type) \u003d \u003cValley\u003e)) \u003d\u003e ((e + 1) in set (inds eventHistory))))))))))))","operation establishes postcondition obligation:(forall time:nat \u0026 (let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2) \u003d\u003e (true \u003d\u003e (((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) and (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) and (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e) or (((eventHistory((e + 1)).Type) \u003d \u003cValley\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cPeak\u003e)))))))))))","legal map application obligation:(forall tim:nat \u0026 ((stockRecord.State) in set (dom (stockRecord.Triggers))))","state invariant holds obligation:(forall tim:nat \u0026 ((((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) and (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) and (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e) or (((eventHistory((e + 1)).Type) \u003d \u003cValley\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cPeak\u003e)))))))) \u003d\u003e (((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) and (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) and (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e) or (((eventHistory((e + 1)).Type) \u003d \u003cValley\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cPeak\u003e))))))))))","operation call obligation:(forall time:nat \u0026 let stockHistory:seq of (StockValue) \u003d ((sm.GetStock)((stockRecord.Name)).GetValueHistory)() in ((len stockHistory) \u003e\u003d 2))","operation establishes postcondition obligation:(forall time:nat \u0026 (forall eventHistory1:seq of (Event), stockRecord2:StockRecord, sm3:[StockMarket], currentlyTriggeredAction4:[ActionType] \u0026 (((((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) and (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) and (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e) or (((eventHistory((e + 1)).Type) \u003d \u003cValley\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cPeak\u003e)))))))) and (((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) and (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) and (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e) or (((eventHistory((e + 1)).Type) \u003d \u003cValley\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cPeak\u003e))))))))) \u003d\u003e (forall eventHistory5:seq of (Event), stockRecord6:StockRecord, sm7:[StockMarket], currentlyTriggeredAction8:[ActionType] \u0026 ((((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) and (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) and (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e) or (((eventHistory((e + 1)).Type) \u003d \u003cValley\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cPeak\u003e)))))))) \u003d\u003e NoActiveTriggerInNoActionRegion(GetStockValue(time), (stockRecord.NoActionReg), currentlyTriggeredAction))))))","state invariant holds obligation:(forall sr:StockRecord \u0026 ((((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) and (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) and (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e) or (((eventHistory((e + 1)).Type) \u003d \u003cValley\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cPeak\u003e)))))))) \u003d\u003e (((eventHistory((len eventHistory)).Type) \u003d \u003cEntersNoActionRegion\u003e) and (forall e in set (inds eventHistory) \u0026 ((e \u003c\u003e (len eventHistory)) \u003d\u003e ((((eventHistory(e).Type) \u003d \u003cLeavesNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLowerLimit\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cUpperLimit\u003e))) and (((eventHistory(e).Type) \u003d \u003cEntersNoActionRegion\u003e) \u003d\u003e (((eventHistory((e + 1)).Type) \u003d \u003cLeavesNoActionRegion\u003e) or (((eventHistory((e + 1)).Type) \u003d \u003cValley\u003e) or ((eventHistory((e + 1)).Type) \u003d \u003cPeak\u003e))))))))))","legal sequence application obligation:(forall time:nat \u0026 (((len eventHistory) \u003e 0) \u003d\u003e (1 in set (inds eventHistory))))","legal sequence application obligation:(forall time:nat \u0026 (((len eventHistory) \u003e 0) \u003d\u003e (((len eventHistory) - time) in set (inds eventHistory))))","non-empty sequence obligation:(forall svs:seq of (StockValue) \u0026 (svs \u003c\u003e []))","legal sequence application obligation:(forall svs:seq of (StockValue) \u0026 let current:StockValue \u003d (hd svs) in (forall i in set (inds svs) \u0026 (i in set (inds svs))))","legal sequence application obligation:(forall svs:seq of (StockValue) \u0026 let current:StockValue \u003d (hd svs) in let indicesOneAbove:set of (nat1) \u003d {i | i in set (inds svs) \u0026 (((current + 1) \u003d svs(i)) and (i \u003c\u003e (len svs)))} in (forall i in set indicesOneAbove \u0026 (forall v in set {2, ... ,i} \u0026 (v in set (inds svs)))))","legal sequence application obligation:(forall svs:seq of (StockValue) \u0026 let current:StockValue \u003d (hd svs) in let indicesOneAbove:set of (nat1) \u003d {i | i in set (inds svs) \u0026 (((current + 1) \u003d svs(i)) and (i \u003c\u003e (len svs)))} in (forall i in set indicesOneAbove \u0026 (forall v in set {2, ... ,i} \u0026 (((current + 1) \u003d svs(v)) \u003d\u003e ((i + 1) in set (inds svs))))))","non-empty sequence obligation:(forall svs:seq of (StockValue) \u0026 (svs \u003c\u003e []))","legal sequence application obligation:(forall svs:seq of (StockValue) \u0026 let current:StockValue \u003d (hd svs) in (forall i in set (inds svs) \u0026 (i in set (inds svs))))","legal sequence application obligation:(forall svs:seq of (StockValue) \u0026 let current:StockValue \u003d (hd svs) in let indicesOneBelow:set of (nat1) \u003d {i | i in set (inds svs) \u0026 (((current - 1) \u003d svs(i)) and (i \u003c\u003e (len svs)))} in (forall i in set indicesOneBelow \u0026 (forall v in set {2, ... ,i} \u0026 (v in set (inds svs)))))","legal sequence application obligation:(forall svs:seq of (StockValue) \u0026 let current:StockValue \u003d (hd svs) in let indicesOneBelow:set of (nat1) \u003d {i | i in set (inds svs) \u0026 (((current - 1) \u003d svs(i)) and (i \u003c\u003e (len svs)))} in (forall i in set indicesOneBelow \u0026 (forall v in set {2, ... ,i} \u0026 (((current - 1) \u003d svs(v)) \u003d\u003e ((i + 1) in set (inds svs))))))","legal sequence application obligation:(forall time:nat, events:seq of (Event) \u0026 (forall x in set (inds events) \u0026 (x in set (inds events))))","let be st existence obligation:(forall time:nat, events:seq of (Event) \u0026 let pastEvents:set of (nat1) \u003d {x | x in set (inds events) \u0026 ((events(x).TimeStamp) \u003c\u003d time)} in (exists i, j in set pastEvents \u0026 ((i \u003c\u003e j) \u003d\u003e ((events(i).TimeStamp) \u003c\u003d (events(j).TimeStamp)))))","legal sequence application obligation:(forall time:nat, events:seq of (Event) \u0026 let pastEvents:set of (nat1) \u003d {x | x in set (inds events) \u0026 ((events(x).TimeStamp) \u003c\u003d time)} in (forall i, j in set pastEvents \u0026 ((i \u003c\u003e j) \u003d\u003e (i in set (inds events)))))","legal sequence application obligation:(forall time:nat, events:seq of (Event) \u0026 let pastEvents:set of (nat1) \u003d {x | x in set (inds events) \u0026 ((events(x).TimeStamp) \u003c\u003d time)} in (forall i, j in set pastEvents \u0026 ((i \u003c\u003e j) \u003d\u003e (j in set (inds events)))))","legal sequence application obligation:(forall time:nat, action:ActionTrigger, eventHistory:seq of (Event) \u0026 let tgr:seq of (EventType) \u003d (action.Trigger) in let index:nat1 \u003d FindLowestIndexFromTime(time, eventHistory), s:seq of (Event) \u003d (eventHistory(index, ... ,((index + (len tgr)) - 1))) in (forall i in set (inds s) \u0026 (i in set (inds s))))","legal sequence application obligation:(forall time:nat, action:ActionTrigger, eventHistory:seq of (Event) \u0026 let tgr:seq of (EventType) \u003d (action.Trigger) in let index:nat1 \u003d FindLowestIndexFromTime(time, eventHistory), s:seq of (Event) \u003d (eventHistory(index, ... ,((index + (len tgr)) - 1))) in (forall i in set (inds s) \u0026 (i in set (inds tgr))))","legal sequence application obligation:(forall time:nat, action:ActionTrigger, eventHistory:seq of (Event) \u0026 let tgr:seq of (EventType) \u003d (action.Trigger) in let index:nat1 \u003d FindLowestIndexFromTime(time, eventHistory), s:seq of (Event) \u003d (eventHistory(index, ... ,((index + (len tgr)) - 1))) in ((forall i in set (inds s) \u0026 ((s(i).Type) \u003d tgr(i))) \u003d\u003e (1 in set (inds s))))","enumeration map injectivity obligation:(forall m1, m2 in set {{\u003cPotentialBuy\u003e |-\u003e mk_ActionTrigger([\u003cLeavesNoActionRegion\u003e, \u003cLowerLimit\u003e], \u003cBuy\u003e)}, {\u003cBought\u003e |-\u003e mk_ActionTrigger([\u003cLeavesNoActionRegion\u003e, \u003cUpperLimit\u003e], \u003cSell\u003e)}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","type compatibility obligation:inv_Region(mk_Region(12, 8))","type compatibility obligation:inv_StockRecord(mk_StockRecord(mk_token(\"test\"), {\u003cPotentialBuy\u003e |-\u003e mk_ActionTrigger([\u003cLeavesNoActionRegion\u003e, \u003cLowerLimit\u003e], \u003cBuy\u003e), \u003cBought\u003e |-\u003e mk_ActionTrigger([\u003cLeavesNoActionRegion\u003e, \u003cUpperLimit\u003e], \u003cSell\u003e)}, mk_Region(12, 8), 10, \u003cBought\u003e))","enumeration map injectivity obligation:(forall m1, m2 in set {{\u003cPotentialBuy\u003e |-\u003e mk_ActionTrigger([\u003cLeavesNoActionRegion\u003e, \u003cLowerLimit\u003e], \u003cBuy\u003e)}, {\u003cBought\u003e |-\u003e mk_ActionTrigger([\u003cLeavesNoActionRegion\u003e, \u003cUpperLimit\u003e], \u003cSell\u003e)}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","type compatibility obligation:inv_Region(mk_Region(12, 8))","type compatibility obligation:inv_StockRecord(mk_StockRecord(mk_token(\"test12\"), {\u003cPotentialBuy\u003e |-\u003e mk_ActionTrigger([\u003cLeavesNoActionRegion\u003e, \u003cLowerLimit\u003e], \u003cBuy\u003e), \u003cBought\u003e |-\u003e mk_ActionTrigger([\u003cLeavesNoActionRegion\u003e, \u003cUpperLimit\u003e], \u003cSell\u003e)}, mk_Region(12, 8), 10, \u003cBought\u003e))","enumeration map injectivity obligation:(forall m1, m2 in set {{\u003cPotentialBuy\u003e |-\u003e mk_ActionTrigger([\u003cLeavesNoActionRegion\u003e, \u003cLowerLimit\u003e], \u003cBuy\u003e)}, {\u003cBought\u003e |-\u003e mk_ActionTrigger([\u003cLeavesNoActionRegion\u003e, \u003cUpperLimit\u003e], \u003cSell\u003e)}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","type compatibility obligation:inv_Region(mk_Region(12, 8))","type compatibility obligation:inv_StockRecord(mk_StockRecord(mk_token(\"test2\"), {\u003cPotentialBuy\u003e |-\u003e mk_ActionTrigger([\u003cLeavesNoActionRegion\u003e, \u003cLowerLimit\u003e], \u003cBuy\u003e), \u003cBought\u003e |-\u003e mk_ActionTrigger([\u003cLeavesNoActionRegion\u003e, \u003cUpperLimit\u003e], \u003cSell\u003e)}, mk_Region(12, 8), 0, \u003cPotentialBuy\u003e))","while loop termination obligation:...","let be st existence obligation:(forall m:map (String) to (seq of (Event)) \u0026 (exists x, y in set {(len m(x)) | x in set (dom m)} \u0026 ((x \u003c\u003e y) \u003d\u003e (x \u003c\u003d y))))","legal map application obligation:(forall m:map (String) to (seq of (Event)) \u0026 (forall x in set (dom m) \u0026 (x in set (dom m))))","state invariant holds obligation:(forall startCash:nat \u0026 ((((startCash \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog)))","state invariant holds obligation:(forall sRecord:StockRecord, priority:nat1 \u0026 (((sRecord.Name) not in set {(x.Name) | x in set (elems stocks)}) \u003d\u003e (((((balance \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog)) \u003d\u003e ((((balance \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog)))))","state invariant holds obligation:(forall sRecord:StockRecord, priority:nat1 \u0026 (((sRecord.Name) not in set {(x.Name) | x in set (elems stocks)}) \u003d\u003e (((((balance \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog)) \u003d\u003e ((((balance \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog)))))","state invariant holds obligation:(forall sRecord:StockRecord, priority:nat1 \u0026 (((sRecord.Name) not in set {(x.Name) | x in set (elems stocks)}) \u003d\u003e (((((balance \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog)) \u003d\u003e ((((balance \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog)))))","legal map application obligation:(forall sRecord:StockRecord, priority:nat1 \u0026 (((sRecord.Name) not in set {(x.Name) | x in set (elems stocks)}) \u003d\u003e ((sRecord.Name) in set (dom testValues))))","legal sequence application obligation:(forall sRecord:StockRecord, priority:nat1 \u0026 (((sRecord.Name) not in set {(x.Name) | x in set (elems stocks)}) \u003d\u003e (((sRecord.Name) in set (dom stockWatchers)) \u003d\u003e (priority in set (inds (((stocks(1, ... ,(priority - 1))) ^ [sRecord]) ^ (stocks((priority + 1), ... ,(len stocks)))))))))","operation establishes postcondition obligation:(forall sRecord:StockRecord, priority:nat1 \u0026 (((sRecord.Name) not in set {(x.Name) | x in set (elems stocks)}) \u003d\u003e (((sRecord.Name) in set (dom stockWatchers)) and (sRecord \u003d stocks(priority)))))","legal sequence application obligation:(forall ss:StockState \u0026 (forall s in set (inds stocks) \u0026 ((((stockWatchers((stocks(s).Name)).GetTriggeredAction)() \u003c\u003e nil) and ((stocks(s).State) \u003d ss)) \u003d\u003e (s in set (inds stocks)))))","legal map application obligation:(forall ss:StockState \u0026 (forall s in set (inds stocks) \u0026 ((stocks(s).Name) in set (dom stockWatchers))))","legal sequence application obligation:(forall ss:StockState \u0026 (forall s in set (inds stocks) \u0026 (s in set (inds stocks))))","legal sequence application obligation:(forall ss:StockState \u0026 (forall s in set (inds stocks) \u0026 (((stockWatchers((stocks(s).Name)).GetTriggeredAction)() \u003c\u003e nil) \u003d\u003e (s in set (inds stocks)))))","legal sequence application obligation:(forall ss:StockState \u0026 let res:seq of (StockRecord) \u003d RESULT in (forall i in set (inds res) \u0026 (i in set (inds res))))","operation establishes postcondition obligation:(forall ss:StockState \u0026 let res:seq of (StockRecord) \u003d RESULT in (forall i in set (inds res) \u0026 ((res(i).State) \u003d ss)))","legal sequence application obligation:(forall potBuys:seq of (StockRecord), time:nat \u0026 (forall x in set (inds potBuys) \u0026 (CanAfford(potBuys(x), balance) \u003d\u003e (x in set (inds potBuys)))))","type compatibility obligation:(forall potBuys:seq of (StockRecord), time:nat \u0026 (forall x in set (inds potBuys) \u0026 (balance \u003e\u003d 0)))","legal sequence application obligation:(forall potBuys:seq of (StockRecord), time:nat \u0026 (forall x in set (inds potBuys) \u0026 (x in set (inds potBuys))))","let be st existence obligation:(forall potBuys:seq of (StockRecord), time:nat \u0026 let affordableStocks:seq of (StockRecord) \u003d [potBuys(x) | x in set (inds potBuys) \u0026 CanAfford(potBuys(x), balance)] in (((len affordableStocks) \u003e 0) \u003d\u003e (exists x in set (inds affordableStocks) \u0026 (forall y in set (inds affordableStocks) \u0026 ((stockWatchers((affordableStocks(x).Name)).GetStockValue)(time) \u003e\u003d (stockWatchers((affordableStocks(y).Name)).GetStockValue)(time))))))","legal map application obligation:(forall potBuys:seq of (StockRecord), time:nat \u0026 let affordableStocks:seq of (StockRecord) \u003d [potBuys(x) | x in set (inds potBuys) \u0026 CanAfford(potBuys(x), balance)] in (((len affordableStocks) \u003e 0) \u003d\u003e (forall x in set (inds affordableStocks) \u0026 (forall y in set (inds affordableStocks) \u0026 ((affordableStocks(x).Name) in set (dom stockWatchers))))))","legal sequence application obligation:(forall potBuys:seq of (StockRecord), time:nat \u0026 let affordableStocks:seq of (StockRecord) \u003d [potBuys(x) | x in set (inds potBuys) \u0026 CanAfford(potBuys(x), balance)] in (((len affordableStocks) \u003e 0) \u003d\u003e (forall x in set (inds affordableStocks) \u0026 (forall y in set (inds affordableStocks) \u0026 (x in set (inds affordableStocks))))))","legal map application obligation:(forall potBuys:seq of (StockRecord), time:nat \u0026 let affordableStocks:seq of (StockRecord) \u003d [potBuys(x) | x in set (inds potBuys) \u0026 CanAfford(potBuys(x), balance)] in (((len affordableStocks) \u003e 0) \u003d\u003e (forall x in set (inds affordableStocks) \u0026 (forall y in set (inds affordableStocks) \u0026 ((affordableStocks(y).Name) in set (dom stockWatchers))))))","legal sequence application obligation:(forall potBuys:seq of (StockRecord), time:nat \u0026 let affordableStocks:seq of (StockRecord) \u003d [potBuys(x) | x in set (inds potBuys) \u0026 CanAfford(potBuys(x), balance)] in (((len affordableStocks) \u003e 0) \u003d\u003e (forall x in set (inds affordableStocks) \u0026 (forall y in set (inds affordableStocks) \u0026 (y in set (inds affordableStocks))))))","legal sequence application obligation:(forall potBuys:seq of (StockRecord), time:nat \u0026 let affordableStocks:seq of (StockRecord) \u003d [potBuys(x) | x in set (inds potBuys) \u0026 CanAfford(potBuys(x), balance)] in (((len affordableStocks) \u003e 0) \u003d\u003e (forall x in set (inds affordableStocks) \u0026 ((forall y in set (inds affordableStocks) \u0026 ((stockWatchers((affordableStocks(x).Name)).GetStockValue)(time) \u003e\u003d (stockWatchers((affordableStocks(y).Name)).GetStockValue)(time))) \u003d\u003e (x in set (inds affordableStocks))))))","let be st existence obligation:(forall potSells:seq of (StockRecord), time:nat \u0026 (((len potSells) \u003e 0) \u003d\u003e (exists x in set (inds potSells) \u0026 (forall y in set (inds potSells) \u0026 (((stockWatchers((potSells(x).Name)).GetStockValue)(time) - (potSells(x).Cost)) \u003e\u003d ((stockWatchers((potSells(y).Name)).GetStockValue)(time) - (potSells(y).Cost)))))))","legal map application obligation:(forall potSells:seq of (StockRecord), time:nat \u0026 (((len potSells) \u003e 0) \u003d\u003e (forall x in set (inds potSells) \u0026 (forall y in set (inds potSells) \u0026 ((potSells(x).Name) in set (dom stockWatchers))))))","legal sequence application obligation:(forall potSells:seq of (StockRecord), time:nat \u0026 (((len potSells) \u003e 0) \u003d\u003e (forall x in set (inds potSells) \u0026 (forall y in set (inds potSells) \u0026 (x in set (inds potSells))))))","legal sequence application obligation:(forall potSells:seq of (StockRecord), time:nat \u0026 (((len potSells) \u003e 0) \u003d\u003e (forall x in set (inds potSells) \u0026 (forall y in set (inds potSells) \u0026 (x in set (inds potSells))))))","legal map application obligation:(forall potSells:seq of (StockRecord), time:nat \u0026 (((len potSells) \u003e 0) \u003d\u003e (forall x in set (inds potSells) \u0026 (forall y in set (inds potSells) \u0026 ((potSells(y).Name) in set (dom stockWatchers))))))","legal sequence application obligation:(forall potSells:seq of (StockRecord), time:nat \u0026 (((len potSells) \u003e 0) \u003d\u003e (forall x in set (inds potSells) \u0026 (forall y in set (inds potSells) \u0026 (y in set (inds potSells))))))","legal sequence application obligation:(forall potSells:seq of (StockRecord), time:nat \u0026 (((len potSells) \u003e 0) \u003d\u003e (forall x in set (inds potSells) \u0026 (forall y in set (inds potSells) \u0026 (y in set (inds potSells))))))","legal sequence application obligation:(forall potSells:seq of (StockRecord), time:nat \u0026 (((len potSells) \u003e 0) \u003d\u003e (forall x in set (inds potSells) \u0026 ((forall y in set (inds potSells) \u0026 (((stockWatchers((potSells(x).Name)).GetStockValue)(time) - (potSells(x).Cost)) \u003e\u003d ((stockWatchers((potSells(y).Name)).GetStockValue)(time) - (potSells(y).Cost)))) \u003d\u003e (x in set (inds potSells))))))","legal map application obligation:(forall potSells:seq of (StockRecord), time:nat \u0026 (((len potSells) \u003e 0) \u003d\u003e ((RESULT.Name) in set (dom stockWatchers))))","legal map application obligation:(forall potSells:seq of (StockRecord), time:nat \u0026 (((len potSells) \u003e 0) \u003d\u003e (forall x in set (elems potSells) \u0026 ((x.Name) in set (dom stockWatchers)))))","operation establishes postcondition obligation:(forall potSells:seq of (StockRecord), time:nat \u0026 (((len potSells) \u003e 0) \u003d\u003e IsGTAll(((stockWatchers((RESULT.Name)).GetStockValue)(time) - (RESULT.Cost)), {((stockWatchers((x.Name)).GetStockValue)(time) - (x.Cost)) | x in set (elems potSells)})))","legal map application obligation:(forall potAction:StockRecord, time:nat \u0026 ((((potAction.State) \u003d \u003cPotentialBuy\u003e) and ((stockWatchers((potAction.Name)).GetTriggeredAction)() \u003d \u003cBuy\u003e)) \u003d\u003e (((potAction.State) \u003d \u003cPotentialBuy\u003e) \u003d\u003e ((potAction.Name) in set (dom stockWatchers)))))","legal map application obligation:(forall potAction:StockRecord, time:nat \u0026 ((((potAction.State) \u003d \u003cPotentialBuy\u003e) and ((stockWatchers((potAction.Name)).GetTriggeredAction)() \u003d \u003cBuy\u003e)) \u003d\u003e ((potAction.Name) in set (dom stockWatchers))))","state invariant holds obligation:(forall potAction:StockRecord, time:nat \u0026 ((((potAction.State) \u003d \u003cPotentialBuy\u003e) and ((stockWatchers((potAction.Name)).GetTriggeredAction)() \u003d \u003cBuy\u003e)) \u003d\u003e (((((balance \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog)) \u003d\u003e ((((balance \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog)))))","state invariant holds obligation:(forall potAction:StockRecord, time:nat \u0026 ((((potAction.State) \u003d \u003cPotentialBuy\u003e) and ((stockWatchers((potAction.Name)).GetTriggeredAction)() \u003d \u003cBuy\u003e)) \u003d\u003e (((((balance \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog)) \u003d\u003e (((((balance - value) \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog)))))","let be st existence obligation:(forall potAction:StockRecord, time:nat \u0026 ((((potAction.State) \u003d \u003cPotentialBuy\u003e) and ((stockWatchers((potAction.Name)).GetTriggeredAction)() \u003d \u003cBuy\u003e)) \u003d\u003e (exists i in set (inds stocks) \u0026 ((stocks(i).Name) \u003d (potAction.Name)))))","legal sequence application obligation:(forall potAction:StockRecord, time:nat \u0026 ((((potAction.State) \u003d \u003cPotentialBuy\u003e) and ((stockWatchers((potAction.Name)).GetTriggeredAction)() \u003d \u003cBuy\u003e)) \u003d\u003e (i in set (inds stocks))))","state invariant holds obligation:(forall potAction:StockRecord, time:nat \u0026 ((((potAction.State) \u003d \u003cPotentialBuy\u003e) and ((stockWatchers((potAction.Name)).GetTriggeredAction)() \u003d \u003cBuy\u003e)) \u003d\u003e ((((((balance - value) \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog)) \u003d\u003e (((((balance - value) \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog)))))","legal sequence application obligation:(forall potAction:StockRecord, time:nat \u0026 ((((potAction.State) \u003d \u003cPotentialBuy\u003e) and ((stockWatchers((potAction.Name)).GetTriggeredAction)() \u003d \u003cBuy\u003e)) \u003d\u003e ((i \u003e 0) and (i \u003c\u003d ((len stocks) + 1)))))","legal sequence application obligation:(forall potAction:StockRecord, time:nat \u0026 ((((potAction.State) \u003d \u003cPotentialBuy\u003e) and ((stockWatchers((potAction.Name)).GetTriggeredAction)() \u003d \u003cBuy\u003e)) \u003d\u003e (i in set (inds stocks))))","operation establishes postcondition obligation:(forall potAction:StockRecord, time:nat \u0026 ((((potAction.State) \u003d \u003cPotentialBuy\u003e) and ((stockWatchers((potAction.Name)).GetTriggeredAction)() \u003d \u003cBuy\u003e)) \u003d\u003e ((balance - value) \u003e\u003d 0)))","legal map application obligation:(forall potAction:StockRecord, time:nat \u0026 ((((potAction.State) \u003d \u003cBought\u003e) and ((stockWatchers((potAction.Name)).GetTriggeredAction)() \u003d \u003cSell\u003e)) \u003d\u003e (((potAction.State) \u003d \u003cBought\u003e) \u003d\u003e ((potAction.Name) in set (dom stockWatchers)))))","legal map application obligation:(forall potAction:StockRecord, time:nat \u0026 ((((potAction.State) \u003d \u003cBought\u003e) and ((stockWatchers((potAction.Name)).GetTriggeredAction)() \u003d \u003cSell\u003e)) \u003d\u003e ((potAction.Name) in set (dom stockWatchers))))","state invariant holds obligation:(forall potAction:StockRecord, time:nat \u0026 ((((potAction.State) \u003d \u003cBought\u003e) and ((stockWatchers((potAction.Name)).GetTriggeredAction)() \u003d \u003cSell\u003e)) \u003d\u003e (((((balance \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog)) \u003d\u003e ((((balance \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog)))))","state invariant holds obligation:(forall potAction:StockRecord, time:nat \u0026 ((((potAction.State) \u003d \u003cBought\u003e) and ((stockWatchers((potAction.Name)).GetTriggeredAction)() \u003d \u003cSell\u003e)) \u003d\u003e (((((balance \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog)) \u003d\u003e (((((balance + value) \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog)))))","let be st existence obligation:(forall potAction:StockRecord, time:nat \u0026 ((((potAction.State) \u003d \u003cBought\u003e) and ((stockWatchers((potAction.Name)).GetTriggeredAction)() \u003d \u003cSell\u003e)) \u003d\u003e (exists i in set (inds stocks) \u0026 ((stocks(i).Name) \u003d (potAction.Name)))))","legal sequence application obligation:(forall potAction:StockRecord, time:nat \u0026 ((((potAction.State) \u003d \u003cBought\u003e) and ((stockWatchers((potAction.Name)).GetTriggeredAction)() \u003d \u003cSell\u003e)) \u003d\u003e (i in set (inds stocks))))","state invariant holds obligation:(forall potAction:StockRecord, time:nat \u0026 ((((potAction.State) \u003d \u003cBought\u003e) and ((stockWatchers((potAction.Name)).GetTriggeredAction)() \u003d \u003cSell\u003e)) \u003d\u003e ((((((balance + value) \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog)) \u003d\u003e (((((balance + value) \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog)))))","legal sequence application obligation:(forall potAction:StockRecord, time:nat \u0026 ((((potAction.State) \u003d \u003cBought\u003e) and ((stockWatchers((potAction.Name)).GetTriggeredAction)() \u003d \u003cSell\u003e)) \u003d\u003e ((i \u003e 0) and (i \u003c\u003d ((len stocks) + 1)))))","legal sequence application obligation:(forall potAction:StockRecord, time:nat \u0026 ((((potAction.State) \u003d \u003cBought\u003e) and ((stockWatchers((potAction.Name)).GetTriggeredAction)() \u003d \u003cSell\u003e)) \u003d\u003e (i in set (inds stocks))))","operation establishes postcondition obligation:(forall potAction:StockRecord, time:nat \u0026 ((((potAction.State) \u003d \u003cBought\u003e) and ((stockWatchers((potAction.Name)).GetTriggeredAction)() \u003d \u003cSell\u003e)) \u003d\u003e ((balance + value) \u003e\u003d 0)))","legal sequence application obligation:(forall time:nat \u0026 (i in set (inds stocks)))","legal map application obligation:(forall time:nat \u0026 ((stock.Name) in set (dom stockWatchers)))","operation call obligation:(forall time:nat \u0026 (forall stocks1:seq of (StockRecord), stockWatchers2:map (StockIdentifier) to (StockWatcher), actionLog3:seq of (ActionEvent), balance4:int \u0026 (((((balance4 \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog)) \u003d\u003e (((FindValidSell(potSells, time).State) \u003d \u003cBought\u003e) and ((stockWatchers((potAction.Name)).GetTriggeredAction)() \u003d \u003cSell\u003e)))))","operation call obligation:(forall time:nat \u0026 (forall stocks1:seq of (StockRecord), stockWatchers2:map (StockIdentifier) to (StockWatcher), actionLog3:seq of (ActionEvent), balance4:int \u0026 (((((balance4 \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog)) \u003d\u003e (forall stocks21:seq of (StockRecord), stockWatchers22:map (StockIdentifier) to (StockWatcher), actionLog23:seq of (ActionEvent), balance24:int \u0026 (((balance24 \u003e\u003d 0) and ((((balance24 \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog))) \u003d\u003e (true \u003d\u003e (true \u003d\u003e (((validBuy.State) \u003d \u003cPotentialBuy\u003e) and ((stockWatchers((potAction.Name)).GetTriggeredAction)() \u003d \u003cBuy\u003e)))))))))","operation establishes postcondition obligation:(forall time:nat \u0026 (forall stocks1:seq of (StockRecord), stockWatchers2:map (StockIdentifier) to (StockWatcher), actionLog3:seq of (ActionEvent), balance4:int \u0026 (((((balance4 \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog)) \u003d\u003e (forall stocks21:seq of (StockRecord), stockWatchers22:map (StockIdentifier) to (StockWatcher), actionLog23:seq of (ActionEvent), balance24:int \u0026 (((balance24 \u003e\u003d 0) and ((((balance24 \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog))) \u003d\u003e (true \u003d\u003e (true \u003d\u003e (forall stocks25:seq of (StockRecord), stockWatchers26:map (StockIdentifier) to (StockWatcher), actionLog27:seq of (ActionEvent), balance28:int \u0026 (((balance28 \u003e\u003d 0) and ((((balance28 \u003e\u003d 0) and (forall x, y in set (inds stocks) \u0026 ((x \u003c\u003e y) \u003d\u003e ((stocks(x).Name) \u003c\u003e (stocks(y).Name))))) and let stockIdentifiers:set of (StockIdentifier) \u003d {(si.Name) | si in set (elems stocks)} in (forall stockIdentifier in set stockIdentifiers \u0026 let allEventsStock:seq of (ActionEvent) \u003d [actionLog(i) | i in set (inds actionLog) \u0026 ((actionLog(i).StockName) \u003d stockIdentifier)] in (forall e in set (inds allEventsStock) \u0026 ((e \u003c\u003e (len allEventsStock)) \u003d\u003e ((allEventsStock(e).Type) \u003c\u003e (allEventsStock((e + 1)).Type)))))) and MaxOneOfEachActionTypePerTime(actionLog))) \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e MaxOneOfEachActionTypePerTime(actionLog))))))))))))))))))))","legal sequence application obligation:(forall actionLog:seq of (ActionEvent) \u0026 (forall x, y in set (inds actionLog) \u0026 ((x \u003c\u003e y) \u003d\u003e (x in set (inds actionLog)))))","legal sequence application obligation:(forall actionLog:seq of (ActionEvent) \u0026 (forall x, y in set (inds actionLog) \u0026 ((x \u003c\u003e y) \u003d\u003e (y in set (inds actionLog)))))","legal sequence application obligation:(forall actionLog:seq of (ActionEvent) \u0026 (forall x, y in set (inds actionLog) \u0026 (((x \u003c\u003e y) and ((actionLog(x).Time) \u003d (actionLog(y).Time))) \u003d\u003e (x in set (inds actionLog)))))","legal sequence application obligation:(forall actionLog:seq of (ActionEvent) \u0026 (forall x, y in set (inds actionLog) \u0026 (((x \u003c\u003e y) and ((actionLog(x).Time) \u003d (actionLog(y).Time))) \u003d\u003e (y in set (inds actionLog)))))","type invariant satisfiable obligation:(exists mk_Region(p1, p2):Region \u0026 (p1 \u003e\u003d p2))","legal map application obligation:(forall mk_StockRecord(p1, p2, p3, p4, p5):StockRecord \u0026 (\u003cPotentialBuy\u003e in set (dom p2)))","legal map application obligation:(forall mk_StockRecord(p1, p2, p3, p4, p5):StockRecord \u0026 (((p2(\u003cPotentialBuy\u003e).Action) \u003d \u003cBuy\u003e) \u003d\u003e (\u003cBought\u003e in set (dom p2))))","type invariant satisfiable obligation:(exists mk_StockRecord(p1, p2, p3, p4, p5):StockRecord \u0026 (((p2(\u003cPotentialBuy\u003e).Action) \u003d \u003cBuy\u003e) and ((p2(\u003cBought\u003e).Action) \u003d \u003cSell\u003e)))","enumeration map injectivity obligation:(forall m1, m2 in set {{mk_token(\"test\") |-\u003e [mk_Event(\u003cLeavesNoActionRegion\u003e, 6, 5), mk_Event(\u003cLowerLimit\u003e, 5, 8), mk_Event(\u003cUpperLimit\u003e, 4, 12), mk_Event(\u003cEntersNoActionRegion\u003e, 3, 11), mk_Event(\u003cLeavesNoActionRegion\u003e, 2, 13), mk_Event(\u003cUpperLimit\u003e, 1, 12), mk_Event(\u003cEntersNoActionRegion\u003e, 0, 10)]}, {mk_token(\"test12\") |-\u003e [mk_Event(\u003cLeavesNoActionRegion\u003e, 6, 5), mk_Event(\u003cLowerLimit\u003e, 5, 8), mk_Event(\u003cUpperLimit\u003e, 4, 12), mk_Event(\u003cEntersNoActionRegion\u003e, 3, 11), mk_Event(\u003cLeavesNoActionRegion\u003e, 2, 16), mk_Event(\u003cUpperLimit\u003e, 1, 12), mk_Event(\u003cEntersNoActionRegion\u003e, 0, 10)]}, {mk_token(\"test2\") |-\u003e [mk_Event(\u003cLeavesNoActionRegion\u003e, 6, 5), mk_Event(\u003cUpperLimit\u003e, 5, 8), mk_Event(\u003cLowerLimit\u003e, 4, 8), mk_Event(\u003cEntersNoActionRegion\u003e, 3, 11), mk_Event(\u003cLeavesNoActionRegion\u003e, 2, 6), mk_Event(\u003cLowerLimit\u003e, 1, 8), mk_Event(\u003cEntersNoActionRegion\u003e, 0, 10)]}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","non-empty sequence obligation:(((len valueHistory) \u003e\u003d 1) \u003d\u003e ((nil \u003d currentRateOfChange) \u003d\u003e (valueHistory \u003c\u003e [])))","type compatibility obligation:(((len valueHistory) \u003e\u003d 1) \u003d\u003e ((not (nil \u003d currentRateOfChange)) \u003d\u003e ((is_(currentRateOfChange, \u003cconstant\u003e) or is_(currentRateOfChange, \u003cnegative\u003e)) or is_(currentRateOfChange, \u003cpositive\u003e))))","non-empty sequence obligation:(((len valueHistory) \u003e\u003d 1) \u003d\u003e ((not (nil \u003d currentRateOfChange)) \u003d\u003e (valueHistory \u003c\u003e [])))","non-empty sequence obligation:(((len valueHistory) \u003e\u003d 1) \u003d\u003e (valueHistory \u003c\u003e []))","non-empty sequence obligation:(((len valueHistory) \u003e\u003d 1) \u003d\u003e (([((hd valueHistory) + 1)] ^ valueHistory) \u003c\u003e []))","type compatibility obligation:(((len valueHistory) \u003e\u003d 1) \u003d\u003e is_(([((hd valueHistory) - 1)] ^ valueHistory), seq of (StockValue)))","non-empty sequence obligation:(((len valueHistory) \u003e\u003d 1) \u003d\u003e (([((hd valueHistory) - 1)] ^ ([((hd valueHistory) + 1)] ^ valueHistory)) \u003c\u003e []))","legal sequence application obligation:(((len valueHistory) \u003e\u003d 1) \u003d\u003e (((cases currentRateOfChange :\nnil -\u003e InitialRateOfChange((hd valueHistory))\nothers NextRateOfChange(currentRateOfChange, (hd valueHistory))\n end) \u003d \u003cpositive\u003e) \u003d\u003e (1 in set (inds ([(hd valueHistory)] ^ ([((hd valueHistory) - 1)] ^ ([((hd valueHistory) + 1)] ^ valueHistory)))))))","legal sequence application obligation:(((len valueHistory) \u003e\u003d 1) \u003d\u003e (((cases currentRateOfChange :\nnil -\u003e InitialRateOfChange((hd valueHistory))\nothers NextRateOfChange(currentRateOfChange, (hd valueHistory))\n end) \u003d \u003cpositive\u003e) \u003d\u003e (2 in set (inds ([(hd valueHistory)] ^ ([((hd valueHistory) - 1)] ^ ([((hd valueHistory) + 1)] ^ valueHistory)))))))","legal sequence application obligation:(((len valueHistory) \u003e\u003d 1) \u003d\u003e ((((cases currentRateOfChange :\nnil -\u003e InitialRateOfChange((hd valueHistory))\nothers NextRateOfChange(currentRateOfChange, (hd valueHistory))\n end) \u003d \u003cpositive\u003e) \u003d\u003e (valueHistory(1) \u003e valueHistory(2))) \u003d\u003e (((cases currentRateOfChange :\nnil -\u003e InitialRateOfChange((hd valueHistory))\nothers NextRateOfChange(currentRateOfChange, (hd valueHistory))\n end) \u003d \u003cnegative\u003e) \u003d\u003e (1 in set (inds ([(hd valueHistory)] ^ ([((hd valueHistory) - 1)] ^ ([((hd valueHistory) + 1)] ^ valueHistory))))))))","legal sequence application obligation:(((len valueHistory) \u003e\u003d 1) \u003d\u003e ((((cases currentRateOfChange :\nnil -\u003e InitialRateOfChange((hd valueHistory))\nothers NextRateOfChange(currentRateOfChange, (hd valueHistory))\n end) \u003d \u003cpositive\u003e) \u003d\u003e (valueHistory(1) \u003e valueHistory(2))) \u003d\u003e (((cases currentRateOfChange :\nnil -\u003e InitialRateOfChange((hd valueHistory))\nothers NextRateOfChange(currentRateOfChange, (hd valueHistory))\n end) \u003d \u003cnegative\u003e) \u003d\u003e (2 in set (inds ([(hd valueHistory)] ^ ([((hd valueHistory) - 1)] ^ ([((hd valueHistory) + 1)] ^ valueHistory))))))))","legal sequence application obligation:(((len valueHistory) \u003e\u003d 1) \u003d\u003e ((((cases currentRateOfChange :\nnil -\u003e InitialRateOfChange((hd valueHistory))\nothers NextRateOfChange(currentRateOfChange, (hd valueHistory))\n end) \u003d \u003cpositive\u003e) \u003d\u003e (valueHistory(1) \u003e valueHistory(2))) \u003d\u003e ((((cases currentRateOfChange :\nnil -\u003e InitialRateOfChange((hd valueHistory))\nothers NextRateOfChange(currentRateOfChange, (hd valueHistory))\n end) \u003d \u003cnegative\u003e) \u003d\u003e (valueHistory(1) \u003c valueHistory(2))) \u003d\u003e (((cases currentRateOfChange :\nnil -\u003e InitialRateOfChange((hd valueHistory))\nothers NextRateOfChange(currentRateOfChange, (hd valueHistory))\n end) \u003d \u003cconstant\u003e) \u003d\u003e (1 in set (inds ([(hd valueHistory)] ^ ([((hd valueHistory) - 1)] ^ ([((hd valueHistory) + 1)] ^ valueHistory)))))))))","legal sequence application obligation:(((len valueHistory) \u003e\u003d 1) \u003d\u003e ((((cases currentRateOfChange :\nnil -\u003e InitialRateOfChange((hd valueHistory))\nothers NextRateOfChange(currentRateOfChange, (hd valueHistory))\n end) \u003d \u003cpositive\u003e) \u003d\u003e (valueHistory(1) \u003e valueHistory(2))) \u003d\u003e ((((cases currentRateOfChange :\nnil -\u003e InitialRateOfChange((hd valueHistory))\nothers NextRateOfChange(currentRateOfChange, (hd valueHistory))\n end) \u003d \u003cnegative\u003e) \u003d\u003e (valueHistory(1) \u003c valueHistory(2))) \u003d\u003e (((cases currentRateOfChange :\nnil -\u003e InitialRateOfChange((hd valueHistory))\nothers NextRateOfChange(currentRateOfChange, (hd valueHistory))\n end) \u003d \u003cconstant\u003e) \u003d\u003e (2 in set (inds ([(hd valueHistory)] ^ ([((hd valueHistory) - 1)] ^ ([((hd valueHistory) + 1)] ^ valueHistory)))))))))","non-empty sequence obligation:(((len valueHistory) \u003e\u003d 1) \u003d\u003e ((((cases currentRateOfChange :\nnil -\u003e InitialRateOfChange((hd valueHistory))\nothers NextRateOfChange(currentRateOfChange, (hd valueHistory))\n end) \u003d \u003cpositive\u003e) \u003d\u003e (valueHistory(1) \u003e valueHistory(2))) \u003d\u003e ((((cases currentRateOfChange :\nnil -\u003e InitialRateOfChange((hd valueHistory))\nothers NextRateOfChange(currentRateOfChange, (hd valueHistory))\n end) \u003d \u003cnegative\u003e) \u003d\u003e (valueHistory(1) \u003c valueHistory(2))) \u003d\u003e ((((cases currentRateOfChange :\nnil -\u003e InitialRateOfChange((hd valueHistory))\nothers NextRateOfChange(currentRateOfChange, (hd valueHistory))\n end) \u003d \u003cconstant\u003e) \u003d\u003e (valueHistory(1) \u003d valueHistory(2))) \u003d\u003e (([(hd valueHistory)] ^ ([((hd valueHistory) - 1)] ^ ([((hd valueHistory) + 1)] ^ valueHistory))) \u003c\u003e [])))))","operation establishes postcondition obligation:(((len valueHistory) \u003e\u003d 1) \u003d\u003e ((((cases currentRateOfChange :\nnil -\u003e InitialRateOfChange((hd valueHistory))\nothers NextRateOfChange(currentRateOfChange, (hd valueHistory))\n end) \u003d \u003cpositive\u003e) \u003d\u003e (valueHistory(1) \u003e valueHistory(2))) and ((((cases currentRateOfChange :\nnil -\u003e InitialRateOfChange((hd valueHistory))\nothers NextRateOfChange(currentRateOfChange, (hd valueHistory))\n end) \u003d \u003cnegative\u003e) \u003d\u003e (valueHistory(1) \u003c valueHistory(2))) and ((((cases currentRateOfChange :\nnil -\u003e InitialRateOfChange((hd valueHistory))\nothers NextRateOfChange(currentRateOfChange, (hd valueHistory))\n end) \u003d \u003cconstant\u003e) \u003d\u003e (valueHistory(1) \u003d valueHistory(2))) and ((hd ([(hd valueHistory)] ^ ([((hd valueHistory) - 1)] ^ ([((hd valueHistory) + 1)] ^ valueHistory)))) \u003e\u003d 0)))))","non-empty sequence obligation:(valueHistory \u003c\u003e [])","cases exhaustive obligation:(forall sv:StockValue \u0026 let r:int \u003d (MATH`rand(21) mod 3) in ((sv \u003e 0) \u003d\u003e (((r \u003d 0) or (r \u003d 1)) or (r \u003d 2))))","cases exhaustive obligation:(forall sv:StockValue \u0026 let r:int \u003d (MATH`rand(21) mod 3) in ((not (sv \u003e 0)) \u003d\u003e (((r \u003d 0) or (r \u003d 1)) or (r \u003d 2))))","finite set obligation:(forall roc:RateOfChange, sv:StockValue \u0026 (exists finmap1:map (nat) to (RateOfChange) \u0026 (forall x:RateOfChange \u0026 (((x \u003c\u003e roc) and ((x \u003d \u003cnegative\u003e) \u003d\u003e (sv \u003e 0))) \u003d\u003e (exists findex2 in set (dom finmap1) \u0026 (finmap1(findex2) \u003d x))))))","legal sequence application obligation:(forall roc:RateOfChange, sv:StockValue \u0026 let r:int \u003d MATH`rand(10), other:seq of (RateOfChange) \u003d MakelistFromSet({x | x:RateOfChange \u0026 ((x \u003c\u003e roc) and ((x \u003d \u003cnegative\u003e) \u003d\u003e (sv \u003e 0)))}) in ((not ((r \u003e\u003d 0) and ((r \u003c\u003d 7) and ((roc \u003d \u003cnegative\u003e) \u003d\u003e (sv \u003e 0))))) \u003d\u003e (((MATH`rand(20) mod (len other)) + 1) in set (inds other))))","let be st existence obligation:(forall roc:set of (RateOfChange) \u0026 (((card roc) \u003e 0) \u003d\u003e (exists r in set roc \u0026 true)))","map compatible obligation:(forall stock:Stock \u0026 (((stock.GetName)() not in set (dom stocks)) \u003d\u003e (forall ldom1 in set (dom {(stock.GetName)() |-\u003e stock}), rdom2 in set (dom stocks) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e ({(stock.GetName)() |-\u003e stock}(ldom1) \u003d stocks(rdom2))))))","operation establishes postcondition obligation:(forall stock:Stock \u0026 (((stock.GetName)() not in set (dom stocks)) \u003d\u003e ((stock.GetName)() in set (dom ({(stock.GetName)() |-\u003e stock} munion stocks)))))","operation establishes postcondition obligation:(forall stock:Stock \u0026 (((stock.GetName)() in set (dom stocks)) \u003d\u003e ((stock.GetName)() not in set (dom ({(stock.GetName)()} \u003c-: stocks)))))","legal map application obligation:(forall name:StockIdentifier \u0026 ((name in set (dom stocks)) \u003d\u003e (name in set (dom stocks))))","operation call obligation:(forall text:seq of (char) \u0026 ((\"\" \u003d \"\") \u003c\u003d\u003e (\"\" \u003d nil)))","non-zero obligation:(forall a:real \u0026 ((a \u003c\u003e 0) \u003d\u003e (a \u003c\u003e 0)))"] \ No newline at end of file diff --git a/core/pog/src/test/resources/examples/BuslinesPP.result b/core/pog/src/test/resources/examples/BuslinesPP.result index 6cdd2bcc18..d880bf8f6c 100644 --- a/core/pog/src/test/resources/examples/BuslinesPP.result +++ b/core/pog/src/test/resources/examples/BuslinesPP.result @@ -1 +1 @@ -["state invariant holds obligation:(forall destination:Busstop \u0026 (((destination.IsStop)() \u003d true) \u003d\u003e ((goal.IsStop)() \u003d true)))","state invariant holds obligation:(((goal.IsStop)() \u003d true) \u003d\u003e ((goal.IsStop)() \u003d true))","state invariant holds obligation:(((goal.IsStop)() \u003d true) \u003d\u003e ((goal.IsStop)() \u003d true))","state invariant holds obligation:(((goal.IsStop)() \u003d true) \u003d\u003e ((goal.IsStop)() \u003d true))","state invariant holds obligation:(forall roadnumber:RoadNumber, waypoints:set of (Waypoint), length:nat \u0026 (((card waypoints) \u003e 1) \u003d\u003e ((card waypoints) \u003e 1)))","non-zero obligation:(forall roadnumber:RoadNumber, waypoints:set of (Waypoint), length:nat, limit:nat \u0026 (((card waypoints) \u003e 1) \u003d\u003e (limit \u003c\u003e 0)))","type compatibility obligation:(forall roadnumber:RoadNumber, waypoints:set of (Waypoint), length:nat, limit:nat \u0026 (((card waypoints) \u003e 1) \u003d\u003e ((floor (length / limit)) \u003e\u003d 0)))","state invariant holds obligation:(forall roadnumber:RoadNumber, waypoints:set of (Waypoint), length:nat, limit:nat \u0026 (((card waypoints) \u003e 1) \u003d\u003e ((card waypoints) \u003e 1)))","let be st existence obligation:(forall wp:Waypoint \u0026 ((wp in set wps) \u003d\u003e (exists opposite in set (wps \\ {wp}) \u0026 true)))","non-empty sequence obligation:(forall linenumber:nat, busroute:seq of (Road), waypoints:seq of (Waypoint) \u0026 (((len waypoints) \u003e 1) \u003d\u003e (waypoints \u003c\u003e [])))","state invariant holds obligation:(forall linenumber:nat, busroute:seq of (Road), waypoints:seq of (Waypoint) \u0026 (((len waypoints) \u003e 1) \u003d\u003e ((card {}) \u003c\u003d Config`BusCapacity)))","state invariant holds obligation:(forall ps:set of (Passenger) \u0026 ((((card seats) + (card ps)) \u003c\u003d Config`BusCapacity) \u003d\u003e (((card seats) \u003c\u003d Config`BusCapacity) \u003d\u003e ((card (seats union ps)) \u003c\u003d Config`BusCapacity))))","state invariant holds obligation:(forall p:set of (Passenger) \u0026 (((p inter seats) \u003c\u003e {}) \u003d\u003e (((card seats) \u003c\u003d Config`BusCapacity) \u003d\u003e ((card (seats \\ p)) \u003c\u003d Config`BusCapacity))))","legal sequence application obligation:(forall i in set (inds wps) \u0026 ((wps(i).IsStop)() \u003d\u003e (i in set (inds wps))))","legal sequence application obligation:(forall i in set (inds wps) \u0026 (i in set (inds wps)))","type compatibility obligation:is_(RESULT, seq of (Busstop))","state invariant holds obligation:(((card seats) \u003c\u003d Config`BusCapacity) \u003d\u003e ((card seats) \u003c\u003d Config`BusCapacity))","non-empty sequence obligation:(route \u003c\u003e [])","state invariant holds obligation:(((card seats) \u003c\u003d Config`BusCapacity) \u003d\u003e ((card seats) \u003c\u003d Config`BusCapacity))","non-empty sequence obligation:(route \u003c\u003e [])","state invariant holds obligation:(((card seats) \u003c\u003d Config`BusCapacity) \u003d\u003e ((card seats) \u003c\u003d Config`BusCapacity))","state invariant holds obligation:(((card seats) \u003c\u003d Config`BusCapacity) \u003d\u003e ((card seats) \u003c\u003d Config`BusCapacity))","let be st existence obligation:(forall ps:set of (Passenger), limit:nat \u0026 (exists sub in set ps \u0026 true))","cases exhaustive obligation:(forall d:Direction \u0026 ((((d \u003d \u003cNORTH\u003e) or (d \u003d \u003cSOUTH\u003e)) or (d \u003d \u003cEAST\u003e)) or (d \u003d \u003cWEST\u003e)))","legal map application obligation:(forall th in set (dom wakeUpMap) \u0026 (th in set (dom wakeUpMap)))","legal map application obligation:(forall th in set (dom wakeUpMap) \u0026 (th in set (dom wakeUpMap)))","let be st existence obligation:(exists p in set waitset \u0026 true)","map compatible obligation:(forall stp:BusStops \u0026 ((stp not in set (dom stops)) \u003d\u003e (forall ldom1 in set (dom stops), rdom2 in set (dom {stp |-\u003e bs}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (stops(ldom1) \u003d {stp |-\u003e bs}(rdom2))))))","type compatibility obligation:(forall stp:BusStops \u0026 ((stp not in set (dom stops)) \u003d\u003e is_((stops munion {stp |-\u003e bs}), inmap (BusStops) to (Busstop))))","map compatible obligation:(forall wp1:Waypoint, wp2:Waypoint, roadNmbr:RoadNumber, length:nat \u0026 (((roadNmbr not in set (dom roads)) and ((wp1 \u003c\u003e wp2) and (forall r in set (rng roads) \u0026 (not (r.Covers)({wp1, wp2}))))) \u003d\u003e (forall ldom1 in set (dom roads), rdom2 in set (dom {roadNmbr |-\u003e r}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (roads(ldom1) \u003d {roadNmbr |-\u003e r}(rdom2))))))","type compatibility obligation:(forall wp1:Waypoint, wp2:Waypoint, roadNmbr:RoadNumber, length:nat \u0026 (((roadNmbr not in set (dom roads)) and ((wp1 \u003c\u003e wp2) and (forall r in set (rng roads) \u0026 (not (r.Covers)({wp1, wp2}))))) \u003d\u003e is_((roads munion {roadNmbr |-\u003e r}), inmap (RoadNumber) to (Road))))","map compatible obligation:(forall wp1:Waypoint, wp2:Waypoint, roadNmbr:RoadNumber, length:nat, speedlimit:nat \u0026 (((roadNmbr not in set (dom roads)) and (forall r in set (rng roads) \u0026 ((not (r.Covers)({wp1, wp2})) and (wp1 \u003c\u003e wp2)))) \u003d\u003e (forall ldom1 in set (dom roads), rdom2 in set (dom {roadNmbr |-\u003e r}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (roads(ldom1) \u003d {roadNmbr |-\u003e r}(rdom2))))))","type compatibility obligation:(forall wp1:Waypoint, wp2:Waypoint, roadNmbr:RoadNumber, length:nat, speedlimit:nat \u0026 (((roadNmbr not in set (dom roads)) and (forall r in set (rng roads) \u0026 ((not (r.Covers)({wp1, wp2})) and (wp1 \u003c\u003e wp2)))) \u003d\u003e is_((roads munion {roadNmbr |-\u003e r}), inmap (RoadNumber) to (Road))))","legal sequence application obligation:(forall lineNumber:nat, route:seq of (RoadNumber) \u0026 ((((len route) \u003e 1) and (lineNumber not in set (dom buses))) \u003d\u003e (i in set (inds busRoads))))","non-empty sequence obligation:(forall lineNumber:nat, route:seq of (RoadNumber) \u0026 ((((len route) \u003e 1) and (lineNumber not in set (dom buses))) \u003d\u003e (([currentWP] ^ [currentWP]) \u003c\u003e [])))","legal sequence application obligation:(forall lineNumber:nat, route:seq of (RoadNumber) \u0026 ((((len route) \u003e 1) and (lineNumber not in set (dom buses))) \u003d\u003e ((len ([currentWP] ^ [currentWP])) in set (inds ([currentWP] ^ [currentWP])))))","map compatible obligation:(forall lineNumber:nat, route:seq of (RoadNumber) \u0026 ((((len route) \u003e 1) and (lineNumber not in set (dom buses))) \u003d\u003e (forall ldom1 in set (dom buses), rdom2 in set (dom {lineNumber |-\u003e bus}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (buses(ldom1) \u003d {lineNumber |-\u003e bus}(rdom2))))))","type compatibility obligation:(forall lineNumber:nat, route:seq of (RoadNumber) \u0026 ((((len route) \u003e 1) and (lineNumber not in set (dom buses))) \u003d\u003e is_((buses munion {lineNumber |-\u003e bus}), inmap (nat) to (Bus))))","type compatibility obligation:(forall lineNumber:nat, route:seq of (RoadNumber) \u0026 ((((len route) \u003e 1) and (lineNumber not in set (dom buses))) \u003d\u003e is_(RESULT, Bus)))","legal map application obligation:(forall route:seq of (RoadNumber) \u0026 (forall i in set (inds route) \u0026 (route(i) in set (dom roads))))","legal sequence application obligation:(forall route:seq of (RoadNumber) \u0026 (forall i in set (inds route) \u0026 (i in set (inds route))))","legal function application obligation:(forall filename:seq of (char) \u0026 pre_(((io.freadval))[InputTP]filename))","type compatibility obligation:(forall filename:seq of (char) \u0026 is_(input, seq of (inline)))","while loop termination obligation:NotYetImplemented","non-empty sequence obligation:(inlines \u003c\u003e [])","type compatibility obligation:is_((event.t), real)","legal sequence application obligation:(true \u003d\u003e (true \u003d\u003e (forall i in set (inds wps) \u0026 (i in set (inds wps)))))","legal sequence application obligation:(true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (forall i in set (inds wps) \u0026 (i in set (inds wps)))))))","type compatibility obligation:(true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e is_((event.t), real)))))))","type compatibility obligation:(true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (forall city1:City, io2:IO, inlines3:seq of (inline), outlines4:seq of (char), busy5:bool, simulating6:bool, passengersTransported7:nat, passengersAnnoyed8:nat, passengersCount9:nat, passengersAnnoyedStops10:map (WaypointsEnum) to (nat) \u0026 (true \u003d\u003e is_((event.t), real)))))))))","type compatibility obligation:(true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (forall city1:City, io2:IO, inlines3:seq of (inline), outlines4:seq of (char), busy5:bool, simulating6:bool, passengersTransported7:nat, passengersAnnoyed8:nat, passengersCount9:nat, passengersAnnoyedStops10:map (WaypointsEnum) to (nat) \u0026 (true \u003d\u003e (true \u003d\u003e is_((event.t), real))))))))))","non-empty sequence obligation:(true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (forall city1:City, io2:IO, inlines3:seq of (inline), outlines4:seq of (char), busy5:bool, simulating6:bool, passengersTransported7:nat, passengersAnnoyed8:nat, passengersCount9:nat, passengersAnnoyedStops10:map (WaypointsEnum) to (nat) \u0026 (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (inlines3 \u003c\u003e []))))))))))))","legal map application obligation:(forall number:nat, goal:WaypointsEnum \u0026 (goal in set (dom (passengersAnnoyedStops ++ {goal |-\u003e number}))))","legal map application obligation:(true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (waypoint in set (dom passengersAnnoyedStops))))))))","operation call obligation:(forall text:seq of (char) \u0026 ((\"\" \u003d \"\") \u003c\u003d\u003e (\"\" \u003d nil)))","non-zero obligation:(forall a:real \u0026 ((a \u003c\u003e 0) \u003d\u003e (a \u003c\u003e 0)))"] \ No newline at end of file +["state invariant holds obligation:(forall destination:Busstop \u0026 (((destination.IsStop)() \u003d true) \u003d\u003e ((goal.IsStop)() \u003d true)))","state invariant holds obligation:(((goal.IsStop)() \u003d true) \u003d\u003e ((goal.IsStop)() \u003d true))","state invariant holds obligation:(((goal.IsStop)() \u003d true) \u003d\u003e ((goal.IsStop)() \u003d true))","state invariant holds obligation:(((goal.IsStop)() \u003d true) \u003d\u003e ((goal.IsStop)() \u003d true))","state invariant holds obligation:(forall roadnumber:RoadNumber, waypoints:set of (Waypoint), length:nat \u0026 (((card waypoints) \u003e 1) \u003d\u003e ((card waypoints) \u003e 1)))","non-zero obligation:(forall roadnumber:RoadNumber, waypoints:set of (Waypoint), length:nat, limit:nat \u0026 (((card waypoints) \u003e 1) \u003d\u003e (limit \u003c\u003e 0)))","type compatibility obligation:(forall roadnumber:RoadNumber, waypoints:set of (Waypoint), length:nat, limit:nat \u0026 (((card waypoints) \u003e 1) \u003d\u003e ((floor (length / limit)) \u003e\u003d 0)))","state invariant holds obligation:(forall roadnumber:RoadNumber, waypoints:set of (Waypoint), length:nat, limit:nat \u0026 (((card waypoints) \u003e 1) \u003d\u003e ((card waypoints) \u003e 1)))","let be st existence obligation:(forall wp:Waypoint \u0026 ((wp in set wps) \u003d\u003e (exists opposite in set (wps \\ {wp}) \u0026 true)))","non-empty sequence obligation:(forall linenumber:nat, busroute:seq of (Road), waypoints:seq of (Waypoint) \u0026 (((len waypoints) \u003e 1) \u003d\u003e (waypoints \u003c\u003e [])))","state invariant holds obligation:(forall linenumber:nat, busroute:seq of (Road), waypoints:seq of (Waypoint) \u0026 (((len waypoints) \u003e 1) \u003d\u003e ((card {}) \u003c\u003d Config`BusCapacity)))","state invariant holds obligation:(forall ps:set of (Passenger) \u0026 ((((card seats) + (card ps)) \u003c\u003d Config`BusCapacity) \u003d\u003e (((card seats) \u003c\u003d Config`BusCapacity) \u003d\u003e ((card (seats union ps)) \u003c\u003d Config`BusCapacity))))","state invariant holds obligation:(forall p:set of (Passenger) \u0026 (((p inter seats) \u003c\u003e {}) \u003d\u003e (((card seats) \u003c\u003d Config`BusCapacity) \u003d\u003e ((card (seats \\ p)) \u003c\u003d Config`BusCapacity))))","legal sequence application obligation:(forall i in set (inds wps) \u0026 ((wps(i).IsStop)() \u003d\u003e (i in set (inds wps))))","legal sequence application obligation:(forall i in set (inds wps) \u0026 (i in set (inds wps)))","type compatibility obligation:is_(RESULT, seq of (Busstop))","state invariant holds obligation:(((card seats) \u003c\u003d Config`BusCapacity) \u003d\u003e ((card seats) \u003c\u003d Config`BusCapacity))","non-empty sequence obligation:(route \u003c\u003e [])","state invariant holds obligation:(((card seats) \u003c\u003d Config`BusCapacity) \u003d\u003e ((card seats) \u003c\u003d Config`BusCapacity))","non-empty sequence obligation:(route \u003c\u003e [])","state invariant holds obligation:(((card seats) \u003c\u003d Config`BusCapacity) \u003d\u003e ((card seats) \u003c\u003d Config`BusCapacity))","state invariant holds obligation:(((card seats) \u003c\u003d Config`BusCapacity) \u003d\u003e ((card seats) \u003c\u003d Config`BusCapacity))","let be st existence obligation:(forall ps:set of (Passenger), limit:nat \u0026 (exists sub in set ps \u0026 true))","cases exhaustive obligation:(forall d:Direction \u0026 ((((d \u003d \u003cNORTH\u003e) or (d \u003d \u003cSOUTH\u003e)) or (d \u003d \u003cEAST\u003e)) or (d \u003d \u003cWEST\u003e)))","legal map application obligation:(forall th in set (dom wakeUpMap) \u0026 (th in set (dom wakeUpMap)))","legal map application obligation:(forall th in set (dom wakeUpMap) \u0026 (th in set (dom wakeUpMap)))","let be st existence obligation:(exists p in set waitset \u0026 true)","map compatible obligation:(forall stp:BusStops \u0026 ((stp not in set (dom stops)) \u003d\u003e (forall ldom1 in set (dom stops), rdom2 in set (dom {stp |-\u003e bs}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (stops(ldom1) \u003d {stp |-\u003e bs}(rdom2))))))","type compatibility obligation:(forall stp:BusStops \u0026 ((stp not in set (dom stops)) \u003d\u003e is_((stops munion {stp |-\u003e bs}), inmap (BusStops) to (Busstop))))","map compatible obligation:(forall wp1:Waypoint, wp2:Waypoint, roadNmbr:RoadNumber, length:nat \u0026 (((roadNmbr not in set (dom roads)) and ((wp1 \u003c\u003e wp2) and (forall r in set (rng roads) \u0026 (not (r.Covers)({wp1, wp2}))))) \u003d\u003e (forall ldom1 in set (dom roads), rdom2 in set (dom {roadNmbr |-\u003e r}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (roads(ldom1) \u003d {roadNmbr |-\u003e r}(rdom2))))))","type compatibility obligation:(forall wp1:Waypoint, wp2:Waypoint, roadNmbr:RoadNumber, length:nat \u0026 (((roadNmbr not in set (dom roads)) and ((wp1 \u003c\u003e wp2) and (forall r in set (rng roads) \u0026 (not (r.Covers)({wp1, wp2}))))) \u003d\u003e is_((roads munion {roadNmbr |-\u003e r}), inmap (RoadNumber) to (Road))))","map compatible obligation:(forall wp1:Waypoint, wp2:Waypoint, roadNmbr:RoadNumber, length:nat, speedlimit:nat \u0026 (((roadNmbr not in set (dom roads)) and (forall r in set (rng roads) \u0026 ((not (r.Covers)({wp1, wp2})) and (wp1 \u003c\u003e wp2)))) \u003d\u003e (forall ldom1 in set (dom roads), rdom2 in set (dom {roadNmbr |-\u003e r}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (roads(ldom1) \u003d {roadNmbr |-\u003e r}(rdom2))))))","type compatibility obligation:(forall wp1:Waypoint, wp2:Waypoint, roadNmbr:RoadNumber, length:nat, speedlimit:nat \u0026 (((roadNmbr not in set (dom roads)) and (forall r in set (rng roads) \u0026 ((not (r.Covers)({wp1, wp2})) and (wp1 \u003c\u003e wp2)))) \u003d\u003e is_((roads munion {roadNmbr |-\u003e r}), inmap (RoadNumber) to (Road))))","legal sequence application obligation:(forall lineNumber:nat, route:seq of (RoadNumber) \u0026 ((((len route) \u003e 1) and (lineNumber not in set (dom buses))) \u003d\u003e (i in set (inds busRoads))))","non-empty sequence obligation:(forall lineNumber:nat, route:seq of (RoadNumber) \u0026 ((((len route) \u003e 1) and (lineNumber not in set (dom buses))) \u003d\u003e (([currentWP] ^ [currentWP]) \u003c\u003e [])))","legal sequence application obligation:(forall lineNumber:nat, route:seq of (RoadNumber) \u0026 ((((len route) \u003e 1) and (lineNumber not in set (dom buses))) \u003d\u003e ((len ([currentWP] ^ [currentWP])) in set (inds ([currentWP] ^ [currentWP])))))","map compatible obligation:(forall lineNumber:nat, route:seq of (RoadNumber) \u0026 ((((len route) \u003e 1) and (lineNumber not in set (dom buses))) \u003d\u003e (forall ldom1 in set (dom buses), rdom2 in set (dom {lineNumber |-\u003e bus}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (buses(ldom1) \u003d {lineNumber |-\u003e bus}(rdom2))))))","type compatibility obligation:(forall lineNumber:nat, route:seq of (RoadNumber) \u0026 ((((len route) \u003e 1) and (lineNumber not in set (dom buses))) \u003d\u003e is_((buses munion {lineNumber |-\u003e bus}), inmap (nat) to (Bus))))","type compatibility obligation:(forall lineNumber:nat, route:seq of (RoadNumber) \u0026 ((((len route) \u003e 1) and (lineNumber not in set (dom buses))) \u003d\u003e is_(RESULT, Bus)))","legal map application obligation:(forall route:seq of (RoadNumber) \u0026 (forall i in set (inds route) \u0026 (route(i) in set (dom roads))))","legal sequence application obligation:(forall route:seq of (RoadNumber) \u0026 (forall i in set (inds route) \u0026 (i in set (inds route))))","legal function application obligation:(forall filename:seq of (char) \u0026 pre_(((io.freadval))[InputTP]filename))","type compatibility obligation:(forall filename:seq of (char) \u0026 is_(input, seq of (inline)))","while loop termination obligation:...","non-empty sequence obligation:(inlines \u003c\u003e [])","type compatibility obligation:is_((event.t), real)","legal sequence application obligation:(true \u003d\u003e (true \u003d\u003e (forall i in set (inds wps) \u0026 (i in set (inds wps)))))","legal sequence application obligation:(true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (forall i in set (inds wps) \u0026 (i in set (inds wps)))))))","type compatibility obligation:(true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e is_((event.t), real)))))))","type compatibility obligation:(true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (forall city1:City, io2:IO, inlines3:seq of (inline), outlines4:seq of (char), busy5:bool, simulating6:bool, passengersTransported7:nat, passengersAnnoyed8:nat, passengersCount9:nat, passengersAnnoyedStops10:map (WaypointsEnum) to (nat) \u0026 (true \u003d\u003e is_((event.t), real)))))))))","type compatibility obligation:(true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (forall city1:City, io2:IO, inlines3:seq of (inline), outlines4:seq of (char), busy5:bool, simulating6:bool, passengersTransported7:nat, passengersAnnoyed8:nat, passengersCount9:nat, passengersAnnoyedStops10:map (WaypointsEnum) to (nat) \u0026 (true \u003d\u003e (true \u003d\u003e is_((event.t), real))))))))))","non-empty sequence obligation:(true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (forall city1:City, io2:IO, inlines3:seq of (inline), outlines4:seq of (char), busy5:bool, simulating6:bool, passengersTransported7:nat, passengersAnnoyed8:nat, passengersCount9:nat, passengersAnnoyedStops10:map (WaypointsEnum) to (nat) \u0026 (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (inlines3 \u003c\u003e []))))))))))))","legal map application obligation:(forall number:nat, goal:WaypointsEnum \u0026 (goal in set (dom (passengersAnnoyedStops ++ {goal |-\u003e number}))))","legal map application obligation:(true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (waypoint in set (dom passengersAnnoyedStops))))))))","operation call obligation:(forall text:seq of (char) \u0026 ((\"\" \u003d \"\") \u003c\u003d\u003e (\"\" \u003d nil)))","non-zero obligation:(forall a:real \u0026 ((a \u003c\u003e 0) \u003d\u003e (a \u003c\u003e 0)))"] \ No newline at end of file diff --git a/core/pog/src/test/resources/examples/BuslinesWithDBPP.result b/core/pog/src/test/resources/examples/BuslinesWithDBPP.result index bab261aff2..a866718ac0 100644 --- a/core/pog/src/test/resources/examples/BuslinesWithDBPP.result +++ b/core/pog/src/test/resources/examples/BuslinesWithDBPP.result @@ -1 +1 @@ -["state invariant holds obligation:(forall destination:Busstop \u0026 (((destination.IsStop)() \u003d true) \u003d\u003e ((goal.IsStop)() \u003d true)))","state invariant holds obligation:(((goal.IsStop)() \u003d true) \u003d\u003e ((goal.IsStop)() \u003d true))","state invariant holds obligation:(((goal.IsStop)() \u003d true) \u003d\u003e ((goal.IsStop)() \u003d true))","state invariant holds obligation:(((goal.IsStop)() \u003d true) \u003d\u003e ((goal.IsStop)() \u003d true))","non-zero obligation:(forall roadnumber:RoadNumber, waypoints:set of (Waypoint), length:nat \u0026 (((card waypoints) \u003e 1) \u003d\u003e (Config`DefaultRoadSpeedLimit \u003c\u003e 0)))","type compatibility obligation:(forall roadnumber:RoadNumber, waypoints:set of (Waypoint), length:nat \u0026 (((card waypoints) \u003e 1) \u003d\u003e ((floor (length / Config`DefaultRoadSpeedLimit)) \u003e\u003d 0)))","state invariant holds obligation:(forall roadnumber:RoadNumber, waypoints:set of (Waypoint), length:nat \u0026 (((card waypoints) \u003e 1) \u003d\u003e ((card waypoints) \u003e 1)))","non-zero obligation:(forall roadnumber:RoadNumber, waypoints:set of (Waypoint), length:nat, limit:nat \u0026 (((card waypoints) \u003e 1) \u003d\u003e (limit \u003c\u003e 0)))","type compatibility obligation:(forall roadnumber:RoadNumber, waypoints:set of (Waypoint), length:nat, limit:nat \u0026 (((card waypoints) \u003e 1) \u003d\u003e ((floor (length / limit)) \u003e\u003d 0)))","state invariant holds obligation:(forall roadnumber:RoadNumber, waypoints:set of (Waypoint), length:nat, limit:nat \u0026 (((card waypoints) \u003e 1) \u003d\u003e ((card waypoints) \u003e 1)))","let be st existence obligation:(forall wp:Waypoint \u0026 ((wp in set wps) \u003d\u003e (exists opposite in set (wps \\ {wp}) \u0026 true)))","cases exhaustive obligation:(forall busstop:seq of (char) \u0026 (((((((busstop \u003d \"A\") or (busstop \u003d \"B\")) or (busstop \u003d \"C\")) or (busstop \u003d \"D\")) or (busstop \u003d \"E\")) or (busstop \u003d \"F\")) or (busstop \u003d \"Central\")))","non-empty sequence obligation:(forall linenumber:nat, busroute:seq of (Road), waypoints:seq of (Waypoint) \u0026 ((((len waypoints) \u003e 1) and (waypoints \u003c\u003e [])) \u003d\u003e (waypoints \u003c\u003e [])))","state invariant holds obligation:(forall linenumber:nat, busroute:seq of (Road), waypoints:seq of (Waypoint) \u0026 ((((len waypoints) \u003e 1) and (waypoints \u003c\u003e [])) \u003d\u003e ((card {}) \u003c\u003d Config`BusCapacity)))","state invariant holds obligation:(forall ps:set of (Passenger) \u0026 ((((card seats) + (card ps)) \u003c\u003d Config`BusCapacity) \u003d\u003e (((card seats) \u003c\u003d Config`BusCapacity) \u003d\u003e ((card (seats union ps)) \u003c\u003d Config`BusCapacity))))","state invariant holds obligation:(forall p:set of (Passenger) \u0026 (((p inter seats) \u003c\u003e {}) \u003d\u003e (((card seats) \u003c\u003d Config`BusCapacity) \u003d\u003e ((card (seats \\ p)) \u003c\u003d Config`BusCapacity))))","legal sequence application obligation:(forall i in set (inds wps) \u0026 ((wps(i).IsStop)() \u003d\u003e (i in set (inds wps))))","legal sequence application obligation:(forall i in set (inds wps) \u0026 (i in set (inds wps)))","type compatibility obligation:is_(RESULT, seq of (Busstop))","state invariant holds obligation:(((card seats) \u003c\u003d Config`BusCapacity) \u003d\u003e ((card seats) \u003c\u003d Config`BusCapacity))","non-empty sequence obligation:(route \u003c\u003e [])","state invariant holds obligation:(((card seats) \u003c\u003d Config`BusCapacity) \u003d\u003e ((card seats) \u003c\u003d Config`BusCapacity))","non-empty sequence obligation:(route \u003c\u003e [])","state invariant holds obligation:(((card seats) \u003c\u003d Config`BusCapacity) \u003d\u003e ((card seats) \u003c\u003d Config`BusCapacity))","state invariant holds obligation:(((card seats) \u003c\u003d Config`BusCapacity) \u003d\u003e ((card seats) \u003c\u003d Config`BusCapacity))","let be st existence obligation:(forall ps:set of (Passenger), limit:nat \u0026 (exists sub in set ps \u0026 true))","cases exhaustive obligation:(forall d:Direction \u0026 ((((d \u003d \u003cNORTH\u003e) or (d \u003d \u003cSOUTH\u003e)) or (d \u003d \u003cEAST\u003e)) or (d \u003d \u003cWEST\u003e)))","legal map application obligation:(forall th in set (dom wakeUpMap) \u0026 (th in set (dom wakeUpMap)))","legal map application obligation:(forall th in set (dom wakeUpMap) \u0026 (th in set (dom wakeUpMap)))","let be st existence obligation:(exists p in set waitset \u0026 true)","map compatible obligation:(forall stp:BusStops \u0026 ((stp not in set (dom stops)) \u003d\u003e (forall ldom1 in set (dom stops), rdom2 in set (dom {stp |-\u003e bs}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (stops(ldom1) \u003d {stp |-\u003e bs}(rdom2))))))","type compatibility obligation:(forall stp:BusStops \u0026 ((stp not in set (dom stops)) \u003d\u003e is_((stops munion {stp |-\u003e bs}), inmap (BusStops) to (Busstop))))","map compatible obligation:(forall stp:BusStops \u0026 ((stp not in set (dom stops)) \u003d\u003e (forall ldom1 in set (dom wayspoints), rdom2 in set (dom {stp |-\u003e bs}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (wayspoints(ldom1) \u003d {stp |-\u003e bs}(rdom2))))))","type compatibility obligation:(forall stp:BusStops \u0026 ((stp not in set (dom stops)) \u003d\u003e is_((wayspoints munion {stp |-\u003e bs}), inmap (WaypointsEnum) to (Waypoint))))","map compatible obligation:(forall stp:WaypointsEnum \u0026 ((stp not in set (dom stops)) \u003d\u003e (true \u003d\u003e (forall ldom1 in set (dom wayspoints), rdom2 in set (dom {stp |-\u003e wp}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (wayspoints(ldom1) \u003d {stp |-\u003e wp}(rdom2)))))))","type compatibility obligation:(forall stp:WaypointsEnum \u0026 ((stp not in set (dom stops)) \u003d\u003e (true \u003d\u003e is_((wayspoints munion {stp |-\u003e wp}), inmap (WaypointsEnum) to (Waypoint)))))","map compatible obligation:(forall wp1:Waypoint, wp2:Waypoint, roadNmbr:RoadNumber, length:nat \u0026 (((roadNmbr not in set (dom roads)) and ((wp1 \u003c\u003e wp2) and (forall r in set (rng roads) \u0026 (not (r.Covers)({wp1, wp2}))))) \u003d\u003e (forall ldom1 in set (dom roads), rdom2 in set (dom {roadNmbr |-\u003e r}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (roads(ldom1) \u003d {roadNmbr |-\u003e r}(rdom2))))))","type compatibility obligation:(forall wp1:Waypoint, wp2:Waypoint, roadNmbr:RoadNumber, length:nat \u0026 (((roadNmbr not in set (dom roads)) and ((wp1 \u003c\u003e wp2) and (forall r in set (rng roads) \u0026 (not (r.Covers)({wp1, wp2}))))) \u003d\u003e is_((roads munion {roadNmbr |-\u003e r}), inmap (RoadNumber) to (Road))))","legal map application obligation:(forall wp1:WaypointsEnum, wp2:WaypointsEnum, roadNmbr:RoadNumber, length:nat, highspeed:bool \u0026 (wp1 in set (dom wayspoints)))","legal map application obligation:(forall wp1:WaypointsEnum, wp2:WaypointsEnum, roadNmbr:RoadNumber, length:nat, highspeed:bool \u0026 (wp2 in set (dom wayspoints)))","operation call obligation:(forall wp1:WaypointsEnum, wp2:WaypointsEnum, roadNmbr:RoadNumber, length:nat, highspeed:bool \u0026 ((wayspoints(wp1) not in set (dom roads)) and (forall r in set (rng roads) \u0026 ((not (r.Covers)({wp1, wp2})) and (wp1 \u003c\u003e wp2)))))","legal map application obligation:(forall wp1:WaypointsEnum, wp2:WaypointsEnum, roadNmbr:RoadNumber, length:nat, highspeed:bool \u0026 (forall wayspoints1:inmap (WaypointsEnum) to (Waypoint), stops2:inmap (BusStops) to (Busstop), roads3:inmap (RoadNumber) to (Road), buses4:inmap (nat) to (Bus), central5:Busstop, inflow6:nat \u0026 (true \u003d\u003e (wp1 in set (dom wayspoints1)))))","legal map application obligation:(forall wp1:WaypointsEnum, wp2:WaypointsEnum, roadNmbr:RoadNumber, length:nat, highspeed:bool \u0026 (forall wayspoints1:inmap (WaypointsEnum) to (Waypoint), stops2:inmap (BusStops) to (Busstop), roads3:inmap (RoadNumber) to (Road), buses4:inmap (nat) to (Bus), central5:Busstop, inflow6:nat \u0026 (true \u003d\u003e (wp2 in set (dom wayspoints1)))))","operation call obligation:(forall wp1:WaypointsEnum, wp2:WaypointsEnum, roadNmbr:RoadNumber, length:nat, highspeed:bool \u0026 (forall wayspoints1:inmap (WaypointsEnum) to (Waypoint), stops2:inmap (BusStops) to (Busstop), roads3:inmap (RoadNumber) to (Road), buses4:inmap (nat) to (Bus), central5:Busstop, inflow6:nat \u0026 (true \u003d\u003e ((wayspoints(wp1) not in set (dom roads3)) and ((wayspoints(wp1) \u003c\u003e wayspoints(wp1)) and (forall r in set (rng roads) \u0026 (not (r.Covers)({wp1, wp2}))))))))","map compatible obligation:(forall wp1:Waypoint, wp2:Waypoint, roadNmbr:RoadNumber, length:nat, speedlimit:nat \u0026 (((roadNmbr not in set (dom roads)) and (forall r in set (rng roads) \u0026 ((not (r.Covers)({wp1, wp2})) and (wp1 \u003c\u003e wp2)))) \u003d\u003e (forall ldom1 in set (dom roads), rdom2 in set (dom {roadNmbr |-\u003e r}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (roads(ldom1) \u003d {roadNmbr |-\u003e r}(rdom2))))))","type compatibility obligation:(forall wp1:Waypoint, wp2:Waypoint, roadNmbr:RoadNumber, length:nat, speedlimit:nat \u0026 (((roadNmbr not in set (dom roads)) and (forall r in set (rng roads) \u0026 ((not (r.Covers)({wp1, wp2})) and (wp1 \u003c\u003e wp2)))) \u003d\u003e is_((roads munion {roadNmbr |-\u003e r}), inmap (RoadNumber) to (Road))))","legal sequence application obligation:(forall lineNumber:nat, route:seq of (RoadNumber) \u0026 ((((len route) \u003e 1) and (lineNumber not in set (dom buses))) \u003d\u003e (i in set (inds busRoads))))","non-empty sequence obligation:(forall lineNumber:nat, route:seq of (RoadNumber) \u0026 ((((len route) \u003e 1) and (lineNumber not in set (dom buses))) \u003d\u003e (([currentWP] ^ [currentWP]) \u003c\u003e [])))","legal sequence application obligation:(forall lineNumber:nat, route:seq of (RoadNumber) \u0026 ((((len route) \u003e 1) and (lineNumber not in set (dom buses))) \u003d\u003e ((len ([currentWP] ^ [currentWP])) in set (inds ([currentWP] ^ [currentWP])))))","map compatible obligation:(forall lineNumber:nat, route:seq of (RoadNumber) \u0026 ((((len route) \u003e 1) and (lineNumber not in set (dom buses))) \u003d\u003e (forall ldom1 in set (dom buses), rdom2 in set (dom {lineNumber |-\u003e bus}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (buses(ldom1) \u003d {lineNumber |-\u003e bus}(rdom2))))))","type compatibility obligation:(forall lineNumber:nat, route:seq of (RoadNumber) \u0026 ((((len route) \u003e 1) and (lineNumber not in set (dom buses))) \u003d\u003e is_((buses munion {lineNumber |-\u003e bus}), inmap (nat) to (Bus))))","type compatibility obligation:(forall lineNumber:nat, route:seq of (RoadNumber) \u0026 ((((len route) \u003e 1) and (lineNumber not in set (dom buses))) \u003d\u003e is_(RESULT, Bus)))","legal map application obligation:(forall route:seq of (RoadNumber) \u0026 (forall i in set (inds route) \u0026 (route(i) in set (dom roads))))","legal sequence application obligation:(forall route:seq of (RoadNumber) \u0026 (forall i in set (inds route) \u0026 (i in set (inds route))))","legal function application obligation:(forall filename:seq of (char) \u0026 pre_(((io.freadval))[InputTP]filename))","type compatibility obligation:(forall filename:seq of (char) \u0026 is_(input, seq of (inline)))","while loop termination obligation:NotYetImplemented","non-empty sequence obligation:(inlines \u003c\u003e [])","type compatibility obligation:is_((event.t), real)","legal sequence application obligation:(true \u003d\u003e (true \u003d\u003e (forall i in set (inds wps) \u0026 (i in set (inds wps)))))","legal sequence application obligation:(true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (forall i in set (inds wps) \u0026 (i in set (inds wps)))))))","type compatibility obligation:(true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e is_((event.t), real)))))))","type compatibility obligation:(true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (forall city1:City, io2:IO, inlines3:seq of (inline), outlines4:seq of (char), busy5:bool, simulating6:bool, passengersTransported7:nat, passengersAnnoyed8:nat, passengersCount9:nat, passengersAnnoyedStops10:map (WaypointsEnum) to (nat) \u0026 (true \u003d\u003e is_((event.t), real)))))))))","type compatibility obligation:(true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (forall city1:City, io2:IO, inlines3:seq of (inline), outlines4:seq of (char), busy5:bool, simulating6:bool, passengersTransported7:nat, passengersAnnoyed8:nat, passengersCount9:nat, passengersAnnoyedStops10:map (WaypointsEnum) to (nat) \u0026 (true \u003d\u003e (true \u003d\u003e is_((event.t), real))))))))))","non-empty sequence obligation:(true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (forall city1:City, io2:IO, inlines3:seq of (inline), outlines4:seq of (char), busy5:bool, simulating6:bool, passengersTransported7:nat, passengersAnnoyed8:nat, passengersCount9:nat, passengersAnnoyedStops10:map (WaypointsEnum) to (nat) \u0026 (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (inlines3 \u003c\u003e []))))))))))))","legal map application obligation:(forall number:nat, goal:WaypointsEnum \u0026 (goal in set (dom (passengersAnnoyedStops ++ {goal |-\u003e number}))))","legal map application obligation:(true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (waypoint in set (dom passengersAnnoyedStops))))))))","operation call obligation:(forall text:seq of (char) \u0026 ((\"\" \u003d \"\") \u003c\u003d\u003e (\"\" \u003d nil)))","non-zero obligation:(forall a:real \u0026 ((a \u003c\u003e 0) \u003d\u003e (a \u003c\u003e 0)))"] \ No newline at end of file +["state invariant holds obligation:(forall destination:Busstop \u0026 (((destination.IsStop)() \u003d true) \u003d\u003e ((goal.IsStop)() \u003d true)))","state invariant holds obligation:(((goal.IsStop)() \u003d true) \u003d\u003e ((goal.IsStop)() \u003d true))","state invariant holds obligation:(((goal.IsStop)() \u003d true) \u003d\u003e ((goal.IsStop)() \u003d true))","state invariant holds obligation:(((goal.IsStop)() \u003d true) \u003d\u003e ((goal.IsStop)() \u003d true))","non-zero obligation:(forall roadnumber:RoadNumber, waypoints:set of (Waypoint), length:nat \u0026 (((card waypoints) \u003e 1) \u003d\u003e (Config`DefaultRoadSpeedLimit \u003c\u003e 0)))","type compatibility obligation:(forall roadnumber:RoadNumber, waypoints:set of (Waypoint), length:nat \u0026 (((card waypoints) \u003e 1) \u003d\u003e ((floor (length / Config`DefaultRoadSpeedLimit)) \u003e\u003d 0)))","state invariant holds obligation:(forall roadnumber:RoadNumber, waypoints:set of (Waypoint), length:nat \u0026 (((card waypoints) \u003e 1) \u003d\u003e ((card waypoints) \u003e 1)))","non-zero obligation:(forall roadnumber:RoadNumber, waypoints:set of (Waypoint), length:nat, limit:nat \u0026 (((card waypoints) \u003e 1) \u003d\u003e (limit \u003c\u003e 0)))","type compatibility obligation:(forall roadnumber:RoadNumber, waypoints:set of (Waypoint), length:nat, limit:nat \u0026 (((card waypoints) \u003e 1) \u003d\u003e ((floor (length / limit)) \u003e\u003d 0)))","state invariant holds obligation:(forall roadnumber:RoadNumber, waypoints:set of (Waypoint), length:nat, limit:nat \u0026 (((card waypoints) \u003e 1) \u003d\u003e ((card waypoints) \u003e 1)))","let be st existence obligation:(forall wp:Waypoint \u0026 ((wp in set wps) \u003d\u003e (exists opposite in set (wps \\ {wp}) \u0026 true)))","cases exhaustive obligation:(forall busstop:seq of (char) \u0026 (((((((busstop \u003d \"A\") or (busstop \u003d \"B\")) or (busstop \u003d \"C\")) or (busstop \u003d \"D\")) or (busstop \u003d \"E\")) or (busstop \u003d \"F\")) or (busstop \u003d \"Central\")))","non-empty sequence obligation:(forall linenumber:nat, busroute:seq of (Road), waypoints:seq of (Waypoint) \u0026 ((((len waypoints) \u003e 1) and (waypoints \u003c\u003e [])) \u003d\u003e (waypoints \u003c\u003e [])))","state invariant holds obligation:(forall linenumber:nat, busroute:seq of (Road), waypoints:seq of (Waypoint) \u0026 ((((len waypoints) \u003e 1) and (waypoints \u003c\u003e [])) \u003d\u003e ((card {}) \u003c\u003d Config`BusCapacity)))","state invariant holds obligation:(forall ps:set of (Passenger) \u0026 ((((card seats) + (card ps)) \u003c\u003d Config`BusCapacity) \u003d\u003e (((card seats) \u003c\u003d Config`BusCapacity) \u003d\u003e ((card (seats union ps)) \u003c\u003d Config`BusCapacity))))","state invariant holds obligation:(forall p:set of (Passenger) \u0026 (((p inter seats) \u003c\u003e {}) \u003d\u003e (((card seats) \u003c\u003d Config`BusCapacity) \u003d\u003e ((card (seats \\ p)) \u003c\u003d Config`BusCapacity))))","legal sequence application obligation:(forall i in set (inds wps) \u0026 ((wps(i).IsStop)() \u003d\u003e (i in set (inds wps))))","legal sequence application obligation:(forall i in set (inds wps) \u0026 (i in set (inds wps)))","type compatibility obligation:is_(RESULT, seq of (Busstop))","state invariant holds obligation:(((card seats) \u003c\u003d Config`BusCapacity) \u003d\u003e ((card seats) \u003c\u003d Config`BusCapacity))","non-empty sequence obligation:(route \u003c\u003e [])","state invariant holds obligation:(((card seats) \u003c\u003d Config`BusCapacity) \u003d\u003e ((card seats) \u003c\u003d Config`BusCapacity))","non-empty sequence obligation:(route \u003c\u003e [])","state invariant holds obligation:(((card seats) \u003c\u003d Config`BusCapacity) \u003d\u003e ((card seats) \u003c\u003d Config`BusCapacity))","state invariant holds obligation:(((card seats) \u003c\u003d Config`BusCapacity) \u003d\u003e ((card seats) \u003c\u003d Config`BusCapacity))","let be st existence obligation:(forall ps:set of (Passenger), limit:nat \u0026 (exists sub in set ps \u0026 true))","cases exhaustive obligation:(forall d:Direction \u0026 ((((d \u003d \u003cNORTH\u003e) or (d \u003d \u003cSOUTH\u003e)) or (d \u003d \u003cEAST\u003e)) or (d \u003d \u003cWEST\u003e)))","legal map application obligation:(forall th in set (dom wakeUpMap) \u0026 (th in set (dom wakeUpMap)))","legal map application obligation:(forall th in set (dom wakeUpMap) \u0026 (th in set (dom wakeUpMap)))","let be st existence obligation:(exists p in set waitset \u0026 true)","map compatible obligation:(forall stp:BusStops \u0026 ((stp not in set (dom stops)) \u003d\u003e (forall ldom1 in set (dom stops), rdom2 in set (dom {stp |-\u003e bs}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (stops(ldom1) \u003d {stp |-\u003e bs}(rdom2))))))","type compatibility obligation:(forall stp:BusStops \u0026 ((stp not in set (dom stops)) \u003d\u003e is_((stops munion {stp |-\u003e bs}), inmap (BusStops) to (Busstop))))","map compatible obligation:(forall stp:BusStops \u0026 ((stp not in set (dom stops)) \u003d\u003e (forall ldom1 in set (dom wayspoints), rdom2 in set (dom {stp |-\u003e bs}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (wayspoints(ldom1) \u003d {stp |-\u003e bs}(rdom2))))))","type compatibility obligation:(forall stp:BusStops \u0026 ((stp not in set (dom stops)) \u003d\u003e is_((wayspoints munion {stp |-\u003e bs}), inmap (WaypointsEnum) to (Waypoint))))","map compatible obligation:(forall stp:WaypointsEnum \u0026 ((stp not in set (dom stops)) \u003d\u003e (true \u003d\u003e (forall ldom1 in set (dom wayspoints), rdom2 in set (dom {stp |-\u003e wp}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (wayspoints(ldom1) \u003d {stp |-\u003e wp}(rdom2)))))))","type compatibility obligation:(forall stp:WaypointsEnum \u0026 ((stp not in set (dom stops)) \u003d\u003e (true \u003d\u003e is_((wayspoints munion {stp |-\u003e wp}), inmap (WaypointsEnum) to (Waypoint)))))","map compatible obligation:(forall wp1:Waypoint, wp2:Waypoint, roadNmbr:RoadNumber, length:nat \u0026 (((roadNmbr not in set (dom roads)) and ((wp1 \u003c\u003e wp2) and (forall r in set (rng roads) \u0026 (not (r.Covers)({wp1, wp2}))))) \u003d\u003e (forall ldom1 in set (dom roads), rdom2 in set (dom {roadNmbr |-\u003e r}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (roads(ldom1) \u003d {roadNmbr |-\u003e r}(rdom2))))))","type compatibility obligation:(forall wp1:Waypoint, wp2:Waypoint, roadNmbr:RoadNumber, length:nat \u0026 (((roadNmbr not in set (dom roads)) and ((wp1 \u003c\u003e wp2) and (forall r in set (rng roads) \u0026 (not (r.Covers)({wp1, wp2}))))) \u003d\u003e is_((roads munion {roadNmbr |-\u003e r}), inmap (RoadNumber) to (Road))))","legal map application obligation:(forall wp1:WaypointsEnum, wp2:WaypointsEnum, roadNmbr:RoadNumber, length:nat, highspeed:bool \u0026 (wp1 in set (dom wayspoints)))","legal map application obligation:(forall wp1:WaypointsEnum, wp2:WaypointsEnum, roadNmbr:RoadNumber, length:nat, highspeed:bool \u0026 (wp2 in set (dom wayspoints)))","operation call obligation:(forall wp1:WaypointsEnum, wp2:WaypointsEnum, roadNmbr:RoadNumber, length:nat, highspeed:bool \u0026 ((wayspoints(wp1) not in set (dom roads)) and (forall r in set (rng roads) \u0026 ((not (r.Covers)({wp1, wp2})) and (wp1 \u003c\u003e wp2)))))","legal map application obligation:(forall wp1:WaypointsEnum, wp2:WaypointsEnum, roadNmbr:RoadNumber, length:nat, highspeed:bool \u0026 (forall wayspoints1:inmap (WaypointsEnum) to (Waypoint), stops2:inmap (BusStops) to (Busstop), roads3:inmap (RoadNumber) to (Road), buses4:inmap (nat) to (Bus), central5:Busstop, inflow6:nat \u0026 (true \u003d\u003e (wp1 in set (dom wayspoints1)))))","legal map application obligation:(forall wp1:WaypointsEnum, wp2:WaypointsEnum, roadNmbr:RoadNumber, length:nat, highspeed:bool \u0026 (forall wayspoints1:inmap (WaypointsEnum) to (Waypoint), stops2:inmap (BusStops) to (Busstop), roads3:inmap (RoadNumber) to (Road), buses4:inmap (nat) to (Bus), central5:Busstop, inflow6:nat \u0026 (true \u003d\u003e (wp2 in set (dom wayspoints1)))))","operation call obligation:(forall wp1:WaypointsEnum, wp2:WaypointsEnum, roadNmbr:RoadNumber, length:nat, highspeed:bool \u0026 (forall wayspoints1:inmap (WaypointsEnum) to (Waypoint), stops2:inmap (BusStops) to (Busstop), roads3:inmap (RoadNumber) to (Road), buses4:inmap (nat) to (Bus), central5:Busstop, inflow6:nat \u0026 (true \u003d\u003e ((wayspoints(wp1) not in set (dom roads3)) and ((wayspoints(wp1) \u003c\u003e wayspoints(wp1)) and (forall r in set (rng roads) \u0026 (not (r.Covers)({wp1, wp2}))))))))","map compatible obligation:(forall wp1:Waypoint, wp2:Waypoint, roadNmbr:RoadNumber, length:nat, speedlimit:nat \u0026 (((roadNmbr not in set (dom roads)) and (forall r in set (rng roads) \u0026 ((not (r.Covers)({wp1, wp2})) and (wp1 \u003c\u003e wp2)))) \u003d\u003e (forall ldom1 in set (dom roads), rdom2 in set (dom {roadNmbr |-\u003e r}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (roads(ldom1) \u003d {roadNmbr |-\u003e r}(rdom2))))))","type compatibility obligation:(forall wp1:Waypoint, wp2:Waypoint, roadNmbr:RoadNumber, length:nat, speedlimit:nat \u0026 (((roadNmbr not in set (dom roads)) and (forall r in set (rng roads) \u0026 ((not (r.Covers)({wp1, wp2})) and (wp1 \u003c\u003e wp2)))) \u003d\u003e is_((roads munion {roadNmbr |-\u003e r}), inmap (RoadNumber) to (Road))))","legal sequence application obligation:(forall lineNumber:nat, route:seq of (RoadNumber) \u0026 ((((len route) \u003e 1) and (lineNumber not in set (dom buses))) \u003d\u003e (i in set (inds busRoads))))","non-empty sequence obligation:(forall lineNumber:nat, route:seq of (RoadNumber) \u0026 ((((len route) \u003e 1) and (lineNumber not in set (dom buses))) \u003d\u003e (([currentWP] ^ [currentWP]) \u003c\u003e [])))","legal sequence application obligation:(forall lineNumber:nat, route:seq of (RoadNumber) \u0026 ((((len route) \u003e 1) and (lineNumber not in set (dom buses))) \u003d\u003e ((len ([currentWP] ^ [currentWP])) in set (inds ([currentWP] ^ [currentWP])))))","map compatible obligation:(forall lineNumber:nat, route:seq of (RoadNumber) \u0026 ((((len route) \u003e 1) and (lineNumber not in set (dom buses))) \u003d\u003e (forall ldom1 in set (dom buses), rdom2 in set (dom {lineNumber |-\u003e bus}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (buses(ldom1) \u003d {lineNumber |-\u003e bus}(rdom2))))))","type compatibility obligation:(forall lineNumber:nat, route:seq of (RoadNumber) \u0026 ((((len route) \u003e 1) and (lineNumber not in set (dom buses))) \u003d\u003e is_((buses munion {lineNumber |-\u003e bus}), inmap (nat) to (Bus))))","type compatibility obligation:(forall lineNumber:nat, route:seq of (RoadNumber) \u0026 ((((len route) \u003e 1) and (lineNumber not in set (dom buses))) \u003d\u003e is_(RESULT, Bus)))","legal map application obligation:(forall route:seq of (RoadNumber) \u0026 (forall i in set (inds route) \u0026 (route(i) in set (dom roads))))","legal sequence application obligation:(forall route:seq of (RoadNumber) \u0026 (forall i in set (inds route) \u0026 (i in set (inds route))))","legal function application obligation:(forall filename:seq of (char) \u0026 pre_(((io.freadval))[InputTP]filename))","type compatibility obligation:(forall filename:seq of (char) \u0026 is_(input, seq of (inline)))","while loop termination obligation:...","non-empty sequence obligation:(inlines \u003c\u003e [])","type compatibility obligation:is_((event.t), real)","legal sequence application obligation:(true \u003d\u003e (true \u003d\u003e (forall i in set (inds wps) \u0026 (i in set (inds wps)))))","legal sequence application obligation:(true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (forall i in set (inds wps) \u0026 (i in set (inds wps)))))))","type compatibility obligation:(true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e is_((event.t), real)))))))","type compatibility obligation:(true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (forall city1:City, io2:IO, inlines3:seq of (inline), outlines4:seq of (char), busy5:bool, simulating6:bool, passengersTransported7:nat, passengersAnnoyed8:nat, passengersCount9:nat, passengersAnnoyedStops10:map (WaypointsEnum) to (nat) \u0026 (true \u003d\u003e is_((event.t), real)))))))))","type compatibility obligation:(true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (forall city1:City, io2:IO, inlines3:seq of (inline), outlines4:seq of (char), busy5:bool, simulating6:bool, passengersTransported7:nat, passengersAnnoyed8:nat, passengersCount9:nat, passengersAnnoyedStops10:map (WaypointsEnum) to (nat) \u0026 (true \u003d\u003e (true \u003d\u003e is_((event.t), real))))))))))","non-empty sequence obligation:(true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (forall city1:City, io2:IO, inlines3:seq of (inline), outlines4:seq of (char), busy5:bool, simulating6:bool, passengersTransported7:nat, passengersAnnoyed8:nat, passengersCount9:nat, passengersAnnoyedStops10:map (WaypointsEnum) to (nat) \u0026 (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (inlines3 \u003c\u003e []))))))))))))","legal map application obligation:(forall number:nat, goal:WaypointsEnum \u0026 (goal in set (dom (passengersAnnoyedStops ++ {goal |-\u003e number}))))","legal map application obligation:(true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (waypoint in set (dom passengersAnnoyedStops))))))))","operation call obligation:(forall text:seq of (char) \u0026 ((\"\" \u003d \"\") \u003c\u003d\u003e (\"\" \u003d nil)))","non-zero obligation:(forall a:real \u0026 ((a \u003c\u003e 0) \u003d\u003e (a \u003c\u003e 0)))"] \ No newline at end of file diff --git a/core/pog/src/test/resources/examples/CMConcPP.result b/core/pog/src/test/resources/examples/CMConcPP.result index 34196bc2e9..e3eac3ca07 100644 --- a/core/pog/src/test/resources/examples/CMConcPP.result +++ b/core/pog/src/test/resources/examples/CMConcPP.result @@ -1 +1 @@ -["legal function application obligation:(forall fname:seq of (char), tDef:[ThreadDef] \u0026 pre_(((io.freadval))[InputTP]fname))","state invariant holds obligation:(forall fname:seq of (char), tDef:[ThreadDef] \u0026 ((dom ranges) \u003d (dom sensors)))","state invariant holds obligation:(((dom ranges) \u003d (dom sensors)) \u003d\u003e ((dom (ranges munion {id |-\u003e (psens.getAperture)()})) \u003d (dom (sensors munion {id |-\u003e psens}))))","while loop termination obligation:NotYetImplemented","non-empty sequence obligation:(inlines \u003c\u003e [])","legal map application obligation:(id in set (dom ranges))","state invariant holds obligation:(((dom ranges) \u003d (dom sensors)) \u003d\u003e ((dom ranges) \u003d (dom sensors)))","non-empty sequence obligation:(inlines \u003c\u003e [])","state invariant holds obligation:(((dom ranges) \u003d (dom sensors)) \u003d\u003e ((dom ranges) \u003d (dom sensors)))","state invariant holds obligation:(((dom ranges) \u003d (dom sensors)) \u003d\u003e ((dom ranges) \u003d (dom sensors)))","state invariant holds obligation:(((dom ranges) \u003d (dom sensors)) \u003d\u003e ((dom ranges) \u003d (dom sensors)))","state invariant holds obligation:(forall evid:EventId, pfltp:FlareType, angle:Angle, pt1:Time, pt2:Time \u0026 (((dom ranges) \u003d (dom sensors)) \u003d\u003e ((dom ranges) \u003d (dom sensors))))","legal function application obligation:pre_(((io.writeval))[seq of (outline)]outlines)","state invariant holds obligation:(forall io1:IO, inlines2:seq of (inline), outlines3:seq of (outline), ranges4:map (nat) to ((Angle * Angle)), sensors5:map (nat) to (Sensor), busy6:bool, simtime7:Time \u0026 (((dom ranges4) \u003d (dom sensors5)) \u003d\u003e (((dom ranges4) \u003d (dom sensors5)) \u003d\u003e ((dom ranges4) \u003d (dom sensors5)))))","type compatibility obligation:is_(RESULT, (Angle * Angle))","state invariant holds obligation:(forall papp:Angle, tDef:[ThreadDef] \u0026 ((dom ranges) \u003d (dom dispensers)))","state invariant holds obligation:(((dom ranges) \u003d (dom dispensers)) \u003d\u003e ((dom (ranges munion {id |-\u003e mk_(angle, DISPENSER_APERTURE)})) \u003d (dom (dispensers munion {id |-\u003e pfldisp}))))","type compatibility obligation:is_(RESULT, (Angle * Angle))","state invariant holds obligation:(forall evid:EventId, pmt:MissileType, pa:Angle, pt:Time \u0026 (((dom ranges) \u003d (dom dispensers)) \u003d\u003e ((dom ranges) \u003d (dom dispensers))))","state invariant holds obligation:(forall evid:EventId, pmt:MissileType, pa:Angle, pt:Time \u0026 (((dom ranges) \u003d (dom dispensers)) \u003d\u003e ((dom ranges) \u003d (dom dispensers))))","non-empty sequence obligation:(threats \u003c\u003e [])","state invariant holds obligation:(((dom ranges) \u003d (dom dispensers)) \u003d\u003e ((dom ranges) \u003d (dom dispensers)))","non-empty sequence obligation:(threats \u003c\u003e [])","legal map application obligation:(id in set (dom ranges))","state invariant holds obligation:(((dom ranges) \u003d (dom dispensers)) \u003d\u003e ((dom ranges) \u003d (dom dispensers)))","enumeration map injectivity obligation:(forall m1, m2 in set {{\u003cMissileA\u003e |-\u003e [mk_(\u003cFlareOneA\u003e, 900), mk_(\u003cFlareTwoA\u003e, 500), mk_(\u003cDoNothingA\u003e, 100), mk_(\u003cFlareOneA\u003e, 500)]}, {\u003cMissileB\u003e |-\u003e [mk_(\u003cFlareTwoB\u003e, 500), mk_(\u003cFlareTwoB\u003e, 700)]}, {\u003cMissileC\u003e |-\u003e [mk_(\u003cFlareOneC\u003e, 400), mk_(\u003cDoNothingC\u003e, 100), mk_(\u003cFlareTwoC\u003e, 400), mk_(\u003cFlareOneC\u003e, 500)]}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","enumeration map injectivity obligation:(forall m1, m2 in set {{\u003cNone\u003e |-\u003e 0}, {\u003cMissileA\u003e |-\u003e 1}, {\u003cMissileB\u003e |-\u003e 2}, {\u003cMissileC\u003e |-\u003e 3}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","legal map application obligation:(forall evid:EventId, pmt:MissileType, ptime:Time \u0026 (((pmt in set (dom missilePriority)) and (pmt in set (dom responseDB))) \u003d\u003e (pmt in set (dom missilePriority))))","legal map application obligation:(forall evid:EventId, pmt:MissileType, ptime:Time \u0026 (((pmt in set (dom missilePriority)) and (pmt in set (dom responseDB))) \u003d\u003e (pmt in set (dom responseDB))))","non-empty sequence obligation:(forall evid:EventId, pmt:MissileType, ptime:Time \u0026 (((pmt in set (dom missilePriority)) and (pmt in set (dom responseDB))) \u003d\u003e ((newplan ^ [mk_(fltp, newtime)]) \u003c\u003e [])))","non-empty sequence obligation:(forall evid:EventId, pmt:MissileType, ptime:Time \u0026 (((pmt in set (dom missilePriority)) and (pmt in set (dom responseDB))) \u003d\u003e (forall curplan1:Plan, curprio2:nat, busy3:bool, aperture4:Angle, eventid5:[EventId] \u0026 (true \u003d\u003e (newplan \u003c\u003e [])))))","legal map application obligation:(forall evid:EventId, pmt:MissileType, ptime:Time \u0026 (((pmt in set (dom missilePriority)) and (pmt in set (dom responseDB))) \u003d\u003e (forall curplan1:Plan, curprio2:nat, busy3:bool, aperture4:Angle, eventid5:[EventId] \u0026 (true \u003d\u003e (pmt in set (dom missilePriority))))))","while loop termination obligation:NotYetImplemented","non-empty sequence obligation:(curplan \u003c\u003e [])","non-empty sequence obligation:(curplan \u003c\u003e [])","type invariant satisfiable obligation:(exists num:Angle \u0026 (num \u003c 360))","type compatibility obligation:(forall t:BaseThread \u0026 ((barrierCount - 1) \u003e\u003d 0))","while loop termination obligation:NotYetImplemented","legal map application obligation:(forall th in set (dom wakeUpMap) \u0026 (th in set (dom wakeUpMap)))","legal map application obligation:(forall th in set (dom wakeUpMap) \u0026 ((wakeUpMap(th) \u003c\u003e nil) \u003d\u003e (th in set (dom wakeUpMap))))","operation establishes postcondition obligation:(forall x in set (rng wakeUpMap) \u0026 ((x \u003d nil) or (x \u003e\u003d currentTime)))","state invariant holds obligation:(forall tDef:[ThreadDef] \u0026 ((dom ranges) \u003d (dom controllers)))","state invariant holds obligation:(((dom ranges) \u003d (dom controllers)) \u003d\u003e ((dom (ranges munion {nid |-\u003e (pctrl.getAperture)()})) \u003d (dom (controllers munion {nid |-\u003e pctrl}))))","state invariant holds obligation:(forall evid:EventId, pmt:MissileType, pa:Angle, pt:Time \u0026 (((dom ranges) \u003d (dom controllers)) \u003d\u003e ((dom ranges) \u003d (dom controllers))))","state invariant holds obligation:(forall evid:EventId, pmt:MissileType, pa:Angle, pt:Time \u0026 (((dom ranges) \u003d (dom controllers)) \u003d\u003e ((dom ranges) \u003d (dom controllers))))","non-empty sequence obligation:(threats \u003c\u003e [])","state invariant holds obligation:(((dom ranges) \u003d (dom controllers)) \u003d\u003e ((dom ranges) \u003d (dom controllers)))","non-empty sequence obligation:(threats \u003c\u003e [])","legal map application obligation:(id in set (dom ranges))","state invariant holds obligation:(((dom ranges) \u003d (dom controllers)) \u003d\u003e ((dom ranges) \u003d (dom controllers)))","operation call obligation:(forall text:seq of (char) \u0026 ((\"\" \u003d \"\") \u003c\u003d\u003e (\"\" \u003d nil)))"] \ No newline at end of file +["legal function application obligation:(forall fname:seq of (char), tDef:[ThreadDef] \u0026 pre_(((io.freadval))[InputTP]fname))","state invariant holds obligation:(forall fname:seq of (char), tDef:[ThreadDef] \u0026 ((dom ranges) \u003d (dom sensors)))","state invariant holds obligation:(((dom ranges) \u003d (dom sensors)) \u003d\u003e ((dom (ranges munion {id |-\u003e (psens.getAperture)()})) \u003d (dom (sensors munion {id |-\u003e psens}))))","while loop termination obligation:...","non-empty sequence obligation:(inlines \u003c\u003e [])","legal map application obligation:(id in set (dom ranges))","state invariant holds obligation:(((dom ranges) \u003d (dom sensors)) \u003d\u003e ((dom ranges) \u003d (dom sensors)))","non-empty sequence obligation:(inlines \u003c\u003e [])","state invariant holds obligation:(((dom ranges) \u003d (dom sensors)) \u003d\u003e ((dom ranges) \u003d (dom sensors)))","state invariant holds obligation:(((dom ranges) \u003d (dom sensors)) \u003d\u003e ((dom ranges) \u003d (dom sensors)))","state invariant holds obligation:(((dom ranges) \u003d (dom sensors)) \u003d\u003e ((dom ranges) \u003d (dom sensors)))","state invariant holds obligation:(forall evid:EventId, pfltp:FlareType, angle:Angle, pt1:Time, pt2:Time \u0026 (((dom ranges) \u003d (dom sensors)) \u003d\u003e ((dom ranges) \u003d (dom sensors))))","legal function application obligation:pre_(((io.writeval))[seq of (outline)]outlines)","state invariant holds obligation:(forall io1:IO, inlines2:seq of (inline), outlines3:seq of (outline), ranges4:map (nat) to ((Angle * Angle)), sensors5:map (nat) to (Sensor), busy6:bool, simtime7:Time \u0026 (((dom ranges4) \u003d (dom sensors5)) \u003d\u003e (((dom ranges4) \u003d (dom sensors5)) \u003d\u003e ((dom ranges4) \u003d (dom sensors5)))))","type compatibility obligation:is_(RESULT, (Angle * Angle))","state invariant holds obligation:(forall papp:Angle, tDef:[ThreadDef] \u0026 ((dom ranges) \u003d (dom dispensers)))","state invariant holds obligation:(((dom ranges) \u003d (dom dispensers)) \u003d\u003e ((dom (ranges munion {id |-\u003e mk_(angle, DISPENSER_APERTURE)})) \u003d (dom (dispensers munion {id |-\u003e pfldisp}))))","type compatibility obligation:is_(RESULT, (Angle * Angle))","state invariant holds obligation:(forall evid:EventId, pmt:MissileType, pa:Angle, pt:Time \u0026 (((dom ranges) \u003d (dom dispensers)) \u003d\u003e ((dom ranges) \u003d (dom dispensers))))","state invariant holds obligation:(forall evid:EventId, pmt:MissileType, pa:Angle, pt:Time \u0026 (((dom ranges) \u003d (dom dispensers)) \u003d\u003e ((dom ranges) \u003d (dom dispensers))))","non-empty sequence obligation:(threats \u003c\u003e [])","state invariant holds obligation:(((dom ranges) \u003d (dom dispensers)) \u003d\u003e ((dom ranges) \u003d (dom dispensers)))","non-empty sequence obligation:(threats \u003c\u003e [])","legal map application obligation:(id in set (dom ranges))","state invariant holds obligation:(((dom ranges) \u003d (dom dispensers)) \u003d\u003e ((dom ranges) \u003d (dom dispensers)))","enumeration map injectivity obligation:(forall m1, m2 in set {{\u003cMissileA\u003e |-\u003e [mk_(\u003cFlareOneA\u003e, 900), mk_(\u003cFlareTwoA\u003e, 500), mk_(\u003cDoNothingA\u003e, 100), mk_(\u003cFlareOneA\u003e, 500)]}, {\u003cMissileB\u003e |-\u003e [mk_(\u003cFlareTwoB\u003e, 500), mk_(\u003cFlareTwoB\u003e, 700)]}, {\u003cMissileC\u003e |-\u003e [mk_(\u003cFlareOneC\u003e, 400), mk_(\u003cDoNothingC\u003e, 100), mk_(\u003cFlareTwoC\u003e, 400), mk_(\u003cFlareOneC\u003e, 500)]}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","enumeration map injectivity obligation:(forall m1, m2 in set {{\u003cNone\u003e |-\u003e 0}, {\u003cMissileA\u003e |-\u003e 1}, {\u003cMissileB\u003e |-\u003e 2}, {\u003cMissileC\u003e |-\u003e 3}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","legal map application obligation:(forall evid:EventId, pmt:MissileType, ptime:Time \u0026 (((pmt in set (dom missilePriority)) and (pmt in set (dom responseDB))) \u003d\u003e (pmt in set (dom missilePriority))))","legal map application obligation:(forall evid:EventId, pmt:MissileType, ptime:Time \u0026 (((pmt in set (dom missilePriority)) and (pmt in set (dom responseDB))) \u003d\u003e (pmt in set (dom responseDB))))","non-empty sequence obligation:(forall evid:EventId, pmt:MissileType, ptime:Time \u0026 (((pmt in set (dom missilePriority)) and (pmt in set (dom responseDB))) \u003d\u003e ((newplan ^ [mk_(fltp, newtime)]) \u003c\u003e [])))","non-empty sequence obligation:(forall evid:EventId, pmt:MissileType, ptime:Time \u0026 (((pmt in set (dom missilePriority)) and (pmt in set (dom responseDB))) \u003d\u003e (forall curplan1:Plan, curprio2:nat, busy3:bool, aperture4:Angle, eventid5:[EventId] \u0026 (true \u003d\u003e (newplan \u003c\u003e [])))))","legal map application obligation:(forall evid:EventId, pmt:MissileType, ptime:Time \u0026 (((pmt in set (dom missilePriority)) and (pmt in set (dom responseDB))) \u003d\u003e (forall curplan1:Plan, curprio2:nat, busy3:bool, aperture4:Angle, eventid5:[EventId] \u0026 (true \u003d\u003e (pmt in set (dom missilePriority))))))","while loop termination obligation:...","non-empty sequence obligation:(curplan \u003c\u003e [])","non-empty sequence obligation:(curplan \u003c\u003e [])","type invariant satisfiable obligation:(exists num:Angle \u0026 (num \u003c 360))","type compatibility obligation:(forall t:BaseThread \u0026 ((barrierCount - 1) \u003e\u003d 0))","while loop termination obligation:...","legal map application obligation:(forall th in set (dom wakeUpMap) \u0026 (th in set (dom wakeUpMap)))","legal map application obligation:(forall th in set (dom wakeUpMap) \u0026 ((wakeUpMap(th) \u003c\u003e nil) \u003d\u003e (th in set (dom wakeUpMap))))","operation establishes postcondition obligation:(forall x in set (rng wakeUpMap) \u0026 ((x \u003d nil) or (x \u003e\u003d currentTime)))","state invariant holds obligation:(forall tDef:[ThreadDef] \u0026 ((dom ranges) \u003d (dom controllers)))","state invariant holds obligation:(((dom ranges) \u003d (dom controllers)) \u003d\u003e ((dom (ranges munion {nid |-\u003e (pctrl.getAperture)()})) \u003d (dom (controllers munion {nid |-\u003e pctrl}))))","state invariant holds obligation:(forall evid:EventId, pmt:MissileType, pa:Angle, pt:Time \u0026 (((dom ranges) \u003d (dom controllers)) \u003d\u003e ((dom ranges) \u003d (dom controllers))))","state invariant holds obligation:(forall evid:EventId, pmt:MissileType, pa:Angle, pt:Time \u0026 (((dom ranges) \u003d (dom controllers)) \u003d\u003e ((dom ranges) \u003d (dom controllers))))","non-empty sequence obligation:(threats \u003c\u003e [])","state invariant holds obligation:(((dom ranges) \u003d (dom controllers)) \u003d\u003e ((dom ranges) \u003d (dom controllers)))","non-empty sequence obligation:(threats \u003c\u003e [])","legal map application obligation:(id in set (dom ranges))","state invariant holds obligation:(((dom ranges) \u003d (dom controllers)) \u003d\u003e ((dom ranges) \u003d (dom controllers)))","operation call obligation:(forall text:seq of (char) \u0026 ((\"\" \u003d \"\") \u003c\u003d\u003e (\"\" \u003d nil)))"] \ No newline at end of file diff --git a/core/pog/src/test/resources/examples/CMSeqPP.result b/core/pog/src/test/resources/examples/CMSeqPP.result index 490be3e47f..05f17f4f86 100644 --- a/core/pog/src/test/resources/examples/CMSeqPP.result +++ b/core/pog/src/test/resources/examples/CMSeqPP.result @@ -1 +1 @@ -["legal function application obligation:(forall fname:seq of (char) \u0026 pre_(((io.freadval))[seq of (inline)]fname))","type compatibility obligation:(forall fname:seq of (char) \u0026 is_(input, seq of (inline)))","state invariant holds obligation:(forall fname:seq of (char) \u0026 ((dom ranges) \u003d (dom sensors)))","state invariant holds obligation:(((dom ranges) \u003d (dom sensors)) \u003d\u003e ((dom (ranges munion {id |-\u003e (psens.getAperture)()})) \u003d (dom (sensors munion {id |-\u003e psens}))))","while loop termination obligation:NotYetImplemented","state invariant holds obligation:(((dom ranges) \u003d (dom sensors)) \u003d\u003e ((dom ranges) \u003d (dom sensors)))","while loop termination obligation:NotYetImplemented","non-empty sequence obligation:(inlines \u003c\u003e [])","legal map application obligation:(id in set (dom ranges))","state invariant holds obligation:(((dom ranges) \u003d (dom sensors)) \u003d\u003e ((dom ranges) \u003d (dom sensors)))","non-empty sequence obligation:(inlines \u003c\u003e [])","state invariant holds obligation:(((dom ranges) \u003d (dom sensors)) \u003d\u003e ((dom ranges) \u003d (dom sensors)))","state invariant holds obligation:(((dom ranges) \u003d (dom sensors)) \u003d\u003e ((dom ranges) \u003d (dom sensors)))","state invariant holds obligation:(((dom ranges) \u003d (dom sensors)) \u003d\u003e ((dom ranges) \u003d (dom sensors)))","state invariant holds obligation:(forall newevid:EventId, pfltp:FlareType, angle:Angle, pt1:Time, pt2:Time \u0026 (((dom ranges) \u003d (dom sensors)) \u003d\u003e ((dom ranges) \u003d (dom sensors))))","legal function application obligation:pre_(((io.writeval))[seq of (outline)]outlines)","type compatibility obligation:is_(RESULT, (Angle * Angle))","type compatibility obligation:is_(RESULT, (Angle * Angle))","state invariant holds obligation:(forall papp:Angle \u0026 ((dom ranges) \u003d (dom dispensers)))","state invariant holds obligation:(((dom ranges) \u003d (dom dispensers)) \u003d\u003e ((dom (ranges munion {id |-\u003e mk_(angle, DISPENSER_APERTURE)})) \u003d (dom (dispensers munion {id |-\u003e pfldisp}))))","legal map application obligation:(id in set (dom ranges))","state invariant holds obligation:(((dom ranges) \u003d (dom dispensers)) \u003d\u003e ((dom ranges) \u003d (dom dispensers)))","type compatibility obligation:is_(RESULT, (Angle * Angle))","state invariant holds obligation:(forall evid:EventId, pmt:MissileType, pa:Angle, pt:Time \u0026 (((dom ranges) \u003d (dom dispensers)) \u003d\u003e ((dom ranges) \u003d (dom dispensers))))","state invariant holds obligation:(forall evid:EventId, pmt:MissileType, pa:Angle, pt:Time \u0026 (((dom ranges) \u003d (dom dispensers)) \u003d\u003e ((dom ranges) \u003d (dom dispensers))))","non-empty sequence obligation:(threats \u003c\u003e [])","state invariant holds obligation:(((dom ranges) \u003d (dom dispensers)) \u003d\u003e ((dom ranges) \u003d (dom dispensers)))","non-empty sequence obligation:(threats \u003c\u003e [])","legal map application obligation:(forall id in set (dom dispensers) \u0026 (id in set (dom dispensers)))","enumeration map injectivity obligation:(forall m1, m2 in set {{\u003cMissileA\u003e |-\u003e [mk_(\u003cFlareOneA\u003e, 900), mk_(\u003cFlareTwoA\u003e, 500), mk_(\u003cDoNothingA\u003e, 100), mk_(\u003cFlareOneA\u003e, 500)]}, {\u003cMissileB\u003e |-\u003e [mk_(\u003cFlareTwoB\u003e, 500), mk_(\u003cFlareTwoB\u003e, 700)]}, {\u003cMissileC\u003e |-\u003e [mk_(\u003cFlareOneC\u003e, 400), mk_(\u003cDoNothingC\u003e, 100), mk_(\u003cFlareTwoC\u003e, 400), mk_(\u003cFlareOneC\u003e, 500)]}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","enumeration map injectivity obligation:(forall m1, m2 in set {{\u003cNone\u003e |-\u003e 0}, {\u003cMissileA\u003e |-\u003e 1}, {\u003cMissileB\u003e |-\u003e 2}, {\u003cMissileC\u003e |-\u003e 3}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","type compatibility obligation:(forall ang:nat \u0026 inv_Angle(ang))","non-empty sequence obligation:(curplan \u003c\u003e [])","non-empty sequence obligation:(curplan \u003c\u003e [])","legal map application obligation:(forall evid:EventId, pmt:MissileType, ptime:Time \u0026 (((pmt in set (dom missilePriority)) and (pmt in set (dom responseDB))) \u003d\u003e (pmt in set (dom missilePriority))))","legal map application obligation:(forall evid:EventId, pmt:MissileType, ptime:Time \u0026 (((pmt in set (dom missilePriority)) and (pmt in set (dom responseDB))) \u003d\u003e (pmt in set (dom responseDB))))","non-empty sequence obligation:(forall evid:EventId, pmt:MissileType, ptime:Time \u0026 (((pmt in set (dom missilePriority)) and (pmt in set (dom responseDB))) \u003d\u003e ((newplan ^ [mk_(fltp, newtime)]) \u003c\u003e [])))","non-empty sequence obligation:(forall evid:EventId, pmt:MissileType, ptime:Time \u0026 (((pmt in set (dom missilePriority)) and (pmt in set (dom responseDB))) \u003d\u003e (forall curplan1:Plan, curprio2:nat, busy3:bool, aperture4:Angle, eventid5:[EventId] \u0026 (true \u003d\u003e (newplan \u003c\u003e [])))))","legal map application obligation:(forall evid:EventId, pmt:MissileType, ptime:Time \u0026 (((pmt in set (dom missilePriority)) and (pmt in set (dom responseDB))) \u003d\u003e (forall curplan1:Plan, curprio2:nat, busy3:bool, aperture4:Angle, eventid5:[EventId] \u0026 (true \u003d\u003e (pmt in set (dom missilePriority))))))","type compatibility obligation:is_(RESULT, (Angle * Angle))","type invariant satisfiable obligation:(exists num:Angle \u0026 (num \u003c 360))","state invariant initialized obligation:((dom {|-\u003e}) \u003d (dom {|-\u003e}))","state invariant satisfiable obligation:(exists ranges:map (nat) to ((Angle * Angle)), controllers:map (nat) to (FlareController), threats:seq of ((EventId * MissileType * Angle * Time)), busy:bool \u0026 ((dom ranges) \u003d (dom controllers)))","state invariant holds obligation:(((dom ranges) \u003d (dom controllers)) \u003d\u003e ((dom (ranges munion {nid |-\u003e (pctrl.getAperture)()})) \u003d (dom (controllers munion {nid |-\u003e pctrl}))))","legal map application obligation:(id in set (dom ranges))","state invariant holds obligation:(((dom ranges) \u003d (dom controllers)) \u003d\u003e ((dom ranges) \u003d (dom controllers)))","state invariant holds obligation:(forall evid:EventId, pmt:MissileType, pa:Angle, pt:Time \u0026 (((dom ranges) \u003d (dom controllers)) \u003d\u003e ((dom ranges) \u003d (dom controllers))))","state invariant holds obligation:(forall evid:EventId, pmt:MissileType, pa:Angle, pt:Time \u0026 (((dom ranges) \u003d (dom controllers)) \u003d\u003e ((dom ranges) \u003d (dom controllers))))","non-empty sequence obligation:(threats \u003c\u003e [])","state invariant holds obligation:(((dom ranges) \u003d (dom controllers)) \u003d\u003e ((dom ranges) \u003d (dom controllers)))","non-empty sequence obligation:(threats \u003c\u003e [])","legal map application obligation:(forall id in set (dom controllers) \u0026 (id in set (dom controllers)))","type compatibility obligation:is_(RESULT, (Angle * Angle))","operation call obligation:(forall text:seq of (char) \u0026 ((\"\" \u003d \"\") \u003c\u003d\u003e (\"\" \u003d nil)))"] \ No newline at end of file +["legal function application obligation:(forall fname:seq of (char) \u0026 pre_(((io.freadval))[seq of (inline)]fname))","type compatibility obligation:(forall fname:seq of (char) \u0026 is_(input, seq of (inline)))","state invariant holds obligation:(forall fname:seq of (char) \u0026 ((dom ranges) \u003d (dom sensors)))","state invariant holds obligation:(((dom ranges) \u003d (dom sensors)) \u003d\u003e ((dom (ranges munion {id |-\u003e (psens.getAperture)()})) \u003d (dom (sensors munion {id |-\u003e psens}))))","while loop termination obligation:...","state invariant holds obligation:(((dom ranges) \u003d (dom sensors)) \u003d\u003e ((dom ranges) \u003d (dom sensors)))","while loop termination obligation:...","non-empty sequence obligation:(inlines \u003c\u003e [])","legal map application obligation:(id in set (dom ranges))","state invariant holds obligation:(((dom ranges) \u003d (dom sensors)) \u003d\u003e ((dom ranges) \u003d (dom sensors)))","non-empty sequence obligation:(inlines \u003c\u003e [])","state invariant holds obligation:(((dom ranges) \u003d (dom sensors)) \u003d\u003e ((dom ranges) \u003d (dom sensors)))","state invariant holds obligation:(((dom ranges) \u003d (dom sensors)) \u003d\u003e ((dom ranges) \u003d (dom sensors)))","state invariant holds obligation:(((dom ranges) \u003d (dom sensors)) \u003d\u003e ((dom ranges) \u003d (dom sensors)))","state invariant holds obligation:(forall newevid:EventId, pfltp:FlareType, angle:Angle, pt1:Time, pt2:Time \u0026 (((dom ranges) \u003d (dom sensors)) \u003d\u003e ((dom ranges) \u003d (dom sensors))))","legal function application obligation:pre_(((io.writeval))[seq of (outline)]outlines)","type compatibility obligation:is_(RESULT, (Angle * Angle))","type compatibility obligation:is_(RESULT, (Angle * Angle))","state invariant holds obligation:(forall papp:Angle \u0026 ((dom ranges) \u003d (dom dispensers)))","state invariant holds obligation:(((dom ranges) \u003d (dom dispensers)) \u003d\u003e ((dom (ranges munion {id |-\u003e mk_(angle, DISPENSER_APERTURE)})) \u003d (dom (dispensers munion {id |-\u003e pfldisp}))))","legal map application obligation:(id in set (dom ranges))","state invariant holds obligation:(((dom ranges) \u003d (dom dispensers)) \u003d\u003e ((dom ranges) \u003d (dom dispensers)))","type compatibility obligation:is_(RESULT, (Angle * Angle))","state invariant holds obligation:(forall evid:EventId, pmt:MissileType, pa:Angle, pt:Time \u0026 (((dom ranges) \u003d (dom dispensers)) \u003d\u003e ((dom ranges) \u003d (dom dispensers))))","state invariant holds obligation:(forall evid:EventId, pmt:MissileType, pa:Angle, pt:Time \u0026 (((dom ranges) \u003d (dom dispensers)) \u003d\u003e ((dom ranges) \u003d (dom dispensers))))","non-empty sequence obligation:(threats \u003c\u003e [])","state invariant holds obligation:(((dom ranges) \u003d (dom dispensers)) \u003d\u003e ((dom ranges) \u003d (dom dispensers)))","non-empty sequence obligation:(threats \u003c\u003e [])","legal map application obligation:(forall id in set (dom dispensers) \u0026 (id in set (dom dispensers)))","enumeration map injectivity obligation:(forall m1, m2 in set {{\u003cMissileA\u003e |-\u003e [mk_(\u003cFlareOneA\u003e, 900), mk_(\u003cFlareTwoA\u003e, 500), mk_(\u003cDoNothingA\u003e, 100), mk_(\u003cFlareOneA\u003e, 500)]}, {\u003cMissileB\u003e |-\u003e [mk_(\u003cFlareTwoB\u003e, 500), mk_(\u003cFlareTwoB\u003e, 700)]}, {\u003cMissileC\u003e |-\u003e [mk_(\u003cFlareOneC\u003e, 400), mk_(\u003cDoNothingC\u003e, 100), mk_(\u003cFlareTwoC\u003e, 400), mk_(\u003cFlareOneC\u003e, 500)]}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","enumeration map injectivity obligation:(forall m1, m2 in set {{\u003cNone\u003e |-\u003e 0}, {\u003cMissileA\u003e |-\u003e 1}, {\u003cMissileB\u003e |-\u003e 2}, {\u003cMissileC\u003e |-\u003e 3}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","type compatibility obligation:(forall ang:nat \u0026 inv_Angle(ang))","non-empty sequence obligation:(curplan \u003c\u003e [])","non-empty sequence obligation:(curplan \u003c\u003e [])","legal map application obligation:(forall evid:EventId, pmt:MissileType, ptime:Time \u0026 (((pmt in set (dom missilePriority)) and (pmt in set (dom responseDB))) \u003d\u003e (pmt in set (dom missilePriority))))","legal map application obligation:(forall evid:EventId, pmt:MissileType, ptime:Time \u0026 (((pmt in set (dom missilePriority)) and (pmt in set (dom responseDB))) \u003d\u003e (pmt in set (dom responseDB))))","non-empty sequence obligation:(forall evid:EventId, pmt:MissileType, ptime:Time \u0026 (((pmt in set (dom missilePriority)) and (pmt in set (dom responseDB))) \u003d\u003e ((newplan ^ [mk_(fltp, newtime)]) \u003c\u003e [])))","non-empty sequence obligation:(forall evid:EventId, pmt:MissileType, ptime:Time \u0026 (((pmt in set (dom missilePriority)) and (pmt in set (dom responseDB))) \u003d\u003e (forall curplan1:Plan, curprio2:nat, busy3:bool, aperture4:Angle, eventid5:[EventId] \u0026 (true \u003d\u003e (newplan \u003c\u003e [])))))","legal map application obligation:(forall evid:EventId, pmt:MissileType, ptime:Time \u0026 (((pmt in set (dom missilePriority)) and (pmt in set (dom responseDB))) \u003d\u003e (forall curplan1:Plan, curprio2:nat, busy3:bool, aperture4:Angle, eventid5:[EventId] \u0026 (true \u003d\u003e (pmt in set (dom missilePriority))))))","type compatibility obligation:is_(RESULT, (Angle * Angle))","type invariant satisfiable obligation:(exists num:Angle \u0026 (num \u003c 360))","state invariant initialized obligation:((dom {|-\u003e}) \u003d (dom {|-\u003e}))","state invariant satisfiable obligation:(exists ranges:map (nat) to ((Angle * Angle)), controllers:map (nat) to (FlareController), threats:seq of ((EventId * MissileType * Angle * Time)), busy:bool \u0026 ((dom ranges) \u003d (dom controllers)))","state invariant holds obligation:(((dom ranges) \u003d (dom controllers)) \u003d\u003e ((dom (ranges munion {nid |-\u003e (pctrl.getAperture)()})) \u003d (dom (controllers munion {nid |-\u003e pctrl}))))","legal map application obligation:(id in set (dom ranges))","state invariant holds obligation:(((dom ranges) \u003d (dom controllers)) \u003d\u003e ((dom ranges) \u003d (dom controllers)))","state invariant holds obligation:(forall evid:EventId, pmt:MissileType, pa:Angle, pt:Time \u0026 (((dom ranges) \u003d (dom controllers)) \u003d\u003e ((dom ranges) \u003d (dom controllers))))","state invariant holds obligation:(forall evid:EventId, pmt:MissileType, pa:Angle, pt:Time \u0026 (((dom ranges) \u003d (dom controllers)) \u003d\u003e ((dom ranges) \u003d (dom controllers))))","non-empty sequence obligation:(threats \u003c\u003e [])","state invariant holds obligation:(((dom ranges) \u003d (dom controllers)) \u003d\u003e ((dom ranges) \u003d (dom controllers)))","non-empty sequence obligation:(threats \u003c\u003e [])","legal map application obligation:(forall id in set (dom controllers) \u0026 (id in set (dom controllers)))","type compatibility obligation:is_(RESULT, (Angle * Angle))","operation call obligation:(forall text:seq of (char) \u0026 ((\"\" \u003d \"\") \u003c\u003d\u003e (\"\" \u003d nil)))"] \ No newline at end of file diff --git a/core/pog/src/test/resources/examples/ChessWayRT.result b/core/pog/src/test/resources/examples/ChessWayRT.result index 796866206b..eab37c483c 100644 --- a/core/pog/src/test/resources/examples/ChessWayRT.result +++ b/core/pog/src/test/resources/examples/ChessWayRT.result @@ -1 +1 @@ -["type compatibility obligation:(forall prad:real \u0026 (let degrees:int \u003d (floor ((prad * MATH`pi) / 180)) in (degrees mod 360) \u003e\u003d 0))","non-zero obligation:(World`SIM_RESOLUTION \u003c\u003e 0)","type compatibility obligation:(forall init:real, file:seq of (char) \u0026 is_(file, seq1 of (char)))","legal sequence application obligation:(((line \u003c\u003d lines) and (next_setpoint \u003d nil)) \u003d\u003e (forall filename1:seq of (char), lines2:int, line3:int, setpoint4:real, next_setpoint5:[(real * real)] \u0026 (true \u003d\u003e (1 in set (inds vals)))))","legal sequence application obligation:(((line \u003c\u003d lines) and (next_setpoint \u003d nil)) \u003d\u003e (forall filename1:seq of (char), lines2:int, line3:int, setpoint4:real, next_setpoint5:[(real * real)] \u0026 (true \u003d\u003e (2 in set (inds vals)))))","operation call obligation:((line \u003c\u003d lines) and (next_setpoint \u003d nil))","non-zero obligation:(forall fname:seq1 of (char) \u0026 (true \u003d\u003e (forall cosim1:bool, finish2:bool \u0026 (true \u003d\u003e (true \u003d\u003e (SIM_RESOLUTION \u003c\u003e 0))))))","legal sequence application obligation:(forall tcb:map (seq of (char)) to (seq1 of (tCtCurve)) \u0026 (forall tc in set (rng tcb) \u0026 (forall i in set ((inds tc) \\ {1}) \u0026 ((i - 1) in set (inds tc)))))","legal sequence application obligation:(forall tcb:map (seq of (char)) to (seq1 of (tCtCurve)) \u0026 (forall tc in set (rng tcb) \u0026 (forall i in set ((inds tc) \\ {1}) \u0026 (i in set (inds tc)))))","type invariant satisfiable obligation:(exists tcb:tCtBehavior \u0026 (forall tc in set (rng tcb) \u0026 (forall i in set ((inds tc) \\ {1}) \u0026 ((tc((i - 1)).#1) \u003c (tc(i).#1)))))","type compatibility obligation:inv_tCtBehavior({|-\u003e})","type compatibility obligation:(forall pctvar:seq of (char), pfname:seq of (char) \u0026 ((pctvar in set reserved) \u003d\u003e (true \u003d\u003e is_(pfname, seq1 of (char)))))","while loop termination obligation:NotYetImplemented","legal sequence application obligation:(forall pctvar:seq of (char), pfname:seq of (char) \u0026 ((pctvar in set reserved) \u003d\u003e (true \u003d\u003e (true \u003d\u003e (1 in set (inds vs))))))","legal sequence application obligation:(forall pctvar:seq of (char), pfname:seq of (char) \u0026 ((pctvar in set reserved) \u003d\u003e (true \u003d\u003e (true \u003d\u003e (1 in set (inds vs))))))","legal sequence application obligation:(forall pctvar:seq of (char), pfname:seq of (char) \u0026 ((pctvar in set reserved) \u003d\u003e (true \u003d\u003e (true \u003d\u003e (2 in set (inds vs))))))","legal sequence application obligation:(forall pctvar:seq of (char), pfname:seq of (char) \u0026 ((pctvar in set reserved) \u003d\u003e (true \u003d\u003e (true \u003d\u003e (2 in set (inds vs))))))","legal sequence application obligation:(forall pctvar:seq of (char), pfname:seq of (char) \u0026 ((pctvar in set reserved) \u003d\u003e (true \u003d\u003e (true \u003d\u003e ((len (lctc ^ [mk_((cx + 0.5), cy, 0.0)])) in set (inds (lctc ^ [mk_((cx + 0.5), cy, 0.0)])))))))","type compatibility obligation:(forall pctvar:seq of (char), pfname:seq of (char) \u0026 ((pctvar in set reserved) \u003d\u003e (true \u003d\u003e (true \u003d\u003e (inv_tCtBehavior((mCtBehavior ++ {pctvar |-\u003e lctc})) and is_((mCtBehavior ++ {pctvar |-\u003e lctc}), map (seq of (char)) to (seq1 of (tCtCurve))))))))","type compatibility obligation:(forall pfname:seq of (char) \u0026 (true \u003d\u003e (true \u003d\u003e (inv_tCtBehavior(rv) and is_(rv, map (seq of (char)) to (seq1 of (tCtCurve)))))))","legal map application obligation:(forall ptime:real \u0026 (iname in set (dom mCtBehavior)))","operation call obligation:(forall ptime:real \u0026 (ptime \u003e\u003d ptime))","type compatibility obligation:(forall ptime:real \u0026 (forall mCtBehavior1:tCtBehavior, debug2:nat, mWorld3:World, mMaxSimTime4:nat, mLeftWheel5:Wheel, mRightWheel6:Wheel, mLeftHall7:HallSensor, mRightHall8:HallSensor, mUser9:User, ain10:ISensorReal, vin11:ISensorReal, aout12:IActuatorReal, vout13:IActuatorReal, mValues14:map (seq of (char)) to (real) \u0026 (true \u003d\u003e inv_tCtBehavior((mCtBehavior ++ {iname |-\u003e (tl behaviors)})))))","operation call obligation:(forall ptime:real \u0026 (forall mCtBehavior1:tCtBehavior, debug2:nat, mWorld3:World, mMaxSimTime4:nat, mLeftWheel5:Wheel, mRightWheel6:Wheel, mLeftHall7:HallSensor, mRightHall8:HallSensor, mUser9:User, ain10:ISensorReal, vin11:ISensorReal, aout12:IActuatorReal, vout13:IActuatorReal, mValues14:map (seq of (char)) to (real) \u0026 (true \u003d\u003e (ptime \u003e\u003d ptime))))","operation call obligation:(forall ptime:real \u0026 (forall mCtBehavior1:tCtBehavior, debug2:nat, mWorld3:World, mMaxSimTime4:nat, mLeftWheel5:Wheel, mRightWheel6:Wheel, mLeftHall7:HallSensor, mRightHall8:HallSensor, mUser9:User, ain10:ISensorReal, vin11:ISensorReal, aout12:IActuatorReal, vout13:IActuatorReal, mValues14:map (seq of (char)) to (real) \u0026 (true \u003d\u003e (forall mCtBehavior15:tCtBehavior, debug16:nat, mWorld17:World, mMaxSimTime18:nat, mLeftWheel19:Wheel, mRightWheel20:Wheel, mLeftHall21:HallSensor, mRightHall22:HallSensor, mUser23:User, ain24:ISensorReal, vin25:ISensorReal, aout26:IActuatorReal, vout27:IActuatorReal, mValues28:map (seq of (char)) to (real) \u0026 (true \u003d\u003e (ptime \u003e\u003d ptime))))))","operation call obligation:(forall ptime:real, pname:seq of (char), mk_(ltime, lvalue, ldir):tCtCurve \u0026 ((ptime \u003e\u003d ltime) \u003d\u003e (pname in set reserved)))","type compatibility obligation:is_(ChessWay`acc_in, ISensorReal)","type compatibility obligation:is_(ChessWay`vel_in, ISensorReal)","type compatibility obligation:is_(ChessWay`acc_out, IActuatorReal)","type compatibility obligation:is_(ChessWay`vel_out, IActuatorReal)","legal map application obligation:(forall pName:seq of (char) \u0026 (pName in set (dom mValues)))","non-zero obligation:(World`SIM_RESOLUTION \u003c\u003e 0)","legal map application obligation:(true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (pKey in set (dom mValues)))))","non-zero obligation:(World`SIM_RESOLUTION \u003c\u003e 0)","non-zero obligation:((not (dt \u003d 0)) \u003d\u003e (dt \u003c\u003e 0))","non-zero obligation:(forall err:real \u0026 (tauI \u003c\u003e 0))","non-zero obligation:(forall err:real \u0026 ((sampletime + (tauD * beta)) \u003c\u003e 0))","operation call obligation:(forall k_:real, tauI_:real, tauD_:real \u0026 (((tauI_ \u003c\u003e 0) and (tauD_ \u003c\u003e 0)) \u003d\u003e ((k_ \u003c\u003e 0) and ((k_ \u003c\u003e 0) and ((k_ \u003e 0) and (k_ \u003c\u003d 1))))))","operation call obligation:((DEF_K \u003c\u003e 0) and ((DEF_K \u003c\u003e 0) and ((DEF_K \u003e 0) and (DEF_K \u003c\u003d 1))))","non-zero obligation:(forall err:real \u0026 ((sampletime + (tauD * beta)) \u003c\u003e 0))","non-zero obligation:(forall err:real \u0026 (tauI \u003c\u003e 0))","operation call obligation:(forall text:seq of (char) \u0026 ((\"\" \u003d \"\") \u003c\u003d\u003e (\"\" \u003d nil)))","non-zero obligation:(forall a:real \u0026 ((a \u003c\u003e 0) \u003d\u003e (a \u003c\u003e 0)))"] \ No newline at end of file +["type compatibility obligation:(forall prad:real \u0026 (let degrees:int \u003d (floor ((prad * MATH`pi) / 180)) in (degrees mod 360) \u003e\u003d 0))","non-zero obligation:(World`SIM_RESOLUTION \u003c\u003e 0)","type compatibility obligation:(forall init:real, file:seq of (char) \u0026 is_(file, seq1 of (char)))","legal sequence application obligation:(((line \u003c\u003d lines) and (next_setpoint \u003d nil)) \u003d\u003e (forall filename1:seq of (char), lines2:int, line3:int, setpoint4:real, next_setpoint5:[(real * real)] \u0026 (true \u003d\u003e (1 in set (inds vals)))))","legal sequence application obligation:(((line \u003c\u003d lines) and (next_setpoint \u003d nil)) \u003d\u003e (forall filename1:seq of (char), lines2:int, line3:int, setpoint4:real, next_setpoint5:[(real * real)] \u0026 (true \u003d\u003e (2 in set (inds vals)))))","operation call obligation:((line \u003c\u003d lines) and (next_setpoint \u003d nil))","non-zero obligation:(forall fname:seq1 of (char) \u0026 (true \u003d\u003e (forall cosim1:bool, finish2:bool \u0026 (true \u003d\u003e (true \u003d\u003e (SIM_RESOLUTION \u003c\u003e 0))))))","legal sequence application obligation:(forall tcb:map (seq of (char)) to (seq1 of (tCtCurve)) \u0026 (forall tc in set (rng tcb) \u0026 (forall i in set ((inds tc) \\ {1}) \u0026 ((i - 1) in set (inds tc)))))","legal sequence application obligation:(forall tcb:map (seq of (char)) to (seq1 of (tCtCurve)) \u0026 (forall tc in set (rng tcb) \u0026 (forall i in set ((inds tc) \\ {1}) \u0026 (i in set (inds tc)))))","type invariant satisfiable obligation:(exists tcb:tCtBehavior \u0026 (forall tc in set (rng tcb) \u0026 (forall i in set ((inds tc) \\ {1}) \u0026 ((tc((i - 1)).#1) \u003c (tc(i).#1)))))","type compatibility obligation:inv_tCtBehavior({|-\u003e})","type compatibility obligation:(forall pctvar:seq of (char), pfname:seq of (char) \u0026 ((pctvar in set reserved) \u003d\u003e (true \u003d\u003e is_(pfname, seq1 of (char)))))","while loop termination obligation:...","legal sequence application obligation:(forall pctvar:seq of (char), pfname:seq of (char) \u0026 ((pctvar in set reserved) \u003d\u003e (true \u003d\u003e (true \u003d\u003e (1 in set (inds vs))))))","legal sequence application obligation:(forall pctvar:seq of (char), pfname:seq of (char) \u0026 ((pctvar in set reserved) \u003d\u003e (true \u003d\u003e (true \u003d\u003e (1 in set (inds vs))))))","legal sequence application obligation:(forall pctvar:seq of (char), pfname:seq of (char) \u0026 ((pctvar in set reserved) \u003d\u003e (true \u003d\u003e (true \u003d\u003e (2 in set (inds vs))))))","legal sequence application obligation:(forall pctvar:seq of (char), pfname:seq of (char) \u0026 ((pctvar in set reserved) \u003d\u003e (true \u003d\u003e (true \u003d\u003e (2 in set (inds vs))))))","legal sequence application obligation:(forall pctvar:seq of (char), pfname:seq of (char) \u0026 ((pctvar in set reserved) \u003d\u003e (true \u003d\u003e (true \u003d\u003e ((len (lctc ^ [mk_((cx + 0.5), cy, 0.0)])) in set (inds (lctc ^ [mk_((cx + 0.5), cy, 0.0)])))))))","type compatibility obligation:(forall pctvar:seq of (char), pfname:seq of (char) \u0026 ((pctvar in set reserved) \u003d\u003e (true \u003d\u003e (true \u003d\u003e (inv_tCtBehavior((mCtBehavior ++ {pctvar |-\u003e lctc})) and is_((mCtBehavior ++ {pctvar |-\u003e lctc}), map (seq of (char)) to (seq1 of (tCtCurve))))))))","type compatibility obligation:(forall pfname:seq of (char) \u0026 (true \u003d\u003e (true \u003d\u003e (inv_tCtBehavior(rv) and is_(rv, map (seq of (char)) to (seq1 of (tCtCurve)))))))","legal map application obligation:(forall ptime:real \u0026 (iname in set (dom mCtBehavior)))","operation call obligation:(forall ptime:real \u0026 (ptime \u003e\u003d ptime))","type compatibility obligation:(forall ptime:real \u0026 (forall mCtBehavior1:tCtBehavior, debug2:nat, mWorld3:World, mMaxSimTime4:nat, mLeftWheel5:Wheel, mRightWheel6:Wheel, mLeftHall7:HallSensor, mRightHall8:HallSensor, mUser9:User, ain10:ISensorReal, vin11:ISensorReal, aout12:IActuatorReal, vout13:IActuatorReal, mValues14:map (seq of (char)) to (real) \u0026 (true \u003d\u003e inv_tCtBehavior((mCtBehavior ++ {iname |-\u003e (tl behaviors)})))))","operation call obligation:(forall ptime:real \u0026 (forall mCtBehavior1:tCtBehavior, debug2:nat, mWorld3:World, mMaxSimTime4:nat, mLeftWheel5:Wheel, mRightWheel6:Wheel, mLeftHall7:HallSensor, mRightHall8:HallSensor, mUser9:User, ain10:ISensorReal, vin11:ISensorReal, aout12:IActuatorReal, vout13:IActuatorReal, mValues14:map (seq of (char)) to (real) \u0026 (true \u003d\u003e (ptime \u003e\u003d ptime))))","operation call obligation:(forall ptime:real \u0026 (forall mCtBehavior1:tCtBehavior, debug2:nat, mWorld3:World, mMaxSimTime4:nat, mLeftWheel5:Wheel, mRightWheel6:Wheel, mLeftHall7:HallSensor, mRightHall8:HallSensor, mUser9:User, ain10:ISensorReal, vin11:ISensorReal, aout12:IActuatorReal, vout13:IActuatorReal, mValues14:map (seq of (char)) to (real) \u0026 (true \u003d\u003e (forall mCtBehavior15:tCtBehavior, debug16:nat, mWorld17:World, mMaxSimTime18:nat, mLeftWheel19:Wheel, mRightWheel20:Wheel, mLeftHall21:HallSensor, mRightHall22:HallSensor, mUser23:User, ain24:ISensorReal, vin25:ISensorReal, aout26:IActuatorReal, vout27:IActuatorReal, mValues28:map (seq of (char)) to (real) \u0026 (true \u003d\u003e (ptime \u003e\u003d ptime))))))","operation call obligation:(forall ptime:real, pname:seq of (char), mk_(ltime, lvalue, ldir):tCtCurve \u0026 ((ptime \u003e\u003d ltime) \u003d\u003e (pname in set reserved)))","type compatibility obligation:is_(ChessWay`acc_in, ISensorReal)","type compatibility obligation:is_(ChessWay`vel_in, ISensorReal)","type compatibility obligation:is_(ChessWay`acc_out, IActuatorReal)","type compatibility obligation:is_(ChessWay`vel_out, IActuatorReal)","legal map application obligation:(forall pName:seq of (char) \u0026 (pName in set (dom mValues)))","non-zero obligation:(World`SIM_RESOLUTION \u003c\u003e 0)","legal map application obligation:(true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (pKey in set (dom mValues)))))","non-zero obligation:(World`SIM_RESOLUTION \u003c\u003e 0)","non-zero obligation:((not (dt \u003d 0)) \u003d\u003e (dt \u003c\u003e 0))","non-zero obligation:(forall err:real \u0026 (tauI \u003c\u003e 0))","non-zero obligation:(forall err:real \u0026 ((sampletime + (tauD * beta)) \u003c\u003e 0))","operation call obligation:(forall k_:real, tauI_:real, tauD_:real \u0026 (((tauI_ \u003c\u003e 0) and (tauD_ \u003c\u003e 0)) \u003d\u003e ((k_ \u003c\u003e 0) and ((k_ \u003c\u003e 0) and ((k_ \u003e 0) and (k_ \u003c\u003d 1))))))","operation call obligation:((DEF_K \u003c\u003e 0) and ((DEF_K \u003c\u003e 0) and ((DEF_K \u003e 0) and (DEF_K \u003c\u003d 1))))","non-zero obligation:(forall err:real \u0026 ((sampletime + (tauD * beta)) \u003c\u003e 0))","non-zero obligation:(forall err:real \u0026 (tauI \u003c\u003e 0))","operation call obligation:(forall text:seq of (char) \u0026 ((\"\" \u003d \"\") \u003c\u003d\u003e (\"\" \u003d nil)))","non-zero obligation:(forall a:real \u0026 ((a \u003c\u003e 0) \u003d\u003e (a \u003c\u003e 0)))"] \ No newline at end of file diff --git a/core/pog/src/test/resources/examples/CodegenPP.result b/core/pog/src/test/resources/examples/CodegenPP.result index d3c66ae4d1..4c025c219b 100644 --- a/core/pog/src/test/resources/examples/CodegenPP.result +++ b/core/pog/src/test/resources/examples/CodegenPP.result @@ -1 +1 @@ -["state invariant initialized obligation:((card (dom {|-\u003e})) \u003d (card (rng {|-\u003e})))","state invariant satisfiable obligation:(exists typeDefs:seq of (SimpleTypeDefinition), context:map (seq of (char)) to (seq of (char)), varDecls:seq of (GiraffeVariableDeclStatement), uid:nat1 \u0026 ((card (dom context)) \u003d (card (rng context))))","state invariant holds obligation:(((card (dom context)) \u003d (card (rng context))) \u003d\u003e ((card (dom context)) \u003d (card (rng context))))","legal function application obligation:pre_((util.iToS)res)","operation establishes postcondition obligation:(RESULT not in set (rng context))","while loop termination obligation:NotYetImplemented","operation establishes postcondition obligation:(RESULT not in set (dom context))","legal sequence application obligation:(forall programName:seq of (char), spec:SimpleSpecification \u0026 ((((len programName) \u003e 0) and (programName(1) not in set {\u00270\u0027, \u00271\u0027, \u00272\u0027, \u00273\u0027, \u00274\u0027, \u00275\u0027, \u00276\u0027, \u00277\u0027, \u00278\u0027, \u00279\u0027})) \u003d\u003e (((len programName) \u003e 0) \u003d\u003e (1 in set (inds programName)))))","legal sequence application obligation:(forall programName:seq of (char), spec:SimpleSpecification \u0026 ((((len programName) \u003e 0) and (programName(1) not in set {\u00270\u0027, \u00271\u0027, \u00272\u0027, \u00273\u0027, \u00274\u0027, \u00275\u0027, \u00276\u0027, \u00277\u0027, \u00278\u0027, \u00279\u0027})) \u003d\u003e (forall i in set (inds defs) \u0026 (isofclass(SimpleFunctionDefinition,defs(i)) \u003d\u003e (i in set (inds defs))))))","legal sequence application obligation:(forall programName:seq of (char), spec:SimpleSpecification \u0026 ((((len programName) \u003e 0) and (programName(1) not in set {\u00270\u0027, \u00271\u0027, \u00272\u0027, \u00273\u0027, \u00274\u0027, \u00275\u0027, \u00276\u0027, \u00277\u0027, \u00278\u0027, \u00279\u0027})) \u003d\u003e (forall i in set (inds defs) \u0026 (i in set (inds defs)))))","state invariant holds obligation:(forall programName:seq of (char), spec:SimpleSpecification \u0026 ((((len programName) \u003e 0) and (programName(1) not in set {\u00270\u0027, \u00271\u0027, \u00272\u0027, \u00273\u0027, \u00274\u0027, \u00275\u0027, \u00276\u0027, \u00277\u0027, \u00278\u0027, \u00279\u0027})) \u003d\u003e (((card (dom context)) \u003d (card (rng context))) \u003d\u003e ((card (dom context)) \u003d (card (rng context))))))","legal sequence application obligation:(forall programName:seq of (char), spec:SimpleSpecification \u0026 ((((len programName) \u003e 0) and (programName(1) not in set {\u00270\u0027, \u00271\u0027, \u00272\u0027, \u00273\u0027, \u00274\u0027, \u00275\u0027, \u00276\u0027, \u00277\u0027, \u00278\u0027, \u00279\u0027})) \u003d\u003e (forall i in set (inds defs) \u0026 (isofclass(SimpleTypeDefinition,defs(i)) \u003d\u003e (i in set (inds defs))))))","legal sequence application obligation:(forall programName:seq of (char), spec:SimpleSpecification \u0026 ((((len programName) \u003e 0) and (programName(1) not in set {\u00270\u0027, \u00271\u0027, \u00272\u0027, \u00273\u0027, \u00274\u0027, \u00275\u0027, \u00276\u0027, \u00277\u0027, \u00278\u0027, \u00279\u0027})) \u003d\u003e (forall i in set (inds defs) \u0026 (i in set (inds defs)))))","type compatibility obligation:(forall programName:seq of (char), spec:SimpleSpecification \u0026 ((((len programName) \u003e 0) and (programName(1) not in set {\u00270\u0027, \u00271\u0027, \u00272\u0027, \u00273\u0027, \u00274\u0027, \u00275\u0027, \u00276\u0027, \u00277\u0027, \u00278\u0027, \u00279\u0027})) \u003d\u003e is_([defs(i) | i in set (inds defs) \u0026 isofclass(SimpleTypeDefinition,defs(i))], seq of (SimpleTypeDefinition))))","legal sequence application obligation:(forall func:SimpleFunctionDefinition \u0026 (((varDecls \u003d []) and (context \u003d {|-\u003e})) \u003d\u003e (forall i in set (inds defs) \u0026 (i in set (inds defs)))))","type compatibility obligation:(forall func:SimpleFunctionDefinition \u0026 (((varDecls \u003d []) and (context \u003d {|-\u003e})) \u003d\u003e is_(Compile(GetType((func.getBody)())), GiraffeType)))","state invariant holds obligation:(forall func:SimpleFunctionDefinition \u0026 (((varDecls \u003d []) and (context \u003d {|-\u003e})) \u003d\u003e (((card (dom context)) \u003d (card (rng context))) \u003d\u003e ((card (dom context)) \u003d (card (rng context))))))","operation establishes postcondition obligation:(forall func:SimpleFunctionDefinition \u0026 (((varDecls \u003d []) and (context \u003d {|-\u003e})) \u003d\u003e (([] \u003d []) and (context \u003d {|-\u003e}))))","type compatibility obligation:(forall param:SimpleParameter \u0026 is_(Compile((param.getType)()), GiraffeType))","type compatibility obligation:(forall type:SimpleType \u0026 is_(type, SimpleIdentifier))","type compatibility obligation:(forall type:SimpleType \u0026 is_(type, SimpleBasicType))","operation establishes postcondition obligation:(forall type:SimpleType \u0026 (RESULT \u003c\u003e nil))","type compatibility obligation:(forall exp:SimpleExpression \u0026 is_(exp, SimpleIntegerLiteralExpression))","type compatibility obligation:(forall exp:SimpleExpression \u0026 is_(exp, SimpleBinaryExpression))","type compatibility obligation:(forall exp:SimpleExpression \u0026 is_(exp, SimpleCasesExpression))","type compatibility obligation:(forall exp:SimpleExpression \u0026 is_(exp, SimpleVariableExpression))","legal map application obligation:(forall exp:SimpleExpression \u0026 ((name.getName)() in set (dom context)))","type compatibility obligation:(forall exp:SimpleExpression \u0026 is_(exp, SimpleLetExpression))","type compatibility obligation:(forall exp:SimpleExpression \u0026 is_(exp, SimpleIfExpression))","operation establishes postcondition obligation:(forall exp:SimpleExpression \u0026 (RESULT \u003c\u003e nil))","non-empty sequence obligation:(forall e:SimpleCasesExpression \u0026 ((not (e.hasDeflt)()) \u003d\u003e ((not ((e.getAlts)() \u003d [])) \u003d\u003e ((e.getAlts)() \u003c\u003e []))))","non-empty sequence obligation:(forall e:SimpleCasesExpression \u0026 ((not (e.hasDeflt)()) \u003d\u003e ((not ((e.getAlts)() \u003d [])) \u003d\u003e ((e.getAlts)() \u003c\u003e []))))","legal sequence application obligation:(forall e:SimpleCasesExpression \u0026 ((not (e.hasDeflt)()) \u003d\u003e ((not ((e.getAlts)() \u003d [])) \u003d\u003e (forall i in set (inds rest) \u0026 (i in set (inds rest))))))","legal sequence application obligation:(forall e:SimpleCasesExpression \u0026 ((not (e.hasDeflt)()) \u003d\u003e ((not ((e.getAlts)() \u003d [])) \u003d\u003e (forall i in set (inds rest) \u0026 (i in set (inds rest))))))","type compatibility obligation:(forall e:SimpleCasesExpression \u0026 ((not (e.hasDeflt)()) \u003d\u003e is_(RESULT, GiraffeExpression)))","type compatibility obligation:(forall letExp:SimpleLetExpression \u0026 (((letExp.getDefs)() \u003c\u003e []) \u003d\u003e is_(Compile(type), GiraffeType)))","type compatibility obligation:(forall letExp:SimpleLetExpression \u0026 (((letExp.getDefs)() \u003c\u003e []) \u003d\u003e is_(Compile((x.getValue)()), GiraffeExpression)))","state invariant holds obligation:(forall letExp:SimpleLetExpression \u0026 (((letExp.getDefs)() \u003c\u003e []) \u003d\u003e (((card (dom context)) \u003d (card (rng context))) \u003d\u003e ((card (dom (context ++ {name |-\u003e newName}))) \u003d (card (rng (context ++ {name |-\u003e newName})))))))","state invariant holds obligation:(forall letExp:SimpleLetExpression \u0026 (((letExp.getDefs)() \u003c\u003e []) \u003d\u003e (((card (dom (context ++ {name |-\u003e newName}))) \u003d (card (rng (context ++ {name |-\u003e newName})))) \u003d\u003e ((card (dom (context ++ {name |-\u003e newName}))) \u003d (card (rng (context ++ {name |-\u003e newName})))))))","type compatibility obligation:(forall letExp:SimpleLetExpression \u0026 (((letExp.getDefs)() \u003c\u003e []) \u003d\u003e is_(Compile((letExp.getBody)()), GiraffeExpression)))","state invariant holds obligation:(forall letExp:SimpleLetExpression \u0026 (((letExp.getDefs)() \u003c\u003e []) \u003d\u003e (((card (dom (context ++ {name |-\u003e newName}))) \u003d (card (rng (context ++ {name |-\u003e newName})))) \u003d\u003e ((card (dom oldContext)) \u003d (card (rng oldContext))))))","type compatibility obligation:(forall op:SimpleBinaryOperator, lhs:SimpleExpression, rhs:SimpleExpression \u0026 is_(Compile(lhs), GiraffeExpression))","type compatibility obligation:(forall op:SimpleBinaryOperator, lhs:SimpleExpression, rhs:SimpleExpression \u0026 is_(Compile(rhs), GiraffeExpression))","type compatibility obligation:(forall op:SimpleBinaryOperator, lhs:SimpleExpression, rhs:SimpleExpression \u0026 is_(Compile(lhs), GiraffeExpression))","type compatibility obligation:(forall op:SimpleBinaryOperator, lhs:SimpleExpression, rhs:SimpleExpression \u0026 is_(Compile(rhs), GiraffeExpression))","operation establishes postcondition obligation:(forall op:SimpleBinaryOperator, lhs:SimpleExpression, rhs:SimpleExpression \u0026 (RESULT \u003c\u003e nil))","type compatibility obligation:(forall selif:SimpleIfExpression \u0026 is_(Compile((selif.getTest)()), GiraffeExpression))","type compatibility obligation:(forall selif:SimpleIfExpression \u0026 is_(Compile((selif.getThn)()), GiraffeExpression))","non-empty sequence obligation:(forall elsif:seq of (SimpleElseIfExpression), els:SimpleExpression \u0026 ((not (elsif \u003d [])) \u003d\u003e (elsif \u003c\u003e [])))","type compatibility obligation:(forall elsif:seq of (SimpleElseIfExpression), els:SimpleExpression \u0026 ((not (elsif \u003d [])) \u003d\u003e is_(Compile((head.getTest)()), GiraffeExpression)))","type compatibility obligation:(forall elsif:seq of (SimpleElseIfExpression), els:SimpleExpression \u0026 ((not (elsif \u003d [])) \u003d\u003e is_(Compile((head.getThn)()), GiraffeExpression)))","non-empty sequence obligation:(forall elsif:seq of (SimpleElseIfExpression), els:SimpleExpression \u0026 ((not (elsif \u003d [])) \u003d\u003e (elsif \u003c\u003e [])))","type compatibility obligation:(forall elsif:seq of (SimpleElseIfExpression), els:SimpleExpression \u0026 is_((if (elsif \u003d [])\nthen Compile(els)\nelse let head:SimpleElseIfExpression \u003d (hd elsif), gTest:GiraffeExpression \u003d Compile((head.getTest)()), gThen:GiraffeExpression \u003d Compile((head.getThn)()), gElse:GiraffeExpression \u003d deflatten((tl elsif), els) in new GiraffeIfExpressionImpl(gTest, gThen, gElse)), GiraffeExpression))","legal sequence application obligation:(forall classDef:GiraffeClassDefinition \u0026 (forall i in set (inds mlist) \u0026 (i in set (inds mlist))))","legal sequence application obligation:(forall method:GiraffeMethodDefinition \u0026 (forall i in set (inds params) \u0026 (i in set (inds params))))","legal sequence application obligation:(forall method:GiraffeMethodDefinition \u0026 (forall i in set (inds body) \u0026 (i in set (inds body))))","type compatibility obligation:(forall type:GiraffeType \u0026 is_(type, GiraffeIdentifier))","type compatibility obligation:(forall type:GiraffeType \u0026 is_(type, GiraffeBasicType))","type compatibility obligation:(forall stm:GiraffeStatement \u0026 is_(stm, GiraffeVariableDeclStatement))","type compatibility obligation:(forall stm:GiraffeStatement \u0026 is_(stm, GiraffeReturnStatement))","type compatibility obligation:(forall exp:GiraffeExpression \u0026 is_(exp, GiraffeIntegerLiteralExpression))","legal function application obligation:(forall exp:GiraffeExpression \u0026 pre_((new codegen_Util().iToS)(e.getValue)()))","type compatibility obligation:(forall exp:GiraffeExpression \u0026 is_(exp, GiraffeVariableExpression))","type compatibility obligation:(forall exp:GiraffeExpression \u0026 is_(exp, GiraffeBinaryExpression))","type compatibility obligation:(forall exp:GiraffeExpression \u0026 is_(exp, GiraffeIfExpression))","non-empty sequence obligation:(forall x:seq of (seq of (char)) \u0026 ((not (x \u003d [])) \u003d\u003e (x \u003c\u003e [])))","non-empty sequence obligation:(forall programs:seq of (seq of (char)) \u0026 (programs \u003c\u003e []))","type compatibility obligation:(forall programs:seq of (seq of (char)) \u0026 is_(e, int))","non-empty sequence obligation:(forall programs:seq of (seq of (char)) \u0026 (programs \u003c\u003e []))","non-empty sequence obligation:(forall programs:seq of (seq of (char)) \u0026 (programs \u003c\u003e []))","type compatibility obligation:is_(RESULT, GiraffeExpression)","type compatibility obligation:is_(RESULT, SimpleExpression)","operation call obligation:(forall text:seq of (char) \u0026 ((\"\" \u003d \"\") \u003c\u003d\u003e (\"\" \u003d nil)))"] \ No newline at end of file +["state invariant initialized obligation:((card (dom {|-\u003e})) \u003d (card (rng {|-\u003e})))","state invariant satisfiable obligation:(exists typeDefs:seq of (SimpleTypeDefinition), context:map (seq of (char)) to (seq of (char)), varDecls:seq of (GiraffeVariableDeclStatement), uid:nat1 \u0026 ((card (dom context)) \u003d (card (rng context))))","state invariant holds obligation:(((card (dom context)) \u003d (card (rng context))) \u003d\u003e ((card (dom context)) \u003d (card (rng context))))","legal function application obligation:pre_((util.iToS)res)","operation establishes postcondition obligation:(RESULT not in set (rng context))","while loop termination obligation:...","operation establishes postcondition obligation:(RESULT not in set (dom context))","legal sequence application obligation:(forall programName:seq of (char), spec:SimpleSpecification \u0026 ((((len programName) \u003e 0) and (programName(1) not in set {\u00270\u0027, \u00271\u0027, \u00272\u0027, \u00273\u0027, \u00274\u0027, \u00275\u0027, \u00276\u0027, \u00277\u0027, \u00278\u0027, \u00279\u0027})) \u003d\u003e (((len programName) \u003e 0) \u003d\u003e (1 in set (inds programName)))))","legal sequence application obligation:(forall programName:seq of (char), spec:SimpleSpecification \u0026 ((((len programName) \u003e 0) and (programName(1) not in set {\u00270\u0027, \u00271\u0027, \u00272\u0027, \u00273\u0027, \u00274\u0027, \u00275\u0027, \u00276\u0027, \u00277\u0027, \u00278\u0027, \u00279\u0027})) \u003d\u003e (forall i in set (inds defs) \u0026 (isofclass(SimpleFunctionDefinition,defs(i)) \u003d\u003e (i in set (inds defs))))))","legal sequence application obligation:(forall programName:seq of (char), spec:SimpleSpecification \u0026 ((((len programName) \u003e 0) and (programName(1) not in set {\u00270\u0027, \u00271\u0027, \u00272\u0027, \u00273\u0027, \u00274\u0027, \u00275\u0027, \u00276\u0027, \u00277\u0027, \u00278\u0027, \u00279\u0027})) \u003d\u003e (forall i in set (inds defs) \u0026 (i in set (inds defs)))))","state invariant holds obligation:(forall programName:seq of (char), spec:SimpleSpecification \u0026 ((((len programName) \u003e 0) and (programName(1) not in set {\u00270\u0027, \u00271\u0027, \u00272\u0027, \u00273\u0027, \u00274\u0027, \u00275\u0027, \u00276\u0027, \u00277\u0027, \u00278\u0027, \u00279\u0027})) \u003d\u003e (((card (dom context)) \u003d (card (rng context))) \u003d\u003e ((card (dom context)) \u003d (card (rng context))))))","legal sequence application obligation:(forall programName:seq of (char), spec:SimpleSpecification \u0026 ((((len programName) \u003e 0) and (programName(1) not in set {\u00270\u0027, \u00271\u0027, \u00272\u0027, \u00273\u0027, \u00274\u0027, \u00275\u0027, \u00276\u0027, \u00277\u0027, \u00278\u0027, \u00279\u0027})) \u003d\u003e (forall i in set (inds defs) \u0026 (isofclass(SimpleTypeDefinition,defs(i)) \u003d\u003e (i in set (inds defs))))))","legal sequence application obligation:(forall programName:seq of (char), spec:SimpleSpecification \u0026 ((((len programName) \u003e 0) and (programName(1) not in set {\u00270\u0027, \u00271\u0027, \u00272\u0027, \u00273\u0027, \u00274\u0027, \u00275\u0027, \u00276\u0027, \u00277\u0027, \u00278\u0027, \u00279\u0027})) \u003d\u003e (forall i in set (inds defs) \u0026 (i in set (inds defs)))))","type compatibility obligation:(forall programName:seq of (char), spec:SimpleSpecification \u0026 ((((len programName) \u003e 0) and (programName(1) not in set {\u00270\u0027, \u00271\u0027, \u00272\u0027, \u00273\u0027, \u00274\u0027, \u00275\u0027, \u00276\u0027, \u00277\u0027, \u00278\u0027, \u00279\u0027})) \u003d\u003e is_([defs(i) | i in set (inds defs) \u0026 isofclass(SimpleTypeDefinition,defs(i))], seq of (SimpleTypeDefinition))))","legal sequence application obligation:(forall func:SimpleFunctionDefinition \u0026 (((varDecls \u003d []) and (context \u003d {|-\u003e})) \u003d\u003e (forall i in set (inds defs) \u0026 (i in set (inds defs)))))","type compatibility obligation:(forall func:SimpleFunctionDefinition \u0026 (((varDecls \u003d []) and (context \u003d {|-\u003e})) \u003d\u003e is_(Compile(GetType((func.getBody)())), GiraffeType)))","state invariant holds obligation:(forall func:SimpleFunctionDefinition \u0026 (((varDecls \u003d []) and (context \u003d {|-\u003e})) \u003d\u003e (((card (dom context)) \u003d (card (rng context))) \u003d\u003e ((card (dom context)) \u003d (card (rng context))))))","operation establishes postcondition obligation:(forall func:SimpleFunctionDefinition \u0026 (((varDecls \u003d []) and (context \u003d {|-\u003e})) \u003d\u003e (([] \u003d []) and (context \u003d {|-\u003e}))))","type compatibility obligation:(forall param:SimpleParameter \u0026 is_(Compile((param.getType)()), GiraffeType))","type compatibility obligation:(forall type:SimpleType \u0026 is_(type, SimpleIdentifier))","type compatibility obligation:(forall type:SimpleType \u0026 is_(type, SimpleBasicType))","operation establishes postcondition obligation:(forall type:SimpleType \u0026 (RESULT \u003c\u003e nil))","type compatibility obligation:(forall exp:SimpleExpression \u0026 is_(exp, SimpleIntegerLiteralExpression))","type compatibility obligation:(forall exp:SimpleExpression \u0026 is_(exp, SimpleBinaryExpression))","type compatibility obligation:(forall exp:SimpleExpression \u0026 is_(exp, SimpleCasesExpression))","type compatibility obligation:(forall exp:SimpleExpression \u0026 is_(exp, SimpleVariableExpression))","legal map application obligation:(forall exp:SimpleExpression \u0026 ((name.getName)() in set (dom context)))","type compatibility obligation:(forall exp:SimpleExpression \u0026 is_(exp, SimpleLetExpression))","type compatibility obligation:(forall exp:SimpleExpression \u0026 is_(exp, SimpleIfExpression))","operation establishes postcondition obligation:(forall exp:SimpleExpression \u0026 (RESULT \u003c\u003e nil))","non-empty sequence obligation:(forall e:SimpleCasesExpression \u0026 ((not (e.hasDeflt)()) \u003d\u003e ((not ((e.getAlts)() \u003d [])) \u003d\u003e ((e.getAlts)() \u003c\u003e []))))","non-empty sequence obligation:(forall e:SimpleCasesExpression \u0026 ((not (e.hasDeflt)()) \u003d\u003e ((not ((e.getAlts)() \u003d [])) \u003d\u003e ((e.getAlts)() \u003c\u003e []))))","legal sequence application obligation:(forall e:SimpleCasesExpression \u0026 ((not (e.hasDeflt)()) \u003d\u003e ((not ((e.getAlts)() \u003d [])) \u003d\u003e (forall i in set (inds rest) \u0026 (i in set (inds rest))))))","legal sequence application obligation:(forall e:SimpleCasesExpression \u0026 ((not (e.hasDeflt)()) \u003d\u003e ((not ((e.getAlts)() \u003d [])) \u003d\u003e (forall i in set (inds rest) \u0026 (i in set (inds rest))))))","type compatibility obligation:(forall e:SimpleCasesExpression \u0026 ((not (e.hasDeflt)()) \u003d\u003e is_(RESULT, GiraffeExpression)))","type compatibility obligation:(forall letExp:SimpleLetExpression \u0026 (((letExp.getDefs)() \u003c\u003e []) \u003d\u003e is_(Compile(type), GiraffeType)))","type compatibility obligation:(forall letExp:SimpleLetExpression \u0026 (((letExp.getDefs)() \u003c\u003e []) \u003d\u003e is_(Compile((x.getValue)()), GiraffeExpression)))","state invariant holds obligation:(forall letExp:SimpleLetExpression \u0026 (((letExp.getDefs)() \u003c\u003e []) \u003d\u003e (((card (dom context)) \u003d (card (rng context))) \u003d\u003e ((card (dom (context ++ {name |-\u003e newName}))) \u003d (card (rng (context ++ {name |-\u003e newName})))))))","state invariant holds obligation:(forall letExp:SimpleLetExpression \u0026 (((letExp.getDefs)() \u003c\u003e []) \u003d\u003e (((card (dom (context ++ {name |-\u003e newName}))) \u003d (card (rng (context ++ {name |-\u003e newName})))) \u003d\u003e ((card (dom (context ++ {name |-\u003e newName}))) \u003d (card (rng (context ++ {name |-\u003e newName})))))))","type compatibility obligation:(forall letExp:SimpleLetExpression \u0026 (((letExp.getDefs)() \u003c\u003e []) \u003d\u003e is_(Compile((letExp.getBody)()), GiraffeExpression)))","state invariant holds obligation:(forall letExp:SimpleLetExpression \u0026 (((letExp.getDefs)() \u003c\u003e []) \u003d\u003e (((card (dom (context ++ {name |-\u003e newName}))) \u003d (card (rng (context ++ {name |-\u003e newName})))) \u003d\u003e ((card (dom oldContext)) \u003d (card (rng oldContext))))))","type compatibility obligation:(forall op:SimpleBinaryOperator, lhs:SimpleExpression, rhs:SimpleExpression \u0026 is_(Compile(lhs), GiraffeExpression))","type compatibility obligation:(forall op:SimpleBinaryOperator, lhs:SimpleExpression, rhs:SimpleExpression \u0026 is_(Compile(rhs), GiraffeExpression))","type compatibility obligation:(forall op:SimpleBinaryOperator, lhs:SimpleExpression, rhs:SimpleExpression \u0026 is_(Compile(lhs), GiraffeExpression))","type compatibility obligation:(forall op:SimpleBinaryOperator, lhs:SimpleExpression, rhs:SimpleExpression \u0026 is_(Compile(rhs), GiraffeExpression))","operation establishes postcondition obligation:(forall op:SimpleBinaryOperator, lhs:SimpleExpression, rhs:SimpleExpression \u0026 (RESULT \u003c\u003e nil))","type compatibility obligation:(forall selif:SimpleIfExpression \u0026 is_(Compile((selif.getTest)()), GiraffeExpression))","type compatibility obligation:(forall selif:SimpleIfExpression \u0026 is_(Compile((selif.getThn)()), GiraffeExpression))","non-empty sequence obligation:(forall elsif:seq of (SimpleElseIfExpression), els:SimpleExpression \u0026 ((not (elsif \u003d [])) \u003d\u003e (elsif \u003c\u003e [])))","type compatibility obligation:(forall elsif:seq of (SimpleElseIfExpression), els:SimpleExpression \u0026 ((not (elsif \u003d [])) \u003d\u003e is_(Compile((head.getTest)()), GiraffeExpression)))","type compatibility obligation:(forall elsif:seq of (SimpleElseIfExpression), els:SimpleExpression \u0026 ((not (elsif \u003d [])) \u003d\u003e is_(Compile((head.getThn)()), GiraffeExpression)))","non-empty sequence obligation:(forall elsif:seq of (SimpleElseIfExpression), els:SimpleExpression \u0026 ((not (elsif \u003d [])) \u003d\u003e (elsif \u003c\u003e [])))","type compatibility obligation:(forall elsif:seq of (SimpleElseIfExpression), els:SimpleExpression \u0026 is_((if (elsif \u003d [])\nthen Compile(els)\nelse let head:SimpleElseIfExpression \u003d (hd elsif), gTest:GiraffeExpression \u003d Compile((head.getTest)()), gThen:GiraffeExpression \u003d Compile((head.getThn)()), gElse:GiraffeExpression \u003d deflatten((tl elsif), els) in new GiraffeIfExpressionImpl(gTest, gThen, gElse)), GiraffeExpression))","legal sequence application obligation:(forall classDef:GiraffeClassDefinition \u0026 (forall i in set (inds mlist) \u0026 (i in set (inds mlist))))","legal sequence application obligation:(forall method:GiraffeMethodDefinition \u0026 (forall i in set (inds params) \u0026 (i in set (inds params))))","legal sequence application obligation:(forall method:GiraffeMethodDefinition \u0026 (forall i in set (inds body) \u0026 (i in set (inds body))))","type compatibility obligation:(forall type:GiraffeType \u0026 is_(type, GiraffeIdentifier))","type compatibility obligation:(forall type:GiraffeType \u0026 is_(type, GiraffeBasicType))","type compatibility obligation:(forall stm:GiraffeStatement \u0026 is_(stm, GiraffeVariableDeclStatement))","type compatibility obligation:(forall stm:GiraffeStatement \u0026 is_(stm, GiraffeReturnStatement))","type compatibility obligation:(forall exp:GiraffeExpression \u0026 is_(exp, GiraffeIntegerLiteralExpression))","legal function application obligation:(forall exp:GiraffeExpression \u0026 pre_((new codegen_Util().iToS)(e.getValue)()))","type compatibility obligation:(forall exp:GiraffeExpression \u0026 is_(exp, GiraffeVariableExpression))","type compatibility obligation:(forall exp:GiraffeExpression \u0026 is_(exp, GiraffeBinaryExpression))","type compatibility obligation:(forall exp:GiraffeExpression \u0026 is_(exp, GiraffeIfExpression))","non-empty sequence obligation:(forall x:seq of (seq of (char)) \u0026 ((not (x \u003d [])) \u003d\u003e (x \u003c\u003e [])))","non-empty sequence obligation:(forall programs:seq of (seq of (char)) \u0026 (programs \u003c\u003e []))","type compatibility obligation:(forall programs:seq of (seq of (char)) \u0026 is_(e, int))","non-empty sequence obligation:(forall programs:seq of (seq of (char)) \u0026 (programs \u003c\u003e []))","non-empty sequence obligation:(forall programs:seq of (seq of (char)) \u0026 (programs \u003c\u003e []))","type compatibility obligation:is_(RESULT, GiraffeExpression)","type compatibility obligation:is_(RESULT, SimpleExpression)","operation call obligation:(forall text:seq of (char) \u0026 ((\"\" \u003d \"\") \u003c\u003d\u003e (\"\" \u003d nil)))"] \ No newline at end of file diff --git a/core/pog/src/test/resources/examples/CyberRailRT.result b/core/pog/src/test/resources/examples/CyberRailRT.result index 237c422fe7..437ef1cfe9 100644 --- a/core/pog/src/test/resources/examples/CyberRailRT.result +++ b/core/pog/src/test/resources/examples/CyberRailRT.result @@ -1 +1 @@ -["while loop termination obligation:NotYetImplemented","non-empty sequence obligation:(inlines \u003c\u003e [])","non-empty sequence obligation:(inlines \u003c\u003e [])","legal function application obligation:(forall fname:seq of (char) \u0026 pre_(((io.freadval))[seq of (inline)]fname))","type compatibility obligation:(forall fname:seq of (char) \u0026 is_(input, seq of (inline)))","map compatible obligation:(forall td:TokenDevice \u0026 (forall ldom1 in set (dom tokenDevices), rdom2 in set (dom {(td.getTokenId)() |-\u003e td}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (tokenDevices(ldom1) \u003d {(td.getTokenId)() |-\u003e td}(rdom2)))))","non-empty sequence obligation:(((len inlines) \u003e 0) \u003d\u003e (inlines \u003c\u003e []))","type invariant satisfiable obligation:(exists n:NavigationInput \u0026 (((len (n.departureLocation)) \u003e 0) and ((len (n.arrivalLocation)) \u003e 0)))","legal sequence application obligation:(forall navInput:NavigationInput, tokenDevice:TokenDevice \u0026 ((exists r in set (railway.getGrid)() \u0026 (((r(1).departureLocation) \u003d (navInput.departureLocation)) and ((r((len r)).arrivalLocation) \u003d (navInput.arrivalLocation)))) \u003d\u003e (forall r in set (railway.getGrid)() \u0026 (1 in set (inds r)))))","legal sequence application obligation:(forall navInput:NavigationInput, tokenDevice:TokenDevice \u0026 ((exists r in set (railway.getGrid)() \u0026 (((r(1).departureLocation) \u003d (navInput.departureLocation)) and ((r((len r)).arrivalLocation) \u003d (navInput.arrivalLocation)))) \u003d\u003e (forall r in set (railway.getGrid)() \u0026 (((r(1).departureLocation) \u003d (navInput.departureLocation)) \u003d\u003e ((len r) in set (inds r))))))","legal sequence application obligation:(forall navInput:NavigationInput, tokenDevice:TokenDevice \u0026 ((exists r in set (railway.getGrid)() \u0026 (((r(1).departureLocation) \u003d (navInput.departureLocation)) and ((r((len r)).arrivalLocation) \u003d (navInput.arrivalLocation)))) \u003d\u003e (forall r in set tempGrid \u0026 (1 in set (inds r)))))","legal sequence application obligation:(forall navInput:NavigationInput, tokenDevice:TokenDevice \u0026 ((exists r in set (railway.getGrid)() \u0026 (((r(1).departureLocation) \u003d (navInput.departureLocation)) and ((r((len r)).arrivalLocation) \u003d (navInput.arrivalLocation)))) \u003d\u003e (forall r in set tempGrid \u0026 (((r(1).departureLocation) \u003d (navInput.departureLocation)) \u003d\u003e ((len r) in set (inds r))))))","non-empty sequence obligation:(((len q_Env_in) \u003e 0) \u003d\u003e (q_Env_in \u003c\u003e []))","operation call obligation:(((len q_Env_in) \u003e 0) \u003d\u003e (forall normalState1:bool, curtime2:nat, railway3:RailwayGrid, q_APM_out4:ActivePlanManager, q_Env_in5:seq of (MessageT), q_APM_in6:seq of (MessageT), busy7:bool, timeout8:nat \u0026 (true \u003d\u003e ((len q_APM_in6) \u003e 0))))","non-empty sequence obligation:(((len q_APM_in) \u003e 0) \u003d\u003e (q_APM_in \u003c\u003e []))","operation call obligation:(((len q_APM_in) \u003e 0) \u003d\u003e (forall normalState1:bool, curtime2:nat, railway3:RailwayGrid, q_APM_out4:ActivePlanManager, q_Env_in5:seq of (MessageT), q_APM_in6:seq of (MessageT), busy7:bool, timeout8:nat \u0026 (true \u003d\u003e ((len q_APM_in6) \u003e 0))))","type compatibility obligation:(forall navi:NavigationInput, tokenDevice:TokenDevice \u0026 is_(calculateTransportPlan(navi, tokenDevice), DTO))","value binding obligation:(forall msg:MessageT \u0026 (exists mk_INACTIVEROUTE(routeid):MessageT \u0026 (mk_INACTIVEROUTE(routeid) \u003d msg)))","type compatibility obligation:(forall msg:MessageT \u0026 is_(msg, INACTIVEROUTE))","non-empty sequence obligation:(((len q_APM_in) \u003e 0) \u003d\u003e (q_APM_in \u003c\u003e []))","non-empty sequence obligation:(((len q_APM_in) \u003e 0) \u003d\u003e (q_Env_in \u003c\u003e []))","while loop termination obligation:NotYetImplemented","type compatibility obligation:((i - 1) \u003e\u003d 0)","type invariant satisfiable obligation:(exists r:Route \u0026 (((len (r.platform)) \u003e 0) and (((len (r.arrivalLocation)) \u003e 0) and (((len (r.departureLocation)) \u003e 0) and ((r.fee) \u003e\u003d 0)))))","state invariant holds obligation:(forall routes:seq of (Route), pChoice:Choice, id_tok:nat \u0026 (((len routes) \u003e 0) \u003d\u003e (forall i in set (inds routeList) \u0026 ((i \u003c (len routeList)) \u003d\u003e ((routeList(i).arrivalLocation) \u003d (routeList((i + 1)).departureLocation))))))","non-empty sequence obligation:(((len routeList) \u003e 0) \u003d\u003e (routeList \u003c\u003e []))","legal sequence application obligation:(forall route:Route \u0026 (((routeList((len routeList)).arrivalLocation) \u003d (route.departureLocation)) \u003d\u003e ((len routeList) in set (inds routeList))))","state invariant holds obligation:(forall route:Route \u0026 (((routeList((len routeList)).arrivalLocation) \u003d (route.departureLocation)) \u003d\u003e ((((len routeList) \u003e 0) \u003d\u003e (forall i in set (inds routeList) \u0026 ((i \u003c (len routeList)) \u003d\u003e ((routeList(i).arrivalLocation) \u003d (routeList((i + 1)).departureLocation))))) \u003d\u003e (((len (routeList ^ [route])) \u003e 0) \u003d\u003e (forall i in set (inds routeList) \u0026 ((i \u003c (len routeList)) \u003d\u003e ((routeList(i).arrivalLocation) \u003d (routeList((i + 1)).departureLocation))))))))","state invariant holds obligation:(forall route:Route \u0026 (((routeList((len routeList)).arrivalLocation) \u003d (route.departureLocation)) \u003d\u003e ((((len (routeList ^ [route])) \u003e 0) \u003d\u003e (forall i in set (inds routeList) \u0026 ((i \u003c (len routeList)) \u003d\u003e ((routeList(i).arrivalLocation) \u003d (routeList((i + 1)).departureLocation))))) \u003d\u003e (((len (routeList ^ [route])) \u003e 0) \u003d\u003e (forall i in set (inds routeList) \u0026 ((i \u003c (len routeList)) \u003d\u003e ((routeList(i).arrivalLocation) \u003d (routeList((i + 1)).departureLocation))))))))","state invariant holds obligation:(((len routeList) \u003e 0) \u003d\u003e ((((len routeList) \u003e 0) \u003d\u003e (forall i in set (inds routeList) \u0026 ((i \u003c (len routeList)) \u003d\u003e ((routeList(i).arrivalLocation) \u003d (routeList((i + 1)).departureLocation))))) \u003d\u003e (((len routeList) \u003e 0) \u003d\u003e (forall i in set (inds routeList) \u0026 ((i \u003c (len routeList)) \u003d\u003e ((routeList(i).arrivalLocation) \u003d (routeList((i + 1)).departureLocation)))))))","non-empty sequence obligation:(((len routeList) \u003e 0) \u003d\u003e (routeList \u003c\u003e []))","state invariant holds obligation:(((len routeList) \u003e 0) \u003d\u003e ((((len routeList) \u003e 0) \u003d\u003e (forall i in set (inds routeList) \u0026 ((i \u003c (len routeList)) \u003d\u003e ((routeList(i).arrivalLocation) \u003d (routeList((i + 1)).departureLocation))))) \u003d\u003e (((len (tl routeList)) \u003e 0) \u003d\u003e (forall i in set (inds routeList) \u0026 ((i \u003c (len routeList)) \u003d\u003e ((routeList(i).arrivalLocation) \u003d (routeList((i + 1)).departureLocation)))))))","non-empty sequence obligation:(((len routeList) \u003e 0) \u003d\u003e (routeList \u003c\u003e []))","non-empty sequence obligation:(((len routeList) \u003e 0) \u003d\u003e (routeList \u003c\u003e []))","legal sequence application obligation:(((len routeList) \u003e 0) \u003d\u003e ((len routeList) in set (inds routeList)))","type compatibility obligation:(((len routeList) \u003e 0) \u003d\u003e (id_token \u003e 0))","type compatibility obligation:(((len routeList) \u003e 0) \u003d\u003e (inv_NavigationInput(mk_CyberRail`NavigationInput(((hd routeList).departureLocation), (routeList((len routeList)).arrivalLocation), choice, id_token)) and (id_token \u003e 0)))","legal sequence application obligation:(forall o:TransportPlan \u0026 (1 in set (inds (o.getRouteList)())))","legal sequence application obligation:(forall o:TransportPlan \u0026 ((len (o.getRouteList)()) in set (inds (o.getRouteList)())))","legal function application obligation:pre_(((io.fwriteval))[seq of (logType)]\"logger.log\", log, \u003cstart\u003e)","type compatibility obligation:(forall plan:[TransportPlan], route:[Route], t:nat \u0026 is_((outlines ^ [mk_(plan, route, t)]), seq of (outline)))","legal function application obligation:pre_(((io.fwriteval))[seq of (outline)]outfileName, outlines, \u003cstart\u003e)","legal function application obligation:(forall fname:seq of (char) \u0026 pre_(((io.freadval))[seq of (inline)]fname))","type compatibility obligation:(forall fname:seq of (char) \u0026 is_(input, seq of (inline)))","type compatibility obligation:inv_Route(mk_TransportPlan`Route(\"A\", \"B\", 42, \"P1\", 200, 1))","type compatibility obligation:inv_Route(mk_TransportPlan`Route(\"A\", \"C\", 42, \"P1\", 200, 2))","type compatibility obligation:inv_Route(mk_TransportPlan`Route(\"B\", \"C\", 99, \"P1\", 200, 3))","type compatibility obligation:inv_Route(mk_TransportPlan`Route(\"B\", \"D\", 42, \"P1\", 200, 4))","type compatibility obligation:inv_Route(mk_TransportPlan`Route(\"B\", \"A\", 42, \"P1\", 200, 5))","type compatibility obligation:inv_Route(mk_TransportPlan`Route(\"C\", \"D\", 42, \"P1\", 200, 6))","type compatibility obligation:inv_Route(mk_TransportPlan`Route(\"C\", \"A\", 42, \"P1\", 200, 7))","type compatibility obligation:inv_Route(mk_TransportPlan`Route(\"D\", \"B\", 42, \"P1\", 200, 8))","type compatibility obligation:inv_Route(mk_TransportPlan`Route(\"D\", \"C\", 42, \"P1\", 200, 9))","type compatibility obligation:inv_Route(mk_TransportPlan`Route(\"C\", \"B\", 99, \"P1\", 200, 10))","legal function application obligation:(forall grid:Grid \u0026 pre_(((io.fwriteval))[Grid]\"railway.txt\", grid, \u003cappend\u003e))","state invariant holds obligation:((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e (forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))))","state invariant holds obligation:((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e (forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))))","state invariant holds obligation:(forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y))))","state invariant holds obligation:(forall plan:TransportPlan, tokenDevice:TokenDevice \u0026 ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e (forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y))))))","type compatibility obligation:(forall plan:TransportPlan, tokenDevice:TokenDevice \u0026 is_((activeTokens ++ {tokenDevice |-\u003e plan}), inmap (TokenDevice) to (TransportPlan)))","state invariant holds obligation:(forall plan:TransportPlan, tokenDevice:TokenDevice \u0026 ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e (forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y))))))","state invariant holds obligation:(forall plan:TransportPlan, tokenDevice:TokenDevice \u0026 ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e (forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y))))))","operation call obligation:((len q_CR_in) \u003e 0)","operation call obligation:(forall activeTokens1:inmap (TokenDevice) to (TransportPlan), busy2:bool, q_CR_out3:CyberRail, tokenDevices4:set of (TokenDevice), q_Tok_in5:seq of (MessageT), q_CR_in6:seq of (MessageT), q_Tok_out7:seq of (TransportPlan), state8:State \u0026 ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e (((len q_Tok_out7) \u003e 0) and (exists plan in set (rng activeTokens) \u0026 (plan \u003d (hd q_Tok_out7))))))","operation call obligation:(forall activeTokens1:inmap (TokenDevice) to (TransportPlan), busy2:bool, q_CR_out3:CyberRail, tokenDevices4:set of (TokenDevice), q_Tok_in5:seq of (MessageT), q_CR_in6:seq of (MessageT), q_Tok_out7:seq of (TransportPlan), state8:State \u0026 ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e (forall activeTokens9:inmap (TokenDevice) to (TransportPlan), busy10:bool, q_CR_out11:CyberRail, tokenDevices12:set of (TokenDevice), q_Tok_in13:seq of (MessageT), q_CR_in14:seq of (MessageT), q_Tok_out15:seq of (TransportPlan), state16:State \u0026 ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e ((len q_Tok_in13) \u003e 0)))))","state invariant holds obligation:(forall activeTokens1:inmap (TokenDevice) to (TransportPlan), busy2:bool, q_CR_out3:CyberRail, tokenDevices4:set of (TokenDevice), q_Tok_in5:seq of (MessageT), q_CR_in6:seq of (MessageT), q_Tok_out7:seq of (TransportPlan), state8:State \u0026 ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e (forall activeTokens9:inmap (TokenDevice) to (TransportPlan), busy10:bool, q_CR_out11:CyberRail, tokenDevices12:set of (TokenDevice), q_Tok_in13:seq of (MessageT), q_CR_in14:seq of (MessageT), q_Tok_out15:seq of (TransportPlan), state16:State \u0026 ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e (forall activeTokens17:inmap (TokenDevice) to (TransportPlan), busy18:bool, q_CR_out19:CyberRail, tokenDevices20:set of (TokenDevice), q_Tok_in21:seq of (MessageT), q_CR_in22:seq of (MessageT), q_Tok_out23:seq of (TransportPlan), state24:State \u0026 ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e (forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))))))))))","non-empty sequence obligation:((((len q_Tok_out) \u003e 0) and (exists plan in set (rng activeTokens) \u0026 (plan \u003d (hd q_Tok_out)))) \u003d\u003e (((len q_Tok_out) \u003e 0) \u003d\u003e (forall plan in set (rng activeTokens) \u0026 (q_Tok_out \u003c\u003e []))))","map inverse obligation:((((len q_Tok_out) \u003e 0) and (exists plan in set (rng activeTokens) \u0026 (plan \u003d (hd q_Tok_out)))) \u003d\u003e is_(activeTokens, inmap (TokenDevice) to (TransportPlan)))","non-empty sequence obligation:((((len q_Tok_out) \u003e 0) and (exists plan in set (rng activeTokens) \u0026 (plan \u003d (hd q_Tok_out)))) \u003d\u003e (q_Tok_out \u003c\u003e []))","legal map application obligation:((((len q_Tok_out) \u003e 0) and (exists plan in set (rng activeTokens) \u0026 (plan \u003d (hd q_Tok_out)))) \u003d\u003e (plan in set (dom ptt_map)))","state invariant holds obligation:((((len q_Tok_out) \u003e 0) and (exists plan in set (rng activeTokens) \u0026 (plan \u003d (hd q_Tok_out)))) \u003d\u003e ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e (forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y))))))","non-empty sequence obligation:((((len q_Tok_out) \u003e 0) and (exists plan in set (rng activeTokens) \u0026 (plan \u003d (hd q_Tok_out)))) \u003d\u003e (q_Tok_out \u003c\u003e []))","state invariant holds obligation:(((len q_CR_in) \u003e 0) \u003d\u003e ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e (forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y))))))","non-empty sequence obligation:(((len q_CR_in) \u003e 0) \u003d\u003e (q_CR_in \u003c\u003e []))","operation call obligation:(((len q_CR_in) \u003e 0) \u003d\u003e (forall activeTokens1:inmap (TokenDevice) to (TransportPlan), busy2:bool, q_CR_out3:CyberRail, tokenDevices4:set of (TokenDevice), q_Tok_in5:seq of (MessageT), q_CR_in6:seq of (MessageT), q_Tok_out7:seq of (TransportPlan), state8:State \u0026 ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e (forall activeTokens9:inmap (TokenDevice) to (TransportPlan), busy10:bool, q_CR_out11:CyberRail, tokenDevices12:set of (TokenDevice), q_Tok_in13:seq of (MessageT), q_CR_in14:seq of (MessageT), q_Tok_out15:seq of (TransportPlan), state16:State \u0026 ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e (forall activeTokens17:inmap (TokenDevice) to (TransportPlan), busy18:bool, q_CR_out19:CyberRail, tokenDevices20:set of (TokenDevice), q_Tok_in21:seq of (MessageT), q_CR_in22:seq of (MessageT), q_Tok_out23:seq of (TransportPlan), state24:State \u0026 ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e (forall activeTokens25:inmap (TokenDevice) to (TransportPlan), busy26:bool, q_CR_out27:CyberRail, tokenDevices28:set of (TokenDevice), q_Tok_in29:seq of (MessageT), q_CR_in30:seq of (MessageT), q_Tok_out31:seq of (TransportPlan), state32:State \u0026 ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e ((len q_CR_in30) \u003e 0))))))))))","state invariant holds obligation:(((len q_Tok_in) \u003e 0) \u003d\u003e ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e (forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y))))))","non-empty sequence obligation:(((len q_Tok_in) \u003e 0) \u003d\u003e (q_Tok_in \u003c\u003e []))","operation call obligation:(((len q_Tok_in) \u003e 0) \u003d\u003e (forall activeTokens1:inmap (TokenDevice) to (TransportPlan), busy2:bool, q_CR_out3:CyberRail, tokenDevices4:set of (TokenDevice), q_Tok_in5:seq of (MessageT), q_CR_in6:seq of (MessageT), q_Tok_out7:seq of (TransportPlan), state8:State \u0026 ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e ((len q_Tok_in5) \u003e 0))))","state invariant holds obligation:(forall log1:seq of (logType) \u0026 (true \u003d\u003e (forall log2:seq of (logType) \u0026 (true \u003d\u003e ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e (forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))))))))","state invariant holds obligation:((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e (forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))))","value binding obligation:(forall msg:MessageT \u0026 (exists mk_STRATEGYNOTIFY(routeid):MessageT \u0026 (mk_STRATEGYNOTIFY(routeid) \u003d msg)))","type compatibility obligation:(forall msg:MessageT \u0026 is_(msg, STRATEGYNOTIFY))","value binding obligation:(forall msg:MessageT \u0026 (exists mk_RETURNPLAN(dto, tok):MessageT \u0026 (mk_RETURNPLAN(dto, tok) \u003d msg)))","type compatibility obligation:(forall msg:MessageT \u0026 is_(msg, RETURNPLAN))","value binding obligation:(forall msg:MessageT \u0026 (exists mk_REQUESTPLAN(navi, tok):MessageT \u0026 (mk_REQUESTPLAN(navi, tok) \u003d msg)))","type compatibility obligation:(forall msg:MessageT \u0026 is_(msg, REQUESTPLAN))","state invariant holds obligation:(((len q_Tok_in) \u003e 0) \u003d\u003e ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e (forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y))))))","non-empty sequence obligation:(((len q_Tok_in) \u003e 0) \u003d\u003e (q_Tok_in \u003c\u003e []))","state invariant holds obligation:(((len q_CR_in) \u003e 0) \u003d\u003e ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e (forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y))))))","non-empty sequence obligation:(((len q_CR_in) \u003e 0) \u003d\u003e (q_CR_in \u003c\u003e []))","state invariant holds obligation:(forall cr:CyberRail \u0026 ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e (forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y))))))","state invariant holds obligation:(forall msg:MessageT \u0026 ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e (forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y))))))","state invariant holds obligation:(forall msg:MessageT \u0026 ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e (forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y))))))","non-empty sequence obligation:(queue \u003c\u003e [])","non-empty sequence obligation:(queue \u003c\u003e [])","operation call obligation:(forall text:seq of (char) \u0026 ((\"\" \u003d \"\") \u003c\u003d\u003e (\"\" \u003d nil)))"] \ No newline at end of file +["while loop termination obligation:...","non-empty sequence obligation:(inlines \u003c\u003e [])","non-empty sequence obligation:(inlines \u003c\u003e [])","legal function application obligation:(forall fname:seq of (char) \u0026 pre_(((io.freadval))[seq of (inline)]fname))","type compatibility obligation:(forall fname:seq of (char) \u0026 is_(input, seq of (inline)))","map compatible obligation:(forall td:TokenDevice \u0026 (forall ldom1 in set (dom tokenDevices), rdom2 in set (dom {(td.getTokenId)() |-\u003e td}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (tokenDevices(ldom1) \u003d {(td.getTokenId)() |-\u003e td}(rdom2)))))","non-empty sequence obligation:(((len inlines) \u003e 0) \u003d\u003e (inlines \u003c\u003e []))","type invariant satisfiable obligation:(exists n:NavigationInput \u0026 (((len (n.departureLocation)) \u003e 0) and ((len (n.arrivalLocation)) \u003e 0)))","legal sequence application obligation:(forall navInput:NavigationInput, tokenDevice:TokenDevice \u0026 ((exists r in set (railway.getGrid)() \u0026 (((r(1).departureLocation) \u003d (navInput.departureLocation)) and ((r((len r)).arrivalLocation) \u003d (navInput.arrivalLocation)))) \u003d\u003e (forall r in set (railway.getGrid)() \u0026 (1 in set (inds r)))))","legal sequence application obligation:(forall navInput:NavigationInput, tokenDevice:TokenDevice \u0026 ((exists r in set (railway.getGrid)() \u0026 (((r(1).departureLocation) \u003d (navInput.departureLocation)) and ((r((len r)).arrivalLocation) \u003d (navInput.arrivalLocation)))) \u003d\u003e (forall r in set (railway.getGrid)() \u0026 (((r(1).departureLocation) \u003d (navInput.departureLocation)) \u003d\u003e ((len r) in set (inds r))))))","legal sequence application obligation:(forall navInput:NavigationInput, tokenDevice:TokenDevice \u0026 ((exists r in set (railway.getGrid)() \u0026 (((r(1).departureLocation) \u003d (navInput.departureLocation)) and ((r((len r)).arrivalLocation) \u003d (navInput.arrivalLocation)))) \u003d\u003e (forall r in set tempGrid \u0026 (1 in set (inds r)))))","legal sequence application obligation:(forall navInput:NavigationInput, tokenDevice:TokenDevice \u0026 ((exists r in set (railway.getGrid)() \u0026 (((r(1).departureLocation) \u003d (navInput.departureLocation)) and ((r((len r)).arrivalLocation) \u003d (navInput.arrivalLocation)))) \u003d\u003e (forall r in set tempGrid \u0026 (((r(1).departureLocation) \u003d (navInput.departureLocation)) \u003d\u003e ((len r) in set (inds r))))))","non-empty sequence obligation:(((len q_Env_in) \u003e 0) \u003d\u003e (q_Env_in \u003c\u003e []))","operation call obligation:(((len q_Env_in) \u003e 0) \u003d\u003e (forall normalState1:bool, curtime2:nat, railway3:RailwayGrid, q_APM_out4:ActivePlanManager, q_Env_in5:seq of (MessageT), q_APM_in6:seq of (MessageT), busy7:bool, timeout8:nat \u0026 (true \u003d\u003e ((len q_APM_in6) \u003e 0))))","non-empty sequence obligation:(((len q_APM_in) \u003e 0) \u003d\u003e (q_APM_in \u003c\u003e []))","operation call obligation:(((len q_APM_in) \u003e 0) \u003d\u003e (forall normalState1:bool, curtime2:nat, railway3:RailwayGrid, q_APM_out4:ActivePlanManager, q_Env_in5:seq of (MessageT), q_APM_in6:seq of (MessageT), busy7:bool, timeout8:nat \u0026 (true \u003d\u003e ((len q_APM_in6) \u003e 0))))","type compatibility obligation:(forall navi:NavigationInput, tokenDevice:TokenDevice \u0026 is_(calculateTransportPlan(navi, tokenDevice), DTO))","value binding obligation:(forall msg:MessageT \u0026 (exists mk_INACTIVEROUTE(routeid):MessageT \u0026 (mk_INACTIVEROUTE(routeid) \u003d msg)))","type compatibility obligation:(forall msg:MessageT \u0026 is_(msg, INACTIVEROUTE))","non-empty sequence obligation:(((len q_APM_in) \u003e 0) \u003d\u003e (q_APM_in \u003c\u003e []))","non-empty sequence obligation:(((len q_APM_in) \u003e 0) \u003d\u003e (q_Env_in \u003c\u003e []))","while loop termination obligation:...","type compatibility obligation:((i - 1) \u003e\u003d 0)","type invariant satisfiable obligation:(exists r:Route \u0026 (((len (r.platform)) \u003e 0) and (((len (r.arrivalLocation)) \u003e 0) and (((len (r.departureLocation)) \u003e 0) and ((r.fee) \u003e\u003d 0)))))","state invariant holds obligation:(forall routes:seq of (Route), pChoice:Choice, id_tok:nat \u0026 (((len routes) \u003e 0) \u003d\u003e (forall i in set (inds routeList) \u0026 ((i \u003c (len routeList)) \u003d\u003e ((routeList(i).arrivalLocation) \u003d (routeList((i + 1)).departureLocation))))))","non-empty sequence obligation:(((len routeList) \u003e 0) \u003d\u003e (routeList \u003c\u003e []))","legal sequence application obligation:(forall route:Route \u0026 (((routeList((len routeList)).arrivalLocation) \u003d (route.departureLocation)) \u003d\u003e ((len routeList) in set (inds routeList))))","state invariant holds obligation:(forall route:Route \u0026 (((routeList((len routeList)).arrivalLocation) \u003d (route.departureLocation)) \u003d\u003e ((((len routeList) \u003e 0) \u003d\u003e (forall i in set (inds routeList) \u0026 ((i \u003c (len routeList)) \u003d\u003e ((routeList(i).arrivalLocation) \u003d (routeList((i + 1)).departureLocation))))) \u003d\u003e (((len (routeList ^ [route])) \u003e 0) \u003d\u003e (forall i in set (inds routeList) \u0026 ((i \u003c (len routeList)) \u003d\u003e ((routeList(i).arrivalLocation) \u003d (routeList((i + 1)).departureLocation))))))))","state invariant holds obligation:(forall route:Route \u0026 (((routeList((len routeList)).arrivalLocation) \u003d (route.departureLocation)) \u003d\u003e ((((len (routeList ^ [route])) \u003e 0) \u003d\u003e (forall i in set (inds routeList) \u0026 ((i \u003c (len routeList)) \u003d\u003e ((routeList(i).arrivalLocation) \u003d (routeList((i + 1)).departureLocation))))) \u003d\u003e (((len (routeList ^ [route])) \u003e 0) \u003d\u003e (forall i in set (inds routeList) \u0026 ((i \u003c (len routeList)) \u003d\u003e ((routeList(i).arrivalLocation) \u003d (routeList((i + 1)).departureLocation))))))))","state invariant holds obligation:(((len routeList) \u003e 0) \u003d\u003e ((((len routeList) \u003e 0) \u003d\u003e (forall i in set (inds routeList) \u0026 ((i \u003c (len routeList)) \u003d\u003e ((routeList(i).arrivalLocation) \u003d (routeList((i + 1)).departureLocation))))) \u003d\u003e (((len routeList) \u003e 0) \u003d\u003e (forall i in set (inds routeList) \u0026 ((i \u003c (len routeList)) \u003d\u003e ((routeList(i).arrivalLocation) \u003d (routeList((i + 1)).departureLocation)))))))","non-empty sequence obligation:(((len routeList) \u003e 0) \u003d\u003e (routeList \u003c\u003e []))","state invariant holds obligation:(((len routeList) \u003e 0) \u003d\u003e ((((len routeList) \u003e 0) \u003d\u003e (forall i in set (inds routeList) \u0026 ((i \u003c (len routeList)) \u003d\u003e ((routeList(i).arrivalLocation) \u003d (routeList((i + 1)).departureLocation))))) \u003d\u003e (((len (tl routeList)) \u003e 0) \u003d\u003e (forall i in set (inds routeList) \u0026 ((i \u003c (len routeList)) \u003d\u003e ((routeList(i).arrivalLocation) \u003d (routeList((i + 1)).departureLocation)))))))","non-empty sequence obligation:(((len routeList) \u003e 0) \u003d\u003e (routeList \u003c\u003e []))","non-empty sequence obligation:(((len routeList) \u003e 0) \u003d\u003e (routeList \u003c\u003e []))","legal sequence application obligation:(((len routeList) \u003e 0) \u003d\u003e ((len routeList) in set (inds routeList)))","type compatibility obligation:(((len routeList) \u003e 0) \u003d\u003e (id_token \u003e 0))","type compatibility obligation:(((len routeList) \u003e 0) \u003d\u003e (inv_NavigationInput(mk_CyberRail`NavigationInput(((hd routeList).departureLocation), (routeList((len routeList)).arrivalLocation), choice, id_token)) and (id_token \u003e 0)))","legal sequence application obligation:(forall o:TransportPlan \u0026 (1 in set (inds (o.getRouteList)())))","legal sequence application obligation:(forall o:TransportPlan \u0026 ((len (o.getRouteList)()) in set (inds (o.getRouteList)())))","legal function application obligation:pre_(((io.fwriteval))[seq of (logType)]\"logger.log\", log, \u003cstart\u003e)","type compatibility obligation:(forall plan:[TransportPlan], route:[Route], t:nat \u0026 is_((outlines ^ [mk_(plan, route, t)]), seq of (outline)))","legal function application obligation:pre_(((io.fwriteval))[seq of (outline)]outfileName, outlines, \u003cstart\u003e)","legal function application obligation:(forall fname:seq of (char) \u0026 pre_(((io.freadval))[seq of (inline)]fname))","type compatibility obligation:(forall fname:seq of (char) \u0026 is_(input, seq of (inline)))","type compatibility obligation:inv_Route(mk_TransportPlan`Route(\"A\", \"B\", 42, \"P1\", 200, 1))","type compatibility obligation:inv_Route(mk_TransportPlan`Route(\"A\", \"C\", 42, \"P1\", 200, 2))","type compatibility obligation:inv_Route(mk_TransportPlan`Route(\"B\", \"C\", 99, \"P1\", 200, 3))","type compatibility obligation:inv_Route(mk_TransportPlan`Route(\"B\", \"D\", 42, \"P1\", 200, 4))","type compatibility obligation:inv_Route(mk_TransportPlan`Route(\"B\", \"A\", 42, \"P1\", 200, 5))","type compatibility obligation:inv_Route(mk_TransportPlan`Route(\"C\", \"D\", 42, \"P1\", 200, 6))","type compatibility obligation:inv_Route(mk_TransportPlan`Route(\"C\", \"A\", 42, \"P1\", 200, 7))","type compatibility obligation:inv_Route(mk_TransportPlan`Route(\"D\", \"B\", 42, \"P1\", 200, 8))","type compatibility obligation:inv_Route(mk_TransportPlan`Route(\"D\", \"C\", 42, \"P1\", 200, 9))","type compatibility obligation:inv_Route(mk_TransportPlan`Route(\"C\", \"B\", 99, \"P1\", 200, 10))","legal function application obligation:(forall grid:Grid \u0026 pre_(((io.fwriteval))[Grid]\"railway.txt\", grid, \u003cappend\u003e))","state invariant holds obligation:((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e (forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))))","state invariant holds obligation:((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e (forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))))","state invariant holds obligation:(forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y))))","state invariant holds obligation:(forall plan:TransportPlan, tokenDevice:TokenDevice \u0026 ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e (forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y))))))","type compatibility obligation:(forall plan:TransportPlan, tokenDevice:TokenDevice \u0026 is_((activeTokens ++ {tokenDevice |-\u003e plan}), inmap (TokenDevice) to (TransportPlan)))","state invariant holds obligation:(forall plan:TransportPlan, tokenDevice:TokenDevice \u0026 ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e (forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y))))))","state invariant holds obligation:(forall plan:TransportPlan, tokenDevice:TokenDevice \u0026 ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e (forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y))))))","operation call obligation:((len q_CR_in) \u003e 0)","operation call obligation:(forall activeTokens1:inmap (TokenDevice) to (TransportPlan), busy2:bool, q_CR_out3:CyberRail, tokenDevices4:set of (TokenDevice), q_Tok_in5:seq of (MessageT), q_CR_in6:seq of (MessageT), q_Tok_out7:seq of (TransportPlan), state8:State \u0026 ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e (((len q_Tok_out7) \u003e 0) and (exists plan in set (rng activeTokens) \u0026 (plan \u003d (hd q_Tok_out7))))))","operation call obligation:(forall activeTokens1:inmap (TokenDevice) to (TransportPlan), busy2:bool, q_CR_out3:CyberRail, tokenDevices4:set of (TokenDevice), q_Tok_in5:seq of (MessageT), q_CR_in6:seq of (MessageT), q_Tok_out7:seq of (TransportPlan), state8:State \u0026 ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e (forall activeTokens9:inmap (TokenDevice) to (TransportPlan), busy10:bool, q_CR_out11:CyberRail, tokenDevices12:set of (TokenDevice), q_Tok_in13:seq of (MessageT), q_CR_in14:seq of (MessageT), q_Tok_out15:seq of (TransportPlan), state16:State \u0026 ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e ((len q_Tok_in13) \u003e 0)))))","state invariant holds obligation:(forall activeTokens1:inmap (TokenDevice) to (TransportPlan), busy2:bool, q_CR_out3:CyberRail, tokenDevices4:set of (TokenDevice), q_Tok_in5:seq of (MessageT), q_CR_in6:seq of (MessageT), q_Tok_out7:seq of (TransportPlan), state8:State \u0026 ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e (forall activeTokens9:inmap (TokenDevice) to (TransportPlan), busy10:bool, q_CR_out11:CyberRail, tokenDevices12:set of (TokenDevice), q_Tok_in13:seq of (MessageT), q_CR_in14:seq of (MessageT), q_Tok_out15:seq of (TransportPlan), state16:State \u0026 ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e (forall activeTokens17:inmap (TokenDevice) to (TransportPlan), busy18:bool, q_CR_out19:CyberRail, tokenDevices20:set of (TokenDevice), q_Tok_in21:seq of (MessageT), q_CR_in22:seq of (MessageT), q_Tok_out23:seq of (TransportPlan), state24:State \u0026 ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e (forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))))))))))","non-empty sequence obligation:((((len q_Tok_out) \u003e 0) and (exists plan in set (rng activeTokens) \u0026 (plan \u003d (hd q_Tok_out)))) \u003d\u003e (((len q_Tok_out) \u003e 0) \u003d\u003e (forall plan in set (rng activeTokens) \u0026 (q_Tok_out \u003c\u003e []))))","map inverse obligation:((((len q_Tok_out) \u003e 0) and (exists plan in set (rng activeTokens) \u0026 (plan \u003d (hd q_Tok_out)))) \u003d\u003e is_(activeTokens, inmap (TokenDevice) to (TransportPlan)))","non-empty sequence obligation:((((len q_Tok_out) \u003e 0) and (exists plan in set (rng activeTokens) \u0026 (plan \u003d (hd q_Tok_out)))) \u003d\u003e (q_Tok_out \u003c\u003e []))","legal map application obligation:((((len q_Tok_out) \u003e 0) and (exists plan in set (rng activeTokens) \u0026 (plan \u003d (hd q_Tok_out)))) \u003d\u003e (plan in set (dom ptt_map)))","state invariant holds obligation:((((len q_Tok_out) \u003e 0) and (exists plan in set (rng activeTokens) \u0026 (plan \u003d (hd q_Tok_out)))) \u003d\u003e ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e (forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y))))))","non-empty sequence obligation:((((len q_Tok_out) \u003e 0) and (exists plan in set (rng activeTokens) \u0026 (plan \u003d (hd q_Tok_out)))) \u003d\u003e (q_Tok_out \u003c\u003e []))","state invariant holds obligation:(((len q_CR_in) \u003e 0) \u003d\u003e ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e (forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y))))))","non-empty sequence obligation:(((len q_CR_in) \u003e 0) \u003d\u003e (q_CR_in \u003c\u003e []))","operation call obligation:(((len q_CR_in) \u003e 0) \u003d\u003e (forall activeTokens1:inmap (TokenDevice) to (TransportPlan), busy2:bool, q_CR_out3:CyberRail, tokenDevices4:set of (TokenDevice), q_Tok_in5:seq of (MessageT), q_CR_in6:seq of (MessageT), q_Tok_out7:seq of (TransportPlan), state8:State \u0026 ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e (forall activeTokens9:inmap (TokenDevice) to (TransportPlan), busy10:bool, q_CR_out11:CyberRail, tokenDevices12:set of (TokenDevice), q_Tok_in13:seq of (MessageT), q_CR_in14:seq of (MessageT), q_Tok_out15:seq of (TransportPlan), state16:State \u0026 ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e (forall activeTokens17:inmap (TokenDevice) to (TransportPlan), busy18:bool, q_CR_out19:CyberRail, tokenDevices20:set of (TokenDevice), q_Tok_in21:seq of (MessageT), q_CR_in22:seq of (MessageT), q_Tok_out23:seq of (TransportPlan), state24:State \u0026 ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e (forall activeTokens25:inmap (TokenDevice) to (TransportPlan), busy26:bool, q_CR_out27:CyberRail, tokenDevices28:set of (TokenDevice), q_Tok_in29:seq of (MessageT), q_CR_in30:seq of (MessageT), q_Tok_out31:seq of (TransportPlan), state32:State \u0026 ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e ((len q_CR_in30) \u003e 0))))))))))","state invariant holds obligation:(((len q_Tok_in) \u003e 0) \u003d\u003e ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e (forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y))))))","non-empty sequence obligation:(((len q_Tok_in) \u003e 0) \u003d\u003e (q_Tok_in \u003c\u003e []))","operation call obligation:(((len q_Tok_in) \u003e 0) \u003d\u003e (forall activeTokens1:inmap (TokenDevice) to (TransportPlan), busy2:bool, q_CR_out3:CyberRail, tokenDevices4:set of (TokenDevice), q_Tok_in5:seq of (MessageT), q_CR_in6:seq of (MessageT), q_Tok_out7:seq of (TransportPlan), state8:State \u0026 ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e ((len q_Tok_in5) \u003e 0))))","state invariant holds obligation:(forall log1:seq of (logType) \u0026 (true \u003d\u003e (forall log2:seq of (logType) \u0026 (true \u003d\u003e ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e (forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))))))))","state invariant holds obligation:((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e (forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))))","value binding obligation:(forall msg:MessageT \u0026 (exists mk_STRATEGYNOTIFY(routeid):MessageT \u0026 (mk_STRATEGYNOTIFY(routeid) \u003d msg)))","type compatibility obligation:(forall msg:MessageT \u0026 is_(msg, STRATEGYNOTIFY))","value binding obligation:(forall msg:MessageT \u0026 (exists mk_RETURNPLAN(dto, tok):MessageT \u0026 (mk_RETURNPLAN(dto, tok) \u003d msg)))","type compatibility obligation:(forall msg:MessageT \u0026 is_(msg, RETURNPLAN))","value binding obligation:(forall msg:MessageT \u0026 (exists mk_REQUESTPLAN(navi, tok):MessageT \u0026 (mk_REQUESTPLAN(navi, tok) \u003d msg)))","type compatibility obligation:(forall msg:MessageT \u0026 is_(msg, REQUESTPLAN))","state invariant holds obligation:(((len q_Tok_in) \u003e 0) \u003d\u003e ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e (forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y))))))","non-empty sequence obligation:(((len q_Tok_in) \u003e 0) \u003d\u003e (q_Tok_in \u003c\u003e []))","state invariant holds obligation:(((len q_CR_in) \u003e 0) \u003d\u003e ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e (forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y))))))","non-empty sequence obligation:(((len q_CR_in) \u003e 0) \u003d\u003e (q_CR_in \u003c\u003e []))","state invariant holds obligation:(forall cr:CyberRail \u0026 ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e (forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y))))))","state invariant holds obligation:(forall msg:MessageT \u0026 ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e (forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y))))))","state invariant holds obligation:(forall msg:MessageT \u0026 ((forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y)))) \u003d\u003e (forall x, y in set (dom activeTokens) \u0026 ((x \u003d y) \u003d\u003e (activeTokens(x) \u003d activeTokens(y))))))","non-empty sequence obligation:(queue \u003c\u003e [])","non-empty sequence obligation:(queue \u003c\u003e [])","operation call obligation:(forall text:seq of (char) \u0026 ((\"\" \u003d \"\") \u003c\u003d\u003e (\"\" \u003d nil)))"] \ No newline at end of file diff --git a/core/pog/src/test/resources/examples/DigraphSL.result b/core/pog/src/test/resources/examples/DigraphSL.result index 7cdf7bb787..664fa697e7 100644 --- a/core/pog/src/test/resources/examples/DigraphSL.result +++ b/core/pog/src/test/resources/examples/DigraphSL.result @@ -1 +1 @@ -["type invariant satisfiable obligation:(exists N:GraphNodes \u0026 (((card N) \u003e 0) and (N \u003d {1, ... ,(card N)})))","type invariant satisfiable obligation:(exists G:FlowGraph \u0026 ((relations`field((G.A)) subset (G.N)) and (((G.S) in set (G.N)) and ((G.E) in set (G.N)))))","type invariant satisfiable obligation:(exists mk_ExtendedFlowGraph(G, U, D):ExtendedFlowGraph \u0026 (((len U) \u003d (card (G.N))) and ((len D) \u003d (card (G.N)))))","type compatibility obligation:inv_FlowGraph(mk_FlowGraph(N1, A1, 1, 4))","type compatibility obligation:inv_FlowGraph(mk_FlowGraph(N1, A2, 1, 4))","type compatibility obligation:inv_FlowGraph(mk_FlowGraph(N2, A3, 1, 6))","type compatibility obligation:inv_FlowGraph(mk_FlowGraph(N2, A5, 1, 7))","type compatibility obligation:inv_FlowGraph(mk_FlowGraph(N2, A6, 1, 5))","finite set obligation:(forall R:BinRel \u0026 (exists finmap1:map (nat) to (nat1) \u0026 (forall x:nat1 \u0026 ((exists y:nat1 \u0026 (mk_(x, y) in set R)) \u003d\u003e (exists findex2 in set (dom finmap1) \u0026 (finmap1(findex2) \u003d x))))))","legal function application obligation:(forall R:BinRel, x:nat1 \u0026 ((x \u003e 0) \u003d\u003e ((not (x \u003d 1)) \u003d\u003e pre_power_of(R, (x - 1)))))","type compatibility obligation:(forall R:BinRel, x:nat1 \u0026 ((x \u003e 0) \u003d\u003e ((not (x \u003d 1)) \u003d\u003e ((x - 1) \u003e 0))))","type compatibility obligation:(forall R:BinRel, k:nat \u0026 ((not (k \u003d 0)) \u003d\u003e ((not (k \u003d 1)) \u003d\u003e ((k - 1) \u003e\u003d 0))))","legal function application obligation:(forall R:BinRel \u0026 ((R \u003c\u003e {}) \u003d\u003e pre_BuildList(R, (card field(R)))))","type compatibility obligation:(forall R:BinRel \u0026 ((R \u003c\u003e {}) \u003d\u003e ((card field(R)) \u003e 0)))","legal function application obligation:(forall R:BinRel, n:nat1 \u0026 ((n \u003e 0) \u003d\u003e ((not (n \u003d 1)) \u003d\u003e pre_BuildList(R, (n - 1)))))","type compatibility obligation:(forall R:BinRel, n:nat1 \u0026 ((n \u003e 0) \u003d\u003e ((not (n \u003d 1)) \u003d\u003e ((n - 1) \u003e 0))))","legal sequence application obligation:(forall R:BinRel, n:nat1 \u0026 ((n \u003e 0) \u003d\u003e ((not (n \u003d 1)) \u003d\u003e ((len M) in set (inds M)))))","let be st existence obligation:(forall S:set of (int) \u0026 ((S \u003c\u003e {}) \u003d\u003e (exists x in set S \u0026 true)))","legal function application obligation:(forall S:set of (int) \u0026 ((S \u003c\u003e {}) \u003d\u003e (forall x in set S \u0026 ((not ((card S) \u003d 1)) \u003d\u003e pre_max_set((S \\ {x}))))))","legal function application obligation:(forall Q:BinRel \u0026 pre_max_set(field(R)))","legal function application obligation:(forall R:BinRel \u0026 pre_PowerList(R))","legal sequence application obligation:(forall R:BinRel \u0026 let L:seq of (BinRel) \u003d PowerList(R), n:nat \u003d (card field(R)) in (forall i in set (inds L) \u0026 (i in set (inds L))))"] \ No newline at end of file +["finite set obligation:(forall R:BinRel \u0026 (exists finmap1:map (nat) to (nat1) \u0026 (forall x:nat1 \u0026 ((exists y:nat1 \u0026 (mk_(x, y) in set R)) \u003d\u003e (exists findex2 in set (dom finmap1) \u0026 (finmap1(findex2) \u003d x))))))","legal function application obligation:(forall R:BinRel, x:nat1 \u0026 ((x \u003e 0) \u003d\u003e ((not (x \u003d 1)) \u003d\u003e pre_power_of(R, (x - 1)))))","type compatibility obligation:(forall R:BinRel, x:nat1 \u0026 ((x \u003e 0) \u003d\u003e ((not (x \u003d 1)) \u003d\u003e ((x - 1) \u003e 0))))","type compatibility obligation:(forall R:BinRel, k:nat \u0026 ((not (k \u003d 0)) \u003d\u003e ((not (k \u003d 1)) \u003d\u003e ((k - 1) \u003e\u003d 0))))","legal function application obligation:(forall R:BinRel \u0026 ((R \u003c\u003e {}) \u003d\u003e pre_BuildList(R, (card field(R)))))","type compatibility obligation:(forall R:BinRel \u0026 ((R \u003c\u003e {}) \u003d\u003e ((card field(R)) \u003e 0)))","legal function application obligation:(forall R:BinRel, n:nat1 \u0026 ((n \u003e 0) \u003d\u003e ((not (n \u003d 1)) \u003d\u003e pre_BuildList(R, (n - 1)))))","type compatibility obligation:(forall R:BinRel, n:nat1 \u0026 ((n \u003e 0) \u003d\u003e ((not (n \u003d 1)) \u003d\u003e ((n - 1) \u003e 0))))","legal sequence application obligation:(forall R:BinRel, n:nat1 \u0026 ((n \u003e 0) \u003d\u003e ((not (n \u003d 1)) \u003d\u003e ((len M) in set (inds M)))))","let be st existence obligation:(forall S:set of (int) \u0026 ((S \u003c\u003e {}) \u003d\u003e (exists x in set S \u0026 true)))","legal function application obligation:(forall S:set of (int) \u0026 ((S \u003c\u003e {}) \u003d\u003e (forall x in set S \u0026 ((not ((card S) \u003d 1)) \u003d\u003e pre_max_set((S \\ {x}))))))","legal function application obligation:(forall Q:BinRel \u0026 pre_max_set(field(R)))","legal function application obligation:(forall R:BinRel \u0026 pre_PowerList(R))","legal sequence application obligation:(forall R:BinRel \u0026 let L:seq of (BinRel) \u003d PowerList(R), n:nat \u003d (card field(R)) in (forall i in set (inds L) \u0026 (i in set (inds L))))","type invariant satisfiable obligation:(exists N:GraphNodes \u0026 (((card N) \u003e 0) and (N \u003d {1, ... ,(card N)})))","type invariant satisfiable obligation:(exists G:FlowGraph \u0026 ((relations`field((G.A)) subset (G.N)) and (((G.S) in set (G.N)) and ((G.E) in set (G.N)))))","type invariant satisfiable obligation:(exists mk_ExtendedFlowGraph(G, U, D):ExtendedFlowGraph \u0026 (((len U) \u003d (card (G.N))) and ((len D) \u003d (card (G.N)))))","type compatibility obligation:inv_FlowGraph(mk_FlowGraph(N1, A1, 1, 4))","type compatibility obligation:inv_FlowGraph(mk_FlowGraph(N1, A2, 1, 4))","type compatibility obligation:inv_FlowGraph(mk_FlowGraph(N2, A3, 1, 6))","type compatibility obligation:inv_FlowGraph(mk_FlowGraph(N2, A5, 1, 7))","type compatibility obligation:inv_FlowGraph(mk_FlowGraph(N2, A6, 1, 5))"] \ No newline at end of file diff --git a/core/pog/src/test/resources/examples/DiningPP.result b/core/pog/src/test/resources/examples/DiningPP.result index 10bc093ef2..46e0f77b46 100644 --- a/core/pog/src/test/resources/examples/DiningPP.result +++ b/core/pog/src/test/resources/examples/DiningPP.result @@ -1 +1 @@ -["type compatibility obligation:((turns - 1) \u003e\u003d 0)","while loop termination obligation:NotYetImplemented","type compatibility obligation:((forks - 1) \u003e\u003d 0)"] \ No newline at end of file +["type compatibility obligation:((turns - 1) \u003e\u003d 0)","while loop termination obligation:...","type compatibility obligation:((forks - 1) \u003e\u003d 0)"] \ No newline at end of file diff --git a/core/pog/src/test/resources/examples/HomeAutomationConcPP.result b/core/pog/src/test/resources/examples/HomeAutomationConcPP.result index 3b10e3e1ae..d82ec7b283 100644 --- a/core/pog/src/test/resources/examples/HomeAutomationConcPP.result +++ b/core/pog/src/test/resources/examples/HomeAutomationConcPP.result @@ -1 +1 @@ -["type compatibility obligation:((envTemp - 1) \u003e\u003d 0)","type compatibility obligation:((envHumid - 1) \u003e\u003d 0)","operation establishes postcondition obligation:(forall id:nat, type:nodeType \u0026 ((id not in set (dom NodeList)) \u003d\u003e (forall finished1:bool, print2:bool, TargetTemp3:nat, Temp4:nat, TargetHumid5:nat, Humid6:nat, NodeList7:map (nat) to (nodeType), Algo8:algType \u0026 (true \u003d\u003e ((card (dom NodeList7)) \u003d ((card (dom NodeList)) + 1))))))","legal map application obligation:(forall id:nat, type:nodeType \u0026 ((id in set (dom NodeList)) \u003d\u003e (id in set (dom NodeList))))","operation establishes postcondition obligation:(forall id:nat, type:nodeType \u0026 ((id in set (dom NodeList)) \u003d\u003e ((card (dom ({id} \u003c-: NodeList))) \u003d ((card (dom NodeList)) - 1))))","type compatibility obligation:((barrierCount - 1) \u003e\u003d 0)","while loop termination obligation:NotYetImplemented","legal map application obligation:(forall th in set (dom wakeUpMap) \u0026 (th in set (dom wakeUpMap)))","legal map application obligation:(forall th in set (dom wakeUpMap) \u0026 ((wakeUpMap(th) \u003c\u003e nil) \u003d\u003e (th in set (dom wakeUpMap))))","operation establishes postcondition obligation:(forall x in set (rng wakeUpMap) \u0026 ((x \u003d nil) or (x \u003e\u003d currentTime)))","legal function application obligation:(forall fname:seq of (char), p:nat1, isP:bool \u0026 pre_(((io.freadval))[(nat * seq of (inline))]fname))","non-empty sequence obligation:(inlines \u003c\u003e [])","non-empty sequence obligation:(true \u003d\u003e (true \u003d\u003e (inlines \u003c\u003e [])))","operation call obligation:(forall text:seq of (char) \u0026 ((\"\" \u003d \"\") \u003c\u003d\u003e (\"\" \u003d nil)))"] \ No newline at end of file +["type compatibility obligation:((envTemp - 1) \u003e\u003d 0)","type compatibility obligation:((envHumid - 1) \u003e\u003d 0)","operation establishes postcondition obligation:(forall id:nat, type:nodeType \u0026 ((id not in set (dom NodeList)) \u003d\u003e (forall finished1:bool, print2:bool, TargetTemp3:nat, Temp4:nat, TargetHumid5:nat, Humid6:nat, NodeList7:map (nat) to (nodeType), Algo8:algType \u0026 (true \u003d\u003e ((card (dom NodeList7)) \u003d ((card (dom NodeList)) + 1))))))","legal map application obligation:(forall id:nat, type:nodeType \u0026 ((id in set (dom NodeList)) \u003d\u003e (id in set (dom NodeList))))","operation establishes postcondition obligation:(forall id:nat, type:nodeType \u0026 ((id in set (dom NodeList)) \u003d\u003e ((card (dom ({id} \u003c-: NodeList))) \u003d ((card (dom NodeList)) - 1))))","type compatibility obligation:((barrierCount - 1) \u003e\u003d 0)","while loop termination obligation:...","legal map application obligation:(forall th in set (dom wakeUpMap) \u0026 (th in set (dom wakeUpMap)))","legal map application obligation:(forall th in set (dom wakeUpMap) \u0026 ((wakeUpMap(th) \u003c\u003e nil) \u003d\u003e (th in set (dom wakeUpMap))))","operation establishes postcondition obligation:(forall x in set (rng wakeUpMap) \u0026 ((x \u003d nil) or (x \u003e\u003d currentTime)))","legal function application obligation:(forall fname:seq of (char), p:nat1, isP:bool \u0026 pre_(((io.freadval))[(nat * seq of (inline))]fname))","non-empty sequence obligation:(inlines \u003c\u003e [])","non-empty sequence obligation:(true \u003d\u003e (true \u003d\u003e (inlines \u003c\u003e [])))","operation call obligation:(forall text:seq of (char) \u0026 ((\"\" \u003d \"\") \u003c\u003d\u003e (\"\" \u003d nil)))"] \ No newline at end of file diff --git a/core/pog/src/test/resources/examples/HomeautomationSeqPP.result b/core/pog/src/test/resources/examples/HomeautomationSeqPP.result index 032401a54c..7dfee8fb7c 100644 --- a/core/pog/src/test/resources/examples/HomeautomationSeqPP.result +++ b/core/pog/src/test/resources/examples/HomeautomationSeqPP.result @@ -1 +1 @@ -["type compatibility obligation:((envTemp - 1) \u003e\u003d 0)","type compatibility obligation:((envHumid - 1) \u003e\u003d 0)","operation establishes postcondition obligation:(forall id:nat, type:nodeType \u0026 ((id not in set (dom NodeList)) \u003d\u003e (forall finished1:bool, print2:bool, TargetTemp3:nat, Temp4:nat, TargetHumid5:nat, Humid6:nat, NodeList7:map (nat) to (nodeType), Algo8:algType \u0026 (true \u003d\u003e ((card (dom NodeList7)) \u003d ((card (dom NodeList)) + 1))))))","legal map application obligation:(forall id:nat, type:nodeType \u0026 ((id in set (dom NodeList)) \u003d\u003e (id in set (dom NodeList))))","operation establishes postcondition obligation:(forall id:nat, type:nodeType \u0026 ((id in set (dom NodeList)) \u003d\u003e (forall finished1:bool, print2:bool, TargetTemp3:nat, Temp4:nat, TargetHumid5:nat, Humid6:nat, NodeList7:map (nat) to (nodeType), Algo8:algType \u0026 (true \u003d\u003e ((card (dom NodeList7)) \u003d ((card (dom NodeList)) - 1))))))","legal function application obligation:(forall fname:seq of (char) \u0026 pre_(((io.freadval))[(nat * seq of (inline))]fname))","while loop termination obligation:NotYetImplemented","non-empty sequence obligation:(inlines \u003c\u003e [])","non-empty sequence obligation:(forall envTemp1:nat, envHumid2:nat, ha3:HA, io4:IO, inlines5:seq of (inline), simtime6:nat, finished7:bool \u0026 (true \u003d\u003e (forall envTemp8:nat, envHumid9:nat, ha10:HA, io11:IO, inlines12:seq of (inline), simtime13:nat, finished14:bool \u0026 (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (inlines12 \u003c\u003e []))))))))","type compatibility obligation:((envTemp - 1) \u003e\u003d 0)","type compatibility obligation:((envHumid - 1) \u003e\u003d 0)","operation call obligation:(forall text:seq of (char) \u0026 ((\"\" \u003d \"\") \u003c\u003d\u003e (\"\" \u003d nil)))"] \ No newline at end of file +["type compatibility obligation:((envTemp - 1) \u003e\u003d 0)","type compatibility obligation:((envHumid - 1) \u003e\u003d 0)","operation establishes postcondition obligation:(forall id:nat, type:nodeType \u0026 ((id not in set (dom NodeList)) \u003d\u003e (forall finished1:bool, print2:bool, TargetTemp3:nat, Temp4:nat, TargetHumid5:nat, Humid6:nat, NodeList7:map (nat) to (nodeType), Algo8:algType \u0026 (true \u003d\u003e ((card (dom NodeList7)) \u003d ((card (dom NodeList)) + 1))))))","legal map application obligation:(forall id:nat, type:nodeType \u0026 ((id in set (dom NodeList)) \u003d\u003e (id in set (dom NodeList))))","operation establishes postcondition obligation:(forall id:nat, type:nodeType \u0026 ((id in set (dom NodeList)) \u003d\u003e (forall finished1:bool, print2:bool, TargetTemp3:nat, Temp4:nat, TargetHumid5:nat, Humid6:nat, NodeList7:map (nat) to (nodeType), Algo8:algType \u0026 (true \u003d\u003e ((card (dom NodeList7)) \u003d ((card (dom NodeList)) - 1))))))","legal function application obligation:(forall fname:seq of (char) \u0026 pre_(((io.freadval))[(nat * seq of (inline))]fname))","while loop termination obligation:...","non-empty sequence obligation:(inlines \u003c\u003e [])","non-empty sequence obligation:(forall envTemp1:nat, envHumid2:nat, ha3:HA, io4:IO, inlines5:seq of (inline), simtime6:nat, finished7:bool \u0026 (true \u003d\u003e (forall envTemp8:nat, envHumid9:nat, ha10:HA, io11:IO, inlines12:seq of (inline), simtime13:nat, finished14:bool \u0026 (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (inlines12 \u003c\u003e []))))))))","type compatibility obligation:((envTemp - 1) \u003e\u003d 0)","type compatibility obligation:((envHumid - 1) \u003e\u003d 0)","operation call obligation:(forall text:seq of (char) \u0026 ((\"\" \u003d \"\") \u003c\u003d\u003e (\"\" \u003d nil)))"] \ No newline at end of file diff --git a/core/pog/src/test/resources/examples/HubInSafeModePP.result b/core/pog/src/test/resources/examples/HubInSafeModePP.result index 256a948ae3..c35ba9e478 100644 --- a/core/pog/src/test/resources/examples/HubInSafeModePP.result +++ b/core/pog/src/test/resources/examples/HubInSafeModePP.result @@ -1 +1 @@ -["type compatibility obligation:inv_WindSpeedType(15)","type compatibility obligation:inv_WindSpeedType(14)","type compatibility obligation:inv_WindSpeedType(15)","type compatibility obligation:inv_WindSpeedType(15)","type compatibility obligation:inv_WindSpeedType(16)","type compatibility obligation:((mAlarm - 1) \u003e\u003d 0)","state invariant holds obligation:(forall eStopSeq:seq of (bool), mainShaftController:MainShaftController \u0026 (forall mHubController1:[HubController], mEnterHubInSafeMode2:bool \u0026 (true \u003d\u003e Mode`HubInSafeModeInv(mMode, (mMainShaftController.GetRPM)(), (mMainShaftController.IsLocked)(), (mHub.IsOpen)()))))","state invariant holds obligation:(forall mode:Mode \u0026 ((Mode`StateChangeInv(mMode, mode) and Mode`HubInSafeModeInv(mode, (mMainShaftController.GetRPM)(), (mMainShaftController.IsLocked)(), (mHub.IsOpen)())) \u003d\u003e (Mode`HubInSafeModeInv(mMode, (mMainShaftController.GetRPM)(), (mMainShaftController.IsLocked)(), (mHub.IsOpen)()) \u003d\u003e Mode`HubInSafeModeInv(mMode, (mMainShaftController.GetRPM)(), (mMainShaftController.IsLocked)(), (mHub.IsOpen)()))))","non-empty sequence obligation:(mEStopSeq \u003c\u003e [])","state invariant holds obligation:(Mode`HubInSafeModeInv(mMode, (mMainShaftController.GetRPM)(), (mMainShaftController.IsLocked)(), (mHub.IsOpen)()) \u003d\u003e Mode`HubInSafeModeInv(mMode, (mMainShaftController.GetRPM)(), (mMainShaftController.IsLocked)(), (mHub.IsOpen)()))","non-empty sequence obligation:(mEStopSeq \u003c\u003e [])","non-empty sequence obligation:(mCmdSeq \u003c\u003e [])","non-empty sequence obligation:(mCmdSeq \u003c\u003e [])","type invariant satisfiable obligation:(exists w:WindSpeedType \u0026 (w \u003c\u003d 50))","type compatibility obligation:inv_WindSpeedType(50)","type compatibility obligation:((mInstance \u003c\u003e nil) \u003d\u003e is_(RESULT, WindMeasurementController))","non-empty sequence obligation:((mWindSpeedSeq \u003c\u003e []) \u003d\u003e (mWindSpeedSeq \u003c\u003e []))","non-empty sequence obligation:(mWindSpeedSeq \u003c\u003e [])","legal sequence application obligation:(forall testData:seq of (TestData) \u0026 (forall i in set (inds testData) \u0026 (i in set (inds testData))))","legal sequence application obligation:(forall testData:seq of (TestData) \u0026 (forall mWindSpeedSeq1:seq of (WindSpeedType), mInstance2:[WindMeasurementController] \u0026 (true \u003d\u003e (forall i in set (inds testData) \u0026 (i in set (inds testData))))))","legal sequence application obligation:(forall testData:seq of (TestData) \u0026 (forall mWindSpeedSeq1:seq of (WindSpeedType), mInstance2:[WindMeasurementController] \u0026 (true \u003d\u003e (forall i in set (inds testData) \u0026 (i in set (inds testData))))))","while loop termination obligation:NotYetImplemented","type compatibility obligation:inv_RPMType(1)","type compatibility obligation:inv_RPMType((WindMeasurementController`MAX_WIND * 10))","type invariant satisfiable obligation:(exists rpm:RPMType \u0026 (rpm \u003c\u003d (WindMeasurementController`MAX_WIND * 10)))","type compatibility obligation:inv_RPMType(0)","legal sequence application obligation:(forall brakeSeq:seq of (Brake) \u0026 (forall i in set (inds brakeSeq) \u0026 ((i \u003e 1) \u003d\u003e ((i - 1) in set (inds brakeSeq)))))","legal sequence application obligation:(forall brakeSeq:seq of (Brake) \u0026 (forall i in set (inds brakeSeq) \u0026 ((i \u003e 1) \u003d\u003e (i in set (inds brakeSeq)))))","operation call obligation:BrakeSeqInv((mBrakeSeq ^ [brake]))","operation call obligation:(forall mIsLocked1:bool, mBrakeSeq2:seq of (Brake), mRPM3:RPMType, mIsBrakeApplied4:bool \u0026 (BrakeSeqInv(mBrakeSeq) \u003d\u003e BrakeSeqInv((mBrakeSeq ^ [brake]))))","operation call obligation:(forall mIsLocked1:bool, mBrakeSeq2:seq of (Brake), mRPM3:RPMType, mIsBrakeApplied4:bool \u0026 (BrakeSeqInv(mBrakeSeq) \u003d\u003e (forall mIsLocked5:bool, mBrakeSeq6:seq of (Brake), mRPM7:RPMType, mIsBrakeApplied8:bool \u0026 (BrakeSeqInv(mBrakeSeq) \u003d\u003e BrakeSeqInv((mBrakeSeq ^ [brake]))))))","operation call obligation:(forall mIsLocked1:bool, mBrakeSeq2:seq of (Brake), mRPM3:RPMType, mIsBrakeApplied4:bool \u0026 (BrakeSeqInv(mBrakeSeq) \u003d\u003e (forall mIsLocked5:bool, mBrakeSeq6:seq of (Brake), mRPM7:RPMType, mIsBrakeApplied8:bool \u0026 (BrakeSeqInv(mBrakeSeq) \u003d\u003e (forall mIsLocked9:bool, mBrakeSeq10:seq of (Brake), mRPM11:RPMType, mIsBrakeApplied12:bool \u0026 (BrakeSeqInv(mBrakeSeq) \u003d\u003e BrakeSeqInv((mBrakeSeq ^ [brake]))))))))","state invariant holds obligation:(forall mIsLocked1:bool, mBrakeSeq2:seq of (Brake), mRPM3:RPMType, mIsBrakeApplied4:bool \u0026 (BrakeSeqInv(mBrakeSeq) \u003d\u003e (forall mIsLocked5:bool, mBrakeSeq6:seq of (Brake), mRPM7:RPMType, mIsBrakeApplied8:bool \u0026 (BrakeSeqInv(mBrakeSeq) \u003d\u003e (forall mIsLocked9:bool, mBrakeSeq10:seq of (Brake), mRPM11:RPMType, mIsBrakeApplied12:bool \u0026 (BrakeSeqInv(mBrakeSeq) \u003d\u003e (forall mIsLocked13:bool, mBrakeSeq14:seq of (Brake), mRPM15:RPMType, mIsBrakeApplied16:bool \u0026 (BrakeSeqInv(mBrakeSeq) \u003d\u003e BrakeSeqInv(mBrakeSeq)))))))))","state invariant holds obligation:(((not IsLocked()) and ((GetRPM() \u003d 0) and IsBrakeApplied())) \u003d\u003e (BrakeSeqInv(mBrakeSeq) \u003d\u003e BrakeSeqInv(mBrakeSeq)))","state invariant holds obligation:((IsLocked() and ((GetRPM() \u003d 0) and IsBrakeApplied())) \u003d\u003e (BrakeSeqInv(mBrakeSeq) \u003d\u003e BrakeSeqInv(mBrakeSeq)))","state invariant holds obligation:(forall brake:Brake \u0026 (BrakeSeqInv((mBrakeSeq ^ [brake])) \u003d\u003e (BrakeSeqInv(mBrakeSeq) \u003d\u003e BrakeSeqInv(mBrakeSeq))))","legal sequence application obligation:(forall brake:Brake \u0026 (((exists i in set (inds mBrakeSeq) \u0026 (mBrakeSeq(i).IsEqual)(brake)) and BrakeSeqInv([mBrakeSeq(i) | i in set (inds mBrakeSeq) \u0026 (not (mBrakeSeq(i).IsEqual)(brake))])) \u003d\u003e (forall i in set (inds mBrakeSeq) \u0026 (i in set (inds mBrakeSeq)))))","legal sequence application obligation:(forall brake:Brake \u0026 (((exists i in set (inds mBrakeSeq) \u0026 (mBrakeSeq(i).IsEqual)(brake)) and BrakeSeqInv([mBrakeSeq(i) | i in set (inds mBrakeSeq) \u0026 (not (mBrakeSeq(i).IsEqual)(brake))])) \u003d\u003e ((exists i in set (inds mBrakeSeq) \u0026 (mBrakeSeq(i).IsEqual)(brake)) \u003d\u003e (forall i in set (inds mBrakeSeq) \u0026 ((not (mBrakeSeq(i).IsEqual)(brake)) \u003d\u003e (i in set (inds mBrakeSeq)))))))","legal sequence application obligation:(forall brake:Brake \u0026 (((exists i in set (inds mBrakeSeq) \u0026 (mBrakeSeq(i).IsEqual)(brake)) and BrakeSeqInv([mBrakeSeq(i) | i in set (inds mBrakeSeq) \u0026 (not (mBrakeSeq(i).IsEqual)(brake))])) \u003d\u003e ((exists i in set (inds mBrakeSeq) \u0026 (mBrakeSeq(i).IsEqual)(brake)) \u003d\u003e (forall i in set (inds mBrakeSeq) \u0026 (i in set (inds mBrakeSeq))))))","state invariant holds obligation:(forall brake:Brake \u0026 (((exists i in set (inds mBrakeSeq) \u0026 (mBrakeSeq(i).IsEqual)(brake)) and BrakeSeqInv([mBrakeSeq(i) | i in set (inds mBrakeSeq) \u0026 (not (mBrakeSeq(i).IsEqual)(brake))])) \u003d\u003e (BrakeSeqInv(mBrakeSeq) \u003d\u003e BrakeSeqInv(mBrakeSeq))))","legal sequence application obligation:(forall brake:Brake \u0026 (((exists i in set (inds mBrakeSeq) \u0026 (mBrakeSeq(i).IsEqual)(brake)) and BrakeSeqInv([mBrakeSeq(i) | i in set (inds mBrakeSeq) \u0026 (not (mBrakeSeq(i).IsEqual)(brake))])) \u003d\u003e (forall i in set (inds mBrakeSeq) \u0026 ((not (mBrakeSeq(i).IsEqual)(brake)) \u003d\u003e (i in set (inds mBrakeSeq))))))","legal sequence application obligation:(forall brake:Brake \u0026 (((exists i in set (inds mBrakeSeq) \u0026 (mBrakeSeq(i).IsEqual)(brake)) and BrakeSeqInv([mBrakeSeq(i) | i in set (inds mBrakeSeq) \u0026 (not (mBrakeSeq(i).IsEqual)(brake))])) \u003d\u003e (forall i in set (inds mBrakeSeq) \u0026 (i in set (inds mBrakeSeq)))))","state invariant holds obligation:(((len mBrakeSeq) \u003c\u003e 0) \u003d\u003e (BrakeSeqInv(mBrakeSeq) \u003d\u003e BrakeSeqInv(mBrakeSeq)))","state invariant holds obligation:(((len mBrakeSeq) \u003c\u003e 0) \u003d\u003e (BrakeSeqInv(mBrakeSeq) \u003d\u003e BrakeSeqInv(mBrakeSeq)))","state invariant holds obligation:(((len mBrakeSeq) \u003c\u003e 0) \u003d\u003e (BrakeSeqInv(mBrakeSeq) \u003d\u003e BrakeSeqInv(mBrakeSeq)))","legal sequence application obligation:(((len mBrakeSeq) \u003c\u003e 0) \u003d\u003e (i in set (inds mBrakeSeq)))","state invariant holds obligation:(((len mBrakeSeq) \u003c\u003e 0) \u003d\u003e (BrakeSeqInv(mBrakeSeq) \u003d\u003e BrakeSeqInv(mBrakeSeq)))","type compatibility obligation:(((len mBrakeSeq) \u003c\u003e 0) \u003d\u003e inv_RPMType(((WindMeasurementController`GetInstance().GetWindSpeed)() * 10)))","operation establishes postcondition obligation:(((len mBrakeSeq) \u003c\u003e 0) \u003d\u003e (((WindMeasurementController`GetInstance().GetWindSpeed)() * 10) \u003c\u003d MAX_RPM))","operation call obligation:(forall text:seq of (char) \u0026 ((\"\" \u003d \"\") \u003c\u003d\u003e (\"\" \u003d nil)))"] \ No newline at end of file +["type compatibility obligation:inv_WindSpeedType(15)","type compatibility obligation:inv_WindSpeedType(14)","type compatibility obligation:inv_WindSpeedType(15)","type compatibility obligation:inv_WindSpeedType(15)","type compatibility obligation:inv_WindSpeedType(16)","type compatibility obligation:((mAlarm - 1) \u003e\u003d 0)","state invariant holds obligation:(forall eStopSeq:seq of (bool), mainShaftController:MainShaftController \u0026 (forall mHubController1:[HubController], mEnterHubInSafeMode2:bool \u0026 (true \u003d\u003e Mode`HubInSafeModeInv(mMode, (mMainShaftController.GetRPM)(), (mMainShaftController.IsLocked)(), (mHub.IsOpen)()))))","state invariant holds obligation:(forall mode:Mode \u0026 ((Mode`StateChangeInv(mMode, mode) and Mode`HubInSafeModeInv(mode, (mMainShaftController.GetRPM)(), (mMainShaftController.IsLocked)(), (mHub.IsOpen)())) \u003d\u003e (Mode`HubInSafeModeInv(mMode, (mMainShaftController.GetRPM)(), (mMainShaftController.IsLocked)(), (mHub.IsOpen)()) \u003d\u003e Mode`HubInSafeModeInv(mMode, (mMainShaftController.GetRPM)(), (mMainShaftController.IsLocked)(), (mHub.IsOpen)()))))","non-empty sequence obligation:(mEStopSeq \u003c\u003e [])","state invariant holds obligation:(Mode`HubInSafeModeInv(mMode, (mMainShaftController.GetRPM)(), (mMainShaftController.IsLocked)(), (mHub.IsOpen)()) \u003d\u003e Mode`HubInSafeModeInv(mMode, (mMainShaftController.GetRPM)(), (mMainShaftController.IsLocked)(), (mHub.IsOpen)()))","non-empty sequence obligation:(mEStopSeq \u003c\u003e [])","non-empty sequence obligation:(mCmdSeq \u003c\u003e [])","non-empty sequence obligation:(mCmdSeq \u003c\u003e [])","type invariant satisfiable obligation:(exists w:WindSpeedType \u0026 (w \u003c\u003d 50))","type compatibility obligation:inv_WindSpeedType(50)","type compatibility obligation:((mInstance \u003c\u003e nil) \u003d\u003e is_(RESULT, WindMeasurementController))","non-empty sequence obligation:((mWindSpeedSeq \u003c\u003e []) \u003d\u003e (mWindSpeedSeq \u003c\u003e []))","non-empty sequence obligation:(mWindSpeedSeq \u003c\u003e [])","legal sequence application obligation:(forall testData:seq of (TestData) \u0026 (forall i in set (inds testData) \u0026 (i in set (inds testData))))","legal sequence application obligation:(forall testData:seq of (TestData) \u0026 (forall mWindSpeedSeq1:seq of (WindSpeedType), mInstance2:[WindMeasurementController] \u0026 (true \u003d\u003e (forall i in set (inds testData) \u0026 (i in set (inds testData))))))","legal sequence application obligation:(forall testData:seq of (TestData) \u0026 (forall mWindSpeedSeq1:seq of (WindSpeedType), mInstance2:[WindMeasurementController] \u0026 (true \u003d\u003e (forall i in set (inds testData) \u0026 (i in set (inds testData))))))","while loop termination obligation:...","type compatibility obligation:inv_RPMType(1)","type compatibility obligation:inv_RPMType((WindMeasurementController`MAX_WIND * 10))","type invariant satisfiable obligation:(exists rpm:RPMType \u0026 (rpm \u003c\u003d (WindMeasurementController`MAX_WIND * 10)))","type compatibility obligation:inv_RPMType(0)","legal sequence application obligation:(forall brakeSeq:seq of (Brake) \u0026 (forall i in set (inds brakeSeq) \u0026 ((i \u003e 1) \u003d\u003e ((i - 1) in set (inds brakeSeq)))))","legal sequence application obligation:(forall brakeSeq:seq of (Brake) \u0026 (forall i in set (inds brakeSeq) \u0026 ((i \u003e 1) \u003d\u003e (i in set (inds brakeSeq)))))","operation call obligation:BrakeSeqInv((mBrakeSeq ^ [brake]))","operation call obligation:(forall mIsLocked1:bool, mBrakeSeq2:seq of (Brake), mRPM3:RPMType, mIsBrakeApplied4:bool \u0026 (BrakeSeqInv(mBrakeSeq) \u003d\u003e BrakeSeqInv((mBrakeSeq ^ [brake]))))","operation call obligation:(forall mIsLocked1:bool, mBrakeSeq2:seq of (Brake), mRPM3:RPMType, mIsBrakeApplied4:bool \u0026 (BrakeSeqInv(mBrakeSeq) \u003d\u003e (forall mIsLocked5:bool, mBrakeSeq6:seq of (Brake), mRPM7:RPMType, mIsBrakeApplied8:bool \u0026 (BrakeSeqInv(mBrakeSeq) \u003d\u003e BrakeSeqInv((mBrakeSeq ^ [brake]))))))","operation call obligation:(forall mIsLocked1:bool, mBrakeSeq2:seq of (Brake), mRPM3:RPMType, mIsBrakeApplied4:bool \u0026 (BrakeSeqInv(mBrakeSeq) \u003d\u003e (forall mIsLocked5:bool, mBrakeSeq6:seq of (Brake), mRPM7:RPMType, mIsBrakeApplied8:bool \u0026 (BrakeSeqInv(mBrakeSeq) \u003d\u003e (forall mIsLocked9:bool, mBrakeSeq10:seq of (Brake), mRPM11:RPMType, mIsBrakeApplied12:bool \u0026 (BrakeSeqInv(mBrakeSeq) \u003d\u003e BrakeSeqInv((mBrakeSeq ^ [brake]))))))))","state invariant holds obligation:(forall mIsLocked1:bool, mBrakeSeq2:seq of (Brake), mRPM3:RPMType, mIsBrakeApplied4:bool \u0026 (BrakeSeqInv(mBrakeSeq) \u003d\u003e (forall mIsLocked5:bool, mBrakeSeq6:seq of (Brake), mRPM7:RPMType, mIsBrakeApplied8:bool \u0026 (BrakeSeqInv(mBrakeSeq) \u003d\u003e (forall mIsLocked9:bool, mBrakeSeq10:seq of (Brake), mRPM11:RPMType, mIsBrakeApplied12:bool \u0026 (BrakeSeqInv(mBrakeSeq) \u003d\u003e (forall mIsLocked13:bool, mBrakeSeq14:seq of (Brake), mRPM15:RPMType, mIsBrakeApplied16:bool \u0026 (BrakeSeqInv(mBrakeSeq) \u003d\u003e BrakeSeqInv(mBrakeSeq)))))))))","state invariant holds obligation:(((not IsLocked()) and ((GetRPM() \u003d 0) and IsBrakeApplied())) \u003d\u003e (BrakeSeqInv(mBrakeSeq) \u003d\u003e BrakeSeqInv(mBrakeSeq)))","state invariant holds obligation:((IsLocked() and ((GetRPM() \u003d 0) and IsBrakeApplied())) \u003d\u003e (BrakeSeqInv(mBrakeSeq) \u003d\u003e BrakeSeqInv(mBrakeSeq)))","state invariant holds obligation:(forall brake:Brake \u0026 (BrakeSeqInv((mBrakeSeq ^ [brake])) \u003d\u003e (BrakeSeqInv(mBrakeSeq) \u003d\u003e BrakeSeqInv(mBrakeSeq))))","legal sequence application obligation:(forall brake:Brake \u0026 (((exists i in set (inds mBrakeSeq) \u0026 (mBrakeSeq(i).IsEqual)(brake)) and BrakeSeqInv([mBrakeSeq(i) | i in set (inds mBrakeSeq) \u0026 (not (mBrakeSeq(i).IsEqual)(brake))])) \u003d\u003e (forall i in set (inds mBrakeSeq) \u0026 (i in set (inds mBrakeSeq)))))","legal sequence application obligation:(forall brake:Brake \u0026 (((exists i in set (inds mBrakeSeq) \u0026 (mBrakeSeq(i).IsEqual)(brake)) and BrakeSeqInv([mBrakeSeq(i) | i in set (inds mBrakeSeq) \u0026 (not (mBrakeSeq(i).IsEqual)(brake))])) \u003d\u003e ((exists i in set (inds mBrakeSeq) \u0026 (mBrakeSeq(i).IsEqual)(brake)) \u003d\u003e (forall i in set (inds mBrakeSeq) \u0026 ((not (mBrakeSeq(i).IsEqual)(brake)) \u003d\u003e (i in set (inds mBrakeSeq)))))))","legal sequence application obligation:(forall brake:Brake \u0026 (((exists i in set (inds mBrakeSeq) \u0026 (mBrakeSeq(i).IsEqual)(brake)) and BrakeSeqInv([mBrakeSeq(i) | i in set (inds mBrakeSeq) \u0026 (not (mBrakeSeq(i).IsEqual)(brake))])) \u003d\u003e ((exists i in set (inds mBrakeSeq) \u0026 (mBrakeSeq(i).IsEqual)(brake)) \u003d\u003e (forall i in set (inds mBrakeSeq) \u0026 (i in set (inds mBrakeSeq))))))","state invariant holds obligation:(forall brake:Brake \u0026 (((exists i in set (inds mBrakeSeq) \u0026 (mBrakeSeq(i).IsEqual)(brake)) and BrakeSeqInv([mBrakeSeq(i) | i in set (inds mBrakeSeq) \u0026 (not (mBrakeSeq(i).IsEqual)(brake))])) \u003d\u003e (BrakeSeqInv(mBrakeSeq) \u003d\u003e BrakeSeqInv(mBrakeSeq))))","legal sequence application obligation:(forall brake:Brake \u0026 (((exists i in set (inds mBrakeSeq) \u0026 (mBrakeSeq(i).IsEqual)(brake)) and BrakeSeqInv([mBrakeSeq(i) | i in set (inds mBrakeSeq) \u0026 (not (mBrakeSeq(i).IsEqual)(brake))])) \u003d\u003e (forall i in set (inds mBrakeSeq) \u0026 ((not (mBrakeSeq(i).IsEqual)(brake)) \u003d\u003e (i in set (inds mBrakeSeq))))))","legal sequence application obligation:(forall brake:Brake \u0026 (((exists i in set (inds mBrakeSeq) \u0026 (mBrakeSeq(i).IsEqual)(brake)) and BrakeSeqInv([mBrakeSeq(i) | i in set (inds mBrakeSeq) \u0026 (not (mBrakeSeq(i).IsEqual)(brake))])) \u003d\u003e (forall i in set (inds mBrakeSeq) \u0026 (i in set (inds mBrakeSeq)))))","state invariant holds obligation:(((len mBrakeSeq) \u003c\u003e 0) \u003d\u003e (BrakeSeqInv(mBrakeSeq) \u003d\u003e BrakeSeqInv(mBrakeSeq)))","state invariant holds obligation:(((len mBrakeSeq) \u003c\u003e 0) \u003d\u003e (BrakeSeqInv(mBrakeSeq) \u003d\u003e BrakeSeqInv(mBrakeSeq)))","state invariant holds obligation:(((len mBrakeSeq) \u003c\u003e 0) \u003d\u003e (BrakeSeqInv(mBrakeSeq) \u003d\u003e BrakeSeqInv(mBrakeSeq)))","legal sequence application obligation:(((len mBrakeSeq) \u003c\u003e 0) \u003d\u003e (i in set (inds mBrakeSeq)))","state invariant holds obligation:(((len mBrakeSeq) \u003c\u003e 0) \u003d\u003e (BrakeSeqInv(mBrakeSeq) \u003d\u003e BrakeSeqInv(mBrakeSeq)))","type compatibility obligation:(((len mBrakeSeq) \u003c\u003e 0) \u003d\u003e inv_RPMType(((WindMeasurementController`GetInstance().GetWindSpeed)() * 10)))","operation establishes postcondition obligation:(((len mBrakeSeq) \u003c\u003e 0) \u003d\u003e (((WindMeasurementController`GetInstance().GetWindSpeed)() * 10) \u003c\u003d MAX_RPM))","operation call obligation:(forall text:seq of (char) \u0026 ((\"\" \u003d \"\") \u003c\u003d\u003e (\"\" \u003d nil)))"] \ No newline at end of file diff --git a/core/pog/src/test/resources/examples/LUPSL.result b/core/pog/src/test/resources/examples/LUPSL.result index 27856dc08a..0262e605c4 100644 --- a/core/pog/src/test/resources/examples/LUPSL.result +++ b/core/pog/src/test/resources/examples/LUPSL.result @@ -1 +1 @@ -["function establishes postcondition obligation:(forall s:set of (int) \u0026 (pre_MaxOfSet(s) \u003d\u003e post_MaxOfSet(s, let e in set s in (if ((card s) \u003d 1)\nthen e\nelse let mr:int \u003d MaxOfSet((s \\ {e})) in (if (e \u003e mr)\nthen e\nelse mr)))))","let be st existence obligation:(forall s:set of (int) \u0026 ((s \u003c\u003e {}) \u003d\u003e (exists e in set s \u0026 true)))","legal function application obligation:(forall s:set of (int) \u0026 ((s \u003c\u003e {}) \u003d\u003e (forall e in set s \u0026 ((not ((card s) \u003d 1)) \u003d\u003e pre_MaxOfSet((s \\ {e}))))))","recursive function obligation:(forall s:set of (int) \u0026 ((s \u003c\u003e {}) \u003d\u003e (forall e in set s \u0026 ((not ((card s) \u003d 1)) \u003d\u003e (CardInt(s) \u003e CardInt((s \\ {e})))))))","legal sequence application obligation:(forall a:array, k:nat1 \u0026 (forall j in set {1, ... ,(k - 1)} \u0026 (j in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1 \u0026 (forall j in set {1, ... ,(k - 1)} \u0026 (k in set (inds a))))","legal function application obligation:(forall a:array, k:nat1 \u0026 let compatible:set of (nat) \u003d {lupsltok(a, j) | j in set {1, ... ,(k - 1)} \u0026 (a(j) \u003c\u003d a(k))} in ((not (compatible \u003d {})) \u003d\u003e pre_MaxOfSet(compatible)))","type compatibility obligation:(forall a:array, k:nat1 \u0026 (let compatible:set of (nat) \u003d {lupsltok(a, j) | j in set {1, ... ,(k - 1)} \u0026 (a(j) \u003c\u003d a(k))} in (if (compatible \u003d {})\nthen 1\nelse (MaxOfSet(compatible) + 1)) \u003e\u003d 0))","legal function application obligation:(forall a:array \u0026 pre_MaxOfSet({lupsltok(a, j) | j in set (inds a)}))","type compatibility obligation:(forall a:array \u0026 (MaxOfSet({lupsltok(a, j) | j in set (inds a)}) \u003e\u003d 0))","legal sequence application obligation:(forall a:array, s:set of (int) \u0026 ((s subset (inds a)) \u003d\u003e (forall i, j in set s \u0026 ((i \u003c j) \u003d\u003e (i in set (inds a))))))","legal sequence application obligation:(forall a:array, s:set of (int) \u0026 ((s subset (inds a)) \u003d\u003e (forall i, j in set s \u0026 ((i \u003c j) \u003d\u003e (j in set (inds a))))))","legal function application obligation:(forall a:array \u0026 pre_MaxOfSet({(card s) | s in set (power (inds a)) \u0026 ascending(a, s)}))","legal function application obligation:(forall a:array \u0026 (forall s in set (power (inds a)) \u0026 pre_ascending(a, s)))","legal function application obligation:(forall a:array, oldstate:lups \u0026 pre_MaxOfSet(lupsls))","type compatibility obligation:(forall a:array, oldstate:lups \u0026 (RESULT \u003e\u003d 0))","operation establishes postcondition obligation:(forall a:array, oldstate:lups \u0026 (lupslSpec(a) \u003d RESULT))","legal sequence application obligation:(forall a:array, oldstate:lups \u0026 (1 in set (inds a)))","operation call obligation:(forall a:array, oldstate:lups \u0026 (a in set (inds a)))","operation establishes postcondition obligation:(forall a:array, oldstate:lups \u0026 (true \u003d\u003e (lupslSpec(a) \u003d RESULT)))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e ((len lupslarr) in set (inds lupslarr))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","unique existence binding obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (exists1 x in set {1, ... ,(len lupslarr)} \u0026 ((lupslarr(x) \u003e a(k)) and (forall j in set {1, ... ,(x - 1)} \u0026 (lupslarr(j) \u003c\u003d a(k)))))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (forall x in set {1, ... ,(len lupslarr)} \u0026 (x in set (inds lupslarr)))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (forall x in set {1, ... ,(len lupslarr)} \u0026 (k in set (inds a)))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (forall x in set {1, ... ,(len lupslarr)} \u0026 ((lupslarr(x) \u003e a(k)) \u003d\u003e (forall j in set {1, ... ,(x - 1)} \u0026 (j in set (inds lupslarr)))))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (forall x in set {1, ... ,(len lupslarr)} \u0026 ((lupslarr(x) \u003e a(k)) \u003d\u003e (forall j in set {1, ... ,(x - 1)} \u0026 (k in set (inds a)))))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (((iota x in set {1, ... ,(len lupslarr)} \u0026 ((lupslarr(x) \u003e a(k)) and (forall j in set {1, ... ,(x - 1)} \u0026 (lupslarr(j) \u003c\u003d a(k))))) \u003e 0) and ((iota x in set {1, ... ,(len lupslarr)} \u0026 ((lupslarr(x) \u003e a(k)) and (forall j in set {1, ... ,(x - 1)} \u0026 (lupslarr(j) \u003c\u003d a(k))))) \u003c\u003d ((len (lupslarr ^ [a(k)])) + 1)))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","operation establishes postcondition obligation:(forall a:array, oldstate:lups \u0026 (lupslSpec(a) \u003d RESULT))","legal sequence application obligation:(forall a:array, oldstate:lups \u0026 (1 in set (inds a)))","operation call obligation:(forall a:array, oldstate:lups \u0026 (a in set (inds a)))","operation establishes postcondition obligation:(forall a:array, oldstate:lups \u0026 (true \u003d\u003e (lupslSpec(a) \u003d RESULT)))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e ((len lupslarr) in set (inds lupslarr))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","while loop termination obligation:NotYetImplemented","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (1 in set (inds (lupslarr ^ [a(k)])))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (((1 + 1) \u003e 0) and ((1 + 1) \u003c\u003d ((len (lupslarr ^ [a(k)])) + 1)))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","operation establishes postcondition obligation:(forall a:array, oldstate:lups \u0026 (lupslSpec(a) \u003d RESULT))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (j in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (j in set (inds lupslarr))))","legal function application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e pre_MaxOfSet(compatible)))","type compatibility obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (RESULT \u003e\u003d 0)))","legal sequence application obligation:(forall a:array, oldstate:lups \u0026 (1 in set (inds a)))","operation call obligation:(forall a:array, oldstate:lups \u0026 (a in set (inds a)))","operation establishes postcondition obligation:(forall a:array, oldstate:lups \u0026 (true \u003d\u003e (lupslSpec(a) \u003d RESULT)))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e ((len lupslarr) in set (inds lupslarr))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (1 in set (inds (lupslarr ^ [a(k)])))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e ((1 \u003e 0) and (1 \u003c\u003d ((len (lupslarr ^ [a(k)])) + 1)))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","while loop termination obligation:NotYetImplemented","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (((1 + (len (lupslarr ^ [a(k)]))) div 2) in set (inds (lupslarr ^ [a(k)])))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e ((((1 + (len (lupslarr ^ [a(k)]))) div 2) \u003e 0) and (((1 + (len (lupslarr ^ [a(k)]))) div 2) \u003c\u003d ((len (lupslarr ^ [a(k)])) + 1)))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","operation establishes postcondition obligation:(forall a:array, oldstate:lups \u0026 (lupslSpec(a) \u003d RESULT))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (j in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (j in set (inds lupslarr))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (j in set (inds lupslarr))))","type compatibility obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (RESULT \u003e\u003d 0)))"] \ No newline at end of file +["function establishes postcondition obligation:(forall s:set of (int) \u0026 (pre_MaxOfSet(s) \u003d\u003e post_MaxOfSet(s, let e in set s in (if ((card s) \u003d 1)\nthen e\nelse let mr:int \u003d MaxOfSet((s \\ {e})) in (if (e \u003e mr)\nthen e\nelse mr)))))","let be st existence obligation:(forall s:set of (int) \u0026 ((s \u003c\u003e {}) \u003d\u003e (exists e in set s \u0026 true)))","legal function application obligation:(forall s:set of (int) \u0026 ((s \u003c\u003e {}) \u003d\u003e (forall e in set s \u0026 ((not ((card s) \u003d 1)) \u003d\u003e pre_MaxOfSet((s \\ {e}))))))","recursive function obligation:(forall s:set of (int) \u0026 ((s \u003c\u003e {}) \u003d\u003e (forall e in set s \u0026 ((not ((card s) \u003d 1)) \u003d\u003e (CardInt(s) \u003e CardInt((s \\ {e})))))))","legal sequence application obligation:(forall a:array, k:nat1 \u0026 (forall j in set {1, ... ,(k - 1)} \u0026 (j in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1 \u0026 (forall j in set {1, ... ,(k - 1)} \u0026 (k in set (inds a))))","legal function application obligation:(forall a:array, k:nat1 \u0026 let compatible:set of (nat) \u003d {lupsltok(a, j) | j in set {1, ... ,(k - 1)} \u0026 (a(j) \u003c\u003d a(k))} in ((not (compatible \u003d {})) \u003d\u003e pre_MaxOfSet(compatible)))","type compatibility obligation:(forall a:array, k:nat1 \u0026 (let compatible:set of (nat) \u003d {lupsltok(a, j) | j in set {1, ... ,(k - 1)} \u0026 (a(j) \u003c\u003d a(k))} in (if (compatible \u003d {})\nthen 1\nelse (MaxOfSet(compatible) + 1)) \u003e\u003d 0))","legal function application obligation:(forall a:array \u0026 pre_MaxOfSet({lupsltok(a, j) | j in set (inds a)}))","type compatibility obligation:(forall a:array \u0026 (MaxOfSet({lupsltok(a, j) | j in set (inds a)}) \u003e\u003d 0))","legal sequence application obligation:(forall a:array, s:set of (int) \u0026 ((s subset (inds a)) \u003d\u003e (forall i, j in set s \u0026 ((i \u003c j) \u003d\u003e (i in set (inds a))))))","legal sequence application obligation:(forall a:array, s:set of (int) \u0026 ((s subset (inds a)) \u003d\u003e (forall i, j in set s \u0026 ((i \u003c j) \u003d\u003e (j in set (inds a))))))","legal function application obligation:(forall a:array \u0026 pre_MaxOfSet({(card s) | s in set (power (inds a)) \u0026 ascending(a, s)}))","legal function application obligation:(forall a:array \u0026 (forall s in set (power (inds a)) \u0026 pre_ascending(a, s)))","legal function application obligation:(forall a:array, oldstate:lups \u0026 pre_MaxOfSet(lupsls))","type compatibility obligation:(forall a:array, oldstate:lups \u0026 (RESULT \u003e\u003d 0))","operation establishes postcondition obligation:(forall a:array, oldstate:lups \u0026 (lupslSpec(a) \u003d RESULT))","legal sequence application obligation:(forall a:array, oldstate:lups \u0026 (1 in set (inds a)))","operation call obligation:(forall a:array, oldstate:lups \u0026 (a in set (inds a)))","operation establishes postcondition obligation:(forall a:array, oldstate:lups \u0026 (true \u003d\u003e (lupslSpec(a) \u003d RESULT)))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e ((len lupslarr) in set (inds lupslarr))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","unique existence binding obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (exists1 x in set {1, ... ,(len lupslarr)} \u0026 ((lupslarr(x) \u003e a(k)) and (forall j in set {1, ... ,(x - 1)} \u0026 (lupslarr(j) \u003c\u003d a(k)))))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (forall x in set {1, ... ,(len lupslarr)} \u0026 (x in set (inds lupslarr)))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (forall x in set {1, ... ,(len lupslarr)} \u0026 (k in set (inds a)))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (forall x in set {1, ... ,(len lupslarr)} \u0026 ((lupslarr(x) \u003e a(k)) \u003d\u003e (forall j in set {1, ... ,(x - 1)} \u0026 (j in set (inds lupslarr)))))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (forall x in set {1, ... ,(len lupslarr)} \u0026 ((lupslarr(x) \u003e a(k)) \u003d\u003e (forall j in set {1, ... ,(x - 1)} \u0026 (k in set (inds a)))))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (((iota x in set {1, ... ,(len lupslarr)} \u0026 ((lupslarr(x) \u003e a(k)) and (forall j in set {1, ... ,(x - 1)} \u0026 (lupslarr(j) \u003c\u003d a(k))))) \u003e 0) and ((iota x in set {1, ... ,(len lupslarr)} \u0026 ((lupslarr(x) \u003e a(k)) and (forall j in set {1, ... ,(x - 1)} \u0026 (lupslarr(j) \u003c\u003d a(k))))) \u003c\u003d ((len (lupslarr ^ [a(k)])) + 1)))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","operation establishes postcondition obligation:(forall a:array, oldstate:lups \u0026 (lupslSpec(a) \u003d RESULT))","legal sequence application obligation:(forall a:array, oldstate:lups \u0026 (1 in set (inds a)))","operation call obligation:(forall a:array, oldstate:lups \u0026 (a in set (inds a)))","operation establishes postcondition obligation:(forall a:array, oldstate:lups \u0026 (true \u003d\u003e (lupslSpec(a) \u003d RESULT)))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e ((len lupslarr) in set (inds lupslarr))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","while loop termination obligation:...","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (1 in set (inds (lupslarr ^ [a(k)])))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (((1 + 1) \u003e 0) and ((1 + 1) \u003c\u003d ((len (lupslarr ^ [a(k)])) + 1)))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","operation establishes postcondition obligation:(forall a:array, oldstate:lups \u0026 (lupslSpec(a) \u003d RESULT))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (j in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (j in set (inds lupslarr))))","legal function application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e pre_MaxOfSet(compatible)))","type compatibility obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (RESULT \u003e\u003d 0)))","legal sequence application obligation:(forall a:array, oldstate:lups \u0026 (1 in set (inds a)))","operation call obligation:(forall a:array, oldstate:lups \u0026 (a in set (inds a)))","operation establishes postcondition obligation:(forall a:array, oldstate:lups \u0026 (true \u003d\u003e (lupslSpec(a) \u003d RESULT)))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e ((len lupslarr) in set (inds lupslarr))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (1 in set (inds (lupslarr ^ [a(k)])))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e ((1 \u003e 0) and (1 \u003c\u003d ((len (lupslarr ^ [a(k)])) + 1)))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","while loop termination obligation:...","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (((1 + (len (lupslarr ^ [a(k)]))) div 2) in set (inds (lupslarr ^ [a(k)])))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e ((((1 + (len (lupslarr ^ [a(k)]))) div 2) \u003e 0) and (((1 + (len (lupslarr ^ [a(k)]))) div 2) \u003c\u003d ((len (lupslarr ^ [a(k)])) + 1)))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","operation establishes postcondition obligation:(forall a:array, oldstate:lups \u0026 (lupslSpec(a) \u003d RESULT))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (j in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (j in set (inds lupslarr))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (j in set (inds lupslarr))))","type compatibility obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (RESULT \u003e\u003d 0)))"] \ No newline at end of file diff --git a/core/pog/src/test/resources/examples/MSAWRT.result b/core/pog/src/test/resources/examples/MSAWRT.result index 183de45b9c..48774439ec 100644 --- a/core/pog/src/test/resources/examples/MSAWRT.result +++ b/core/pog/src/test/resources/examples/MSAWRT.result @@ -1 +1 @@ -["comprehension map injectivity obligation:(forall m1, m2 in set {(r.getDetectedMap)() | r in set radars} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","legal map application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e ((id in set (dom history)) \u003d\u003e (id in set (dom history)))))","legal map application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e (id in set (dom history))))","legal sequence application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e (3 in set (inds hist))))","legal sequence application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e (2 in set (inds hist))))","legal sequence application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e (1 in set (inds hist))))","legal map application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e ((id in set (dom history)) \u003d\u003e (id in set (dom history)))))","legal map application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e (id in set (dom history))))","legal sequence application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e (forall i in set (inds lastHist) \u0026 (i in set (inds lastHist)))))","type compatibility obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e is_(RESULT, seq of (nat))))","legal map application obligation:(forall fo:FO \u0026 (id in set (dom history)))","map compatible obligation:(forall fo:FO \u0026 (forall ldom1 in set (dom history), rdom2 in set (dom {id |-\u003e addHistory([], (fo.getCoordinates)(), (fo.getAltitude)())}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (history(ldom1) \u003d {id |-\u003e addHistory([], (fo.getCoordinates)(), (fo.getAltitude)())}(rdom2)))))","legal function application obligation:(forall hist:History, coord:Coordinates, alt:Altitude \u0026 (((len hist) \u003e 0) \u003d\u003e pre_last(hist)))","non-empty sequence obligation:(forall hist:History, coord:Coordinates, alt:Altitude \u0026 (((len hist) \u003e 0) \u003d\u003e let lastValue:Position \u003d last(hist) in ((not (lastValue \u003d mk_Position(coord, alt))) \u003d\u003e ((not ((len hist) \u003c 3)) \u003d\u003e (hist \u003c\u003e [])))))","legal sequence application obligation:(forall hist:History \u0026 (((len hist) \u003e 0) \u003d\u003e ((len hist) in set (inds hist))))","legal map application obligation:(forall busy1:bool, radars2:set of (Radar), obstacles3:set of (Obstacle), history4:map (FOId) to (seq of (Position)) \u0026 (true \u003d\u003e (((fo.getId)() in set (dom history4)) \u003d\u003e ((fo.getId)() in set (dom history4)))))","operation call obligation:(forall busy1:bool, radars2:set of (Radar), obstacles3:set of (Obstacle), history4:map (FOId) to (seq of (Position)) \u0026 (true \u003d\u003e (((fo.getId)() in set (dom history4)) and ((len history((fo.getId)())) \u003d 3))))","non-empty set obligation:(forall radars:set of (Radar) \u0026 ({(r.getDetected)() | r in set radars} \u003c\u003e {}))","type compatibility obligation:(forall msa:MinimumSafetyAltitude, pos:Position \u0026 ((msa \u003c\u003e \u003cNotAllowed\u003e) \u003d\u003e is_(msa, real)))","legal map application obligation:(forall obs:Obstacle, fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e (((fo.getId)() in set (dom history)) \u003d\u003e ((fo.getId)() in set (dom history)))))","legal map application obligation:(forall fo:FO \u0026 (((fo.getId)() in set (dom history)) \u003d\u003e ((fo.getId)() in set (dom history))))","legal map application obligation:(forall fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e (((fo.getId)() in set (dom history)) \u003d\u003e ((fo.getId)() in set (dom history)))))","legal sequence application obligation:(forall fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e (1 in set (inds vs))))","legal sequence application obligation:(forall fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e (2 in set (inds vs))))","legal sequence application obligation:(forall fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e (1 in set (inds vs))))","legal function application obligation:(forall fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e pre_predictAltitude(getAltitudeHistory(foid))))","legal sequence application obligation:(forall fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e (3 in set (inds history(foid)))))","legal map application obligation:(forall fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e (foid in set (dom history))))","legal sequence application obligation:(forall alts:seq of (nat) \u0026 (((len alts) \u003d 2) \u003d\u003e (1 in set (inds alts))))","legal sequence application obligation:(forall alts:seq of (nat) \u0026 (((len alts) \u003d 2) \u003d\u003e (1 in set (inds alts))))","legal sequence application obligation:(forall alts:seq of (nat) \u0026 (((len alts) \u003d 2) \u003d\u003e (2 in set (inds alts))))","type compatibility obligation:(forall alts:seq of (nat) \u0026 (((len alts) \u003d 2) \u003d\u003e ((alts(1) + (alts(1) - alts(2))) \u003e\u003d 0)))","non-zero obligation:(forall v:Vector, n:int \u0026 ((n \u003c\u003e 0) \u003d\u003e (n \u003c\u003e 0)))","non-zero obligation:(forall v:Vector, n:int \u0026 ((n \u003c\u003e 0) \u003d\u003e (n \u003c\u003e 0)))","legal function application obligation:(forall v:Vector \u0026 pre_sqrt((((v.X) ** 2) + ((v.Y) ** 2))))","non-zero obligation:(forall v:Vector \u0026 let l:real \u003d vectorLength(v) in (l \u003c\u003e 0))","non-zero obligation:(forall v:Vector \u0026 let l:real \u003d vectorLength(v) in (l \u003c\u003e 0))","legal function application obligation:(forall v1:Vector, v2:Vector \u0026 pre_acos(dvs))","non-zero obligation:(forall r:real \u0026 (MATH`pi \u003c\u003e 0))","legal function application obligation:(forall y:real, x:real \u0026 ((not ((x \u003d 0) and (y \u003d 0))) \u003d\u003e pre_sqrt(((x ** 2) + (y ** 2)))))","non-zero obligation:(forall y:real, x:real \u0026 ((not ((x \u003d 0) and (y \u003d 0))) \u003d\u003e ((MATH`sqrt(((x ** 2) + (y ** 2))) + x) \u003c\u003e 0)))","legal function application obligation:(forall v1:Vector, v2:Vector \u0026 pre_atan2((v2.Y), (v2.X)))","legal function application obligation:(forall v1:Vector, v2:Vector \u0026 pre_atan2((v1.Y), (v1.X)))","legal function application obligation:(forall v:Vector \u0026 pre_acos(((v.X) / MATH`sqrt((((v.X) ** 2) + ((v.Y) ** 2))))))","legal function application obligation:(forall v:Vector \u0026 pre_sqrt((((v.X) ** 2) + ((v.Y) ** 2))))","non-zero obligation:(forall v:Vector \u0026 (MATH`sqrt((((v.X) ** 2) + ((v.Y) ** 2))) \u003c\u003e 0))","legal function application obligation:(forall v:Vector \u0026 pre_asin(((v.Y) / MATH`sqrt((((v.X) ** 2) + ((v.Y) ** 2))))))","legal function application obligation:(forall v:Vector \u0026 pre_sqrt((((v.X) ** 2) + ((v.Y) ** 2))))","non-zero obligation:(forall v:Vector \u0026 (MATH`sqrt((((v.X) ** 2) + ((v.Y) ** 2))) \u003c\u003e 0))","legal function application obligation:(forall x1:real, y1:real, x2:real, y2:real \u0026 pre_atan2(1.0E-6, 0.0))","state invariant initialized obligation:(forall foid1, foid2 in set (dom airspace) \u0026 ((foid1 \u003c\u003e foid2) \u003d\u003e ((airspace(foid1).getId)() \u003c\u003e (airspace(foid2).getId)())))","state invariant satisfiable obligation:(exists airspace:map (FOId) to (FO) \u0026 (forall foid1, foid2 in set (dom airspace) \u0026 ((foid1 \u003c\u003e foid2) \u003d\u003e ((airspace(foid1).getId)() \u003c\u003e (airspace(foid2).getId)()))))","state invariant holds obligation:(forall fo:FO \u0026 (((fo.getId)() not in set (dom airspace)) \u003d\u003e ((forall foid1, foid2 in set (dom airspace) \u0026 ((foid1 \u003c\u003e foid2) \u003d\u003e ((airspace(foid1).getId)() \u003c\u003e (airspace(foid2).getId)()))) \u003d\u003e (forall foid1, foid2 in set (dom airspace) \u0026 ((foid1 \u003c\u003e foid2) \u003d\u003e ((airspace(foid1).getId)() \u003c\u003e (airspace(foid2).getId)()))))))","map compatible obligation:(forall fo:FO \u0026 (((fo.getId)() not in set (dom airspace)) \u003d\u003e (forall ldom1 in set (dom airspace), rdom2 in set (dom {(fo.getId)() |-\u003e fo}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (airspace(ldom1) \u003d {(fo.getId)() |-\u003e fo}(rdom2))))))","state invariant holds obligation:(forall id:FOId \u0026 ((forall foid1, foid2 in set (dom airspace) \u0026 ((foid1 \u003c\u003e foid2) \u003d\u003e ((airspace(foid1).getId)() \u003c\u003e (airspace(foid2).getId)()))) \u003d\u003e (forall foid1, foid2 in set (dom airspace) \u0026 ((foid1 \u003c\u003e foid2) \u003d\u003e ((airspace(foid1).getId)() \u003c\u003e (airspace(foid2).getId)())))))","legal map application obligation:(forall id:FOId \u0026 ((id in set (dom airspace)) \u003d\u003e (id in set (dom airspace))))","legal map application obligation:(forall id:FOId, coord:Coordinates, alt:Altitude \u0026 (id in set (dom airspace)))","state invariant holds obligation:(forall id:FOId, coord:Coordinates, alt:Altitude \u0026 ((forall foid1, foid2 in set (dom airspace) \u0026 ((foid1 \u003c\u003e foid2) \u003d\u003e ((airspace(foid1).getId)() \u003c\u003e (airspace(foid2).getId)()))) \u003d\u003e (forall foid1, foid2 in set (dom airspace) \u0026 ((foid1 \u003c\u003e foid2) \u003d\u003e ((airspace(foid1).getId)() \u003c\u003e (airspace(foid2).getId)())))))","map compatible obligation:(forall id:FOId, coord:Coordinates, alt:Altitude \u0026 (forall ldom1 in set (dom airspace), rdom2 in set (dom {id |-\u003e newfo}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (airspace(ldom1) \u003d {id |-\u003e newfo}(rdom2)))))","type compatibility obligation:(forall msa:MinimumSafetyAltitude, loc:Coordinates, ra:nat, secRa:nat, tp:ObstacleType \u0026 (ra \u003e 0))","legal function application obligation:(forall fname:String \u0026 pre_(((io.freadval))[InputTP]fname))","legal function application obligation:pre_(((io.writeval))[seq of (outline)]outlines)","while loop termination obligation:NotYetImplemented","non-empty sequence obligation:(inlines \u003c\u003e [])","non-empty sequence obligation:(inlines \u003c\u003e [])","state invariant holds obligation:(forall x:int, y:int, r:nat1 \u0026 (forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid)))","state invariant holds obligation:(forall as:AirSpace \u0026 ((forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid)) \u003d\u003e (forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid))))","comprehension map injectivity obligation:(forall as:AirSpace \u0026 (forall m1, m2 in set {{(x.getId)() |-\u003e x} | x in set (as.getAirspace)() \u0026 InRange(x)} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4))))))","legal sequence application obligation:(forall i in set (inds priority) \u0026 ((i \u003e (floor (range / 4))) \u003d\u003e (i in set (inds priority))))","state invariant holds obligation:(forall fos:set of (FO) \u0026 ((forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid)) \u003d\u003e (forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid))))","legal sequence application obligation:(forall fos:set of (FO) \u0026 (forall i in set (inds priority) \u0026 ((priority(i) in set fos) \u003d\u003e (i in set (inds priority)))))","legal sequence application obligation:(forall fos:set of (FO) \u0026 (forall i in set (inds priority) \u0026 (i in set (inds priority))))","state invariant holds obligation:(forall newlyDetect:map (FOId) to (FO) \u0026 ((forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid)) \u003d\u003e (forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid))))","let be st existence obligation:(forall fos:set of (FO) \u0026 ((not (fos \u003d {})) \u003d\u003e (exists fo in set fos \u0026 true)))","recursive function obligation:(forall fos:set of (FO) \u0026 ((not (fos \u003d {})) \u003d\u003e (forall fo in set fos \u0026 (set2seqFOm(fos) \u003e set2seqFOm((fos \\ {fo}))))))","state invariant holds obligation:((forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid)) \u003d\u003e (forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid)))","comprehension map injectivity obligation:(forall m1, m2 in set {{(x.getId)() |-\u003e x} | x in set (as.getAirspace)() \u0026 InRange(x)} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","state invariant holds obligation:((forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid)) \u003d\u003e (forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid)))","state invariant holds obligation:(forall busy1:bool, location2:Coordinates, range3:nat1, detected4:map (FOId) to (FO), priority5:seq of (FO) \u0026 ((forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid)) \u003d\u003e (forall busy6:bool, location7:Coordinates, range8:nat1, detected9:map (FOId) to (FO), priority10:seq of (FO) \u0026 ((forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid)) \u003d\u003e ((forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid)) \u003d\u003e (forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid)))))))","operation call obligation:(forall text:seq of (char) \u0026 ((\"\" \u003d \"\") \u003c\u003d\u003e (\"\" \u003d nil)))","non-zero obligation:(forall a:real \u0026 ((a \u003c\u003e 0) \u003d\u003e (a \u003c\u003e 0)))"] \ No newline at end of file +["comprehension map injectivity obligation:(forall m1, m2 in set {(r.getDetectedMap)() | r in set radars} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","legal map application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e ((id in set (dom history)) \u003d\u003e (id in set (dom history)))))","legal map application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e (id in set (dom history))))","legal sequence application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e (3 in set (inds hist))))","legal sequence application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e (2 in set (inds hist))))","legal sequence application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e (1 in set (inds hist))))","legal map application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e ((id in set (dom history)) \u003d\u003e (id in set (dom history)))))","legal map application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e (id in set (dom history))))","legal sequence application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e (forall i in set (inds lastHist) \u0026 (i in set (inds lastHist)))))","type compatibility obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e is_(RESULT, seq of (nat))))","legal map application obligation:(forall fo:FO \u0026 (id in set (dom history)))","map compatible obligation:(forall fo:FO \u0026 (forall ldom1 in set (dom history), rdom2 in set (dom {id |-\u003e addHistory([], (fo.getCoordinates)(), (fo.getAltitude)())}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (history(ldom1) \u003d {id |-\u003e addHistory([], (fo.getCoordinates)(), (fo.getAltitude)())}(rdom2)))))","legal function application obligation:(forall hist:History, coord:Coordinates, alt:Altitude \u0026 (((len hist) \u003e 0) \u003d\u003e pre_last(hist)))","non-empty sequence obligation:(forall hist:History, coord:Coordinates, alt:Altitude \u0026 (((len hist) \u003e 0) \u003d\u003e let lastValue:Position \u003d last(hist) in ((not (lastValue \u003d mk_Position(coord, alt))) \u003d\u003e ((not ((len hist) \u003c 3)) \u003d\u003e (hist \u003c\u003e [])))))","legal sequence application obligation:(forall hist:History \u0026 (((len hist) \u003e 0) \u003d\u003e ((len hist) in set (inds hist))))","legal map application obligation:(forall busy1:bool, radars2:set of (Radar), obstacles3:set of (Obstacle), history4:map (FOId) to (seq of (Position)) \u0026 (true \u003d\u003e (((fo.getId)() in set (dom history4)) \u003d\u003e ((fo.getId)() in set (dom history4)))))","operation call obligation:(forall busy1:bool, radars2:set of (Radar), obstacles3:set of (Obstacle), history4:map (FOId) to (seq of (Position)) \u0026 (true \u003d\u003e (((fo.getId)() in set (dom history4)) and ((len history((fo.getId)())) \u003d 3))))","non-empty set obligation:(forall radars:set of (Radar) \u0026 ({(r.getDetected)() | r in set radars} \u003c\u003e {}))","type compatibility obligation:(forall msa:MinimumSafetyAltitude, pos:Position \u0026 ((msa \u003c\u003e \u003cNotAllowed\u003e) \u003d\u003e is_(msa, real)))","legal map application obligation:(forall obs:Obstacle, fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e (((fo.getId)() in set (dom history)) \u003d\u003e ((fo.getId)() in set (dom history)))))","legal map application obligation:(forall fo:FO \u0026 (((fo.getId)() in set (dom history)) \u003d\u003e ((fo.getId)() in set (dom history))))","legal map application obligation:(forall fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e (((fo.getId)() in set (dom history)) \u003d\u003e ((fo.getId)() in set (dom history)))))","legal sequence application obligation:(forall fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e (1 in set (inds vs))))","legal sequence application obligation:(forall fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e (2 in set (inds vs))))","legal sequence application obligation:(forall fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e (1 in set (inds vs))))","legal function application obligation:(forall fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e pre_predictAltitude(getAltitudeHistory(foid))))","legal sequence application obligation:(forall fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e (3 in set (inds history(foid)))))","legal map application obligation:(forall fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e (foid in set (dom history))))","legal sequence application obligation:(forall alts:seq of (nat) \u0026 (((len alts) \u003d 2) \u003d\u003e (1 in set (inds alts))))","legal sequence application obligation:(forall alts:seq of (nat) \u0026 (((len alts) \u003d 2) \u003d\u003e (1 in set (inds alts))))","legal sequence application obligation:(forall alts:seq of (nat) \u0026 (((len alts) \u003d 2) \u003d\u003e (2 in set (inds alts))))","type compatibility obligation:(forall alts:seq of (nat) \u0026 (((len alts) \u003d 2) \u003d\u003e ((alts(1) + (alts(1) - alts(2))) \u003e\u003d 0)))","non-zero obligation:(forall v:Vector, n:int \u0026 ((n \u003c\u003e 0) \u003d\u003e (n \u003c\u003e 0)))","non-zero obligation:(forall v:Vector, n:int \u0026 ((n \u003c\u003e 0) \u003d\u003e (n \u003c\u003e 0)))","legal function application obligation:(forall v:Vector \u0026 pre_sqrt((((v.X) ** 2) + ((v.Y) ** 2))))","non-zero obligation:(forall v:Vector \u0026 let l:real \u003d vectorLength(v) in (l \u003c\u003e 0))","non-zero obligation:(forall v:Vector \u0026 let l:real \u003d vectorLength(v) in (l \u003c\u003e 0))","legal function application obligation:(forall v1:Vector, v2:Vector \u0026 pre_acos(dvs))","non-zero obligation:(forall r:real \u0026 (MATH`pi \u003c\u003e 0))","legal function application obligation:(forall y:real, x:real \u0026 ((not ((x \u003d 0) and (y \u003d 0))) \u003d\u003e pre_sqrt(((x ** 2) + (y ** 2)))))","non-zero obligation:(forall y:real, x:real \u0026 ((not ((x \u003d 0) and (y \u003d 0))) \u003d\u003e ((MATH`sqrt(((x ** 2) + (y ** 2))) + x) \u003c\u003e 0)))","legal function application obligation:(forall v1:Vector, v2:Vector \u0026 pre_atan2((v2.Y), (v2.X)))","legal function application obligation:(forall v1:Vector, v2:Vector \u0026 pre_atan2((v1.Y), (v1.X)))","legal function application obligation:(forall v:Vector \u0026 pre_acos(((v.X) / MATH`sqrt((((v.X) ** 2) + ((v.Y) ** 2))))))","legal function application obligation:(forall v:Vector \u0026 pre_sqrt((((v.X) ** 2) + ((v.Y) ** 2))))","non-zero obligation:(forall v:Vector \u0026 (MATH`sqrt((((v.X) ** 2) + ((v.Y) ** 2))) \u003c\u003e 0))","legal function application obligation:(forall v:Vector \u0026 pre_asin(((v.Y) / MATH`sqrt((((v.X) ** 2) + ((v.Y) ** 2))))))","legal function application obligation:(forall v:Vector \u0026 pre_sqrt((((v.X) ** 2) + ((v.Y) ** 2))))","non-zero obligation:(forall v:Vector \u0026 (MATH`sqrt((((v.X) ** 2) + ((v.Y) ** 2))) \u003c\u003e 0))","legal function application obligation:(forall x1:real, y1:real, x2:real, y2:real \u0026 pre_atan2(1.0E-6, 0.0))","state invariant initialized obligation:(forall foid1, foid2 in set (dom airspace) \u0026 ((foid1 \u003c\u003e foid2) \u003d\u003e ((airspace(foid1).getId)() \u003c\u003e (airspace(foid2).getId)())))","state invariant satisfiable obligation:(exists airspace:map (FOId) to (FO) \u0026 (forall foid1, foid2 in set (dom airspace) \u0026 ((foid1 \u003c\u003e foid2) \u003d\u003e ((airspace(foid1).getId)() \u003c\u003e (airspace(foid2).getId)()))))","state invariant holds obligation:(forall fo:FO \u0026 (((fo.getId)() not in set (dom airspace)) \u003d\u003e ((forall foid1, foid2 in set (dom airspace) \u0026 ((foid1 \u003c\u003e foid2) \u003d\u003e ((airspace(foid1).getId)() \u003c\u003e (airspace(foid2).getId)()))) \u003d\u003e (forall foid1, foid2 in set (dom airspace) \u0026 ((foid1 \u003c\u003e foid2) \u003d\u003e ((airspace(foid1).getId)() \u003c\u003e (airspace(foid2).getId)()))))))","map compatible obligation:(forall fo:FO \u0026 (((fo.getId)() not in set (dom airspace)) \u003d\u003e (forall ldom1 in set (dom airspace), rdom2 in set (dom {(fo.getId)() |-\u003e fo}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (airspace(ldom1) \u003d {(fo.getId)() |-\u003e fo}(rdom2))))))","state invariant holds obligation:(forall id:FOId \u0026 ((forall foid1, foid2 in set (dom airspace) \u0026 ((foid1 \u003c\u003e foid2) \u003d\u003e ((airspace(foid1).getId)() \u003c\u003e (airspace(foid2).getId)()))) \u003d\u003e (forall foid1, foid2 in set (dom airspace) \u0026 ((foid1 \u003c\u003e foid2) \u003d\u003e ((airspace(foid1).getId)() \u003c\u003e (airspace(foid2).getId)())))))","legal map application obligation:(forall id:FOId \u0026 ((id in set (dom airspace)) \u003d\u003e (id in set (dom airspace))))","legal map application obligation:(forall id:FOId, coord:Coordinates, alt:Altitude \u0026 (id in set (dom airspace)))","state invariant holds obligation:(forall id:FOId, coord:Coordinates, alt:Altitude \u0026 ((forall foid1, foid2 in set (dom airspace) \u0026 ((foid1 \u003c\u003e foid2) \u003d\u003e ((airspace(foid1).getId)() \u003c\u003e (airspace(foid2).getId)()))) \u003d\u003e (forall foid1, foid2 in set (dom airspace) \u0026 ((foid1 \u003c\u003e foid2) \u003d\u003e ((airspace(foid1).getId)() \u003c\u003e (airspace(foid2).getId)())))))","map compatible obligation:(forall id:FOId, coord:Coordinates, alt:Altitude \u0026 (forall ldom1 in set (dom airspace), rdom2 in set (dom {id |-\u003e newfo}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (airspace(ldom1) \u003d {id |-\u003e newfo}(rdom2)))))","type compatibility obligation:(forall msa:MinimumSafetyAltitude, loc:Coordinates, ra:nat, secRa:nat, tp:ObstacleType \u0026 (ra \u003e 0))","legal function application obligation:(forall fname:String \u0026 pre_(((io.freadval))[InputTP]fname))","legal function application obligation:pre_(((io.writeval))[seq of (outline)]outlines)","while loop termination obligation:...","non-empty sequence obligation:(inlines \u003c\u003e [])","non-empty sequence obligation:(inlines \u003c\u003e [])","state invariant holds obligation:(forall x:int, y:int, r:nat1 \u0026 (forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid)))","state invariant holds obligation:(forall as:AirSpace \u0026 ((forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid)) \u003d\u003e (forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid))))","comprehension map injectivity obligation:(forall as:AirSpace \u0026 (forall m1, m2 in set {{(x.getId)() |-\u003e x} | x in set (as.getAirspace)() \u0026 InRange(x)} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4))))))","legal sequence application obligation:(forall i in set (inds priority) \u0026 ((i \u003e (floor (range / 4))) \u003d\u003e (i in set (inds priority))))","state invariant holds obligation:(forall fos:set of (FO) \u0026 ((forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid)) \u003d\u003e (forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid))))","legal sequence application obligation:(forall fos:set of (FO) \u0026 (forall i in set (inds priority) \u0026 ((priority(i) in set fos) \u003d\u003e (i in set (inds priority)))))","legal sequence application obligation:(forall fos:set of (FO) \u0026 (forall i in set (inds priority) \u0026 (i in set (inds priority))))","state invariant holds obligation:(forall newlyDetect:map (FOId) to (FO) \u0026 ((forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid)) \u003d\u003e (forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid))))","let be st existence obligation:(forall fos:set of (FO) \u0026 ((not (fos \u003d {})) \u003d\u003e (exists fo in set fos \u0026 true)))","recursive function obligation:(forall fos:set of (FO) \u0026 ((not (fos \u003d {})) \u003d\u003e (forall fo in set fos \u0026 (set2seqFOm(fos) \u003e set2seqFOm((fos \\ {fo}))))))","state invariant holds obligation:((forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid)) \u003d\u003e (forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid)))","comprehension map injectivity obligation:(forall m1, m2 in set {{(x.getId)() |-\u003e x} | x in set (as.getAirspace)() \u0026 InRange(x)} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","state invariant holds obligation:((forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid)) \u003d\u003e (forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid)))","state invariant holds obligation:(forall busy1:bool, location2:Coordinates, range3:nat1, detected4:map (FOId) to (FO), priority5:seq of (FO) \u0026 ((forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid)) \u003d\u003e (forall busy6:bool, location7:Coordinates, range8:nat1, detected9:map (FOId) to (FO), priority10:seq of (FO) \u0026 ((forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid)) \u003d\u003e ((forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid)) \u003d\u003e (forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid)))))))","operation call obligation:(forall text:seq of (char) \u0026 ((\"\" \u003d \"\") \u003c\u003d\u003e (\"\" \u003d nil)))","non-zero obligation:(forall a:real \u0026 ((a \u003c\u003e 0) \u003d\u003e (a \u003c\u003e 0)))"] \ No newline at end of file diff --git a/core/pog/src/test/resources/examples/MSAWconcurPP.result b/core/pog/src/test/resources/examples/MSAWconcurPP.result index 8de5bf7613..1788bcdcc2 100644 --- a/core/pog/src/test/resources/examples/MSAWconcurPP.result +++ b/core/pog/src/test/resources/examples/MSAWconcurPP.result @@ -1 +1 @@ -["type compatibility obligation:(forall msa:MinimumSafetyAltitude, loc:Coordinates, ra:nat, secRa:nat, tp:ObstacleType \u0026 (ra \u003e 0))","legal function application obligation:(forall fname:String, p:nat1, isP:bool \u0026 pre_(((io.freadval))[InputTP]fname))","legal function application obligation:pre_(((io.writeval))[seq of (outline)]outlines)","while loop termination obligation:NotYetImplemented","non-empty sequence obligation:(inlines \u003c\u003e [])","non-empty sequence obligation:(inlines \u003c\u003e [])","non-zero obligation:(forall v:Vector, n:int \u0026 ((n \u003c\u003e 0) \u003d\u003e (n \u003c\u003e 0)))","non-zero obligation:(forall v:Vector, n:int \u0026 ((n \u003c\u003e 0) \u003d\u003e (n \u003c\u003e 0)))","legal function application obligation:(forall v:Vector \u0026 pre_sqrt((((v.X) ** 2) + ((v.Y) ** 2))))","non-zero obligation:(forall v:Vector \u0026 let l:real \u003d vectorLength(v) in (l \u003c\u003e 0))","non-zero obligation:(forall v:Vector \u0026 let l:real \u003d vectorLength(v) in (l \u003c\u003e 0))","legal function application obligation:(forall v1:Vector, v2:Vector \u0026 pre_acos(dvs))","non-zero obligation:(forall r:real \u0026 (MATH`pi \u003c\u003e 0))","legal function application obligation:(forall y:real, x:real \u0026 ((not ((x \u003d 0) and (y \u003d 0))) \u003d\u003e pre_sqrt(((x ** 2) + (y ** 2)))))","non-zero obligation:(forall y:real, x:real \u0026 ((not ((x \u003d 0) and (y \u003d 0))) \u003d\u003e ((MATH`sqrt(((x ** 2) + (y ** 2))) + x) \u003c\u003e 0)))","legal function application obligation:(forall v1:Vector, v2:Vector \u0026 pre_atan2((v2.Y), (v2.X)))","legal function application obligation:(forall v1:Vector, v2:Vector \u0026 pre_atan2((v1.Y), (v1.X)))","legal function application obligation:(forall v:Vector \u0026 pre_acos(((v.X) / MATH`sqrt((((v.X) ** 2) + ((v.Y) ** 2))))))","legal function application obligation:(forall v:Vector \u0026 pre_sqrt((((v.X) ** 2) + ((v.Y) ** 2))))","non-zero obligation:(forall v:Vector \u0026 (MATH`sqrt((((v.X) ** 2) + ((v.Y) ** 2))) \u003c\u003e 0))","legal function application obligation:(forall v:Vector \u0026 pre_asin(((v.Y) / MATH`sqrt((((v.X) ** 2) + ((v.Y) ** 2))))))","legal function application obligation:(forall v:Vector \u0026 pre_sqrt((((v.X) ** 2) + ((v.Y) ** 2))))","non-zero obligation:(forall v:Vector \u0026 (MATH`sqrt((((v.X) ** 2) + ((v.Y) ** 2))) \u003c\u003e 0))","legal function application obligation:(forall x1:real, y1:real, x2:real, y2:real \u0026 pre_atan2(1.0E-6, 0.0))","state invariant initialized obligation:(forall foid1, foid2 in set (dom airspace) \u0026 ((foid1 \u003c\u003e foid2) \u003d\u003e ((airspace(foid1).getId)() \u003c\u003e (airspace(foid2).getId)())))","state invariant satisfiable obligation:(exists airspace:map (FOId) to (FO) \u0026 (forall foid1, foid2 in set (dom airspace) \u0026 ((foid1 \u003c\u003e foid2) \u003d\u003e ((airspace(foid1).getId)() \u003c\u003e (airspace(foid2).getId)()))))","state invariant holds obligation:(forall fo:FO \u0026 (((fo.getId)() not in set (dom airspace)) \u003d\u003e ((forall foid1, foid2 in set (dom airspace) \u0026 ((foid1 \u003c\u003e foid2) \u003d\u003e ((airspace(foid1).getId)() \u003c\u003e (airspace(foid2).getId)()))) \u003d\u003e (forall foid1, foid2 in set (dom airspace) \u0026 ((foid1 \u003c\u003e foid2) \u003d\u003e ((airspace(foid1).getId)() \u003c\u003e (airspace(foid2).getId)()))))))","map compatible obligation:(forall fo:FO \u0026 (((fo.getId)() not in set (dom airspace)) \u003d\u003e (forall ldom1 in set (dom airspace), rdom2 in set (dom {(fo.getId)() |-\u003e fo}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (airspace(ldom1) \u003d {(fo.getId)() |-\u003e fo}(rdom2))))))","state invariant holds obligation:(forall id:FOId \u0026 ((forall foid1, foid2 in set (dom airspace) \u0026 ((foid1 \u003c\u003e foid2) \u003d\u003e ((airspace(foid1).getId)() \u003c\u003e (airspace(foid2).getId)()))) \u003d\u003e (forall foid1, foid2 in set (dom airspace) \u0026 ((foid1 \u003c\u003e foid2) \u003d\u003e ((airspace(foid1).getId)() \u003c\u003e (airspace(foid2).getId)())))))","legal map application obligation:(forall id:FOId \u0026 ((id in set (dom airspace)) \u003d\u003e (id in set (dom airspace))))","legal map application obligation:(forall id:FOId, coord:Coordinates, alt:Altitude \u0026 (id in set (dom airspace)))","state invariant holds obligation:(forall id:FOId, coord:Coordinates, alt:Altitude \u0026 ((forall foid1, foid2 in set (dom airspace) \u0026 ((foid1 \u003c\u003e foid2) \u003d\u003e ((airspace(foid1).getId)() \u003c\u003e (airspace(foid2).getId)()))) \u003d\u003e (forall foid1, foid2 in set (dom airspace) \u0026 ((foid1 \u003c\u003e foid2) \u003d\u003e ((airspace(foid1).getId)() \u003c\u003e (airspace(foid2).getId)())))))","map compatible obligation:(forall id:FOId, coord:Coordinates, alt:Altitude \u0026 (forall ldom1 in set (dom airspace), rdom2 in set (dom {id |-\u003e newfo}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (airspace(ldom1) \u003d {id |-\u003e newfo}(rdom2)))))","state invariant holds obligation:(forall x:int, y:int, r:nat1, p:nat1, isP:bool \u0026 (forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid)))","state invariant holds obligation:(forall as:AirSpace \u0026 ((forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid)) \u003d\u003e (forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid))))","comprehension map injectivity obligation:(forall as:AirSpace \u0026 (forall m1, m2 in set {{(x.getId)() |-\u003e x} | x in set (as.getAirspace)() \u0026 InRange(x)} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4))))))","legal sequence application obligation:(forall i in set (inds priority) \u0026 ((i \u003e (floor (range / 4))) \u003d\u003e (i in set (inds priority))))","state invariant holds obligation:(forall busy1:bool, location2:Coordinates, range3:nat1, detected4:map (FOId) to (FO), priority5:seq of (FO) \u0026 ((forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid)) \u003d\u003e (forall busy6:bool, location7:Coordinates, range8:nat1, detected9:map (FOId) to (FO), priority10:seq of (FO) \u0026 ((forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid)) \u003d\u003e ((forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid)) \u003d\u003e (forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid)))))))","state invariant holds obligation:(forall fos:set of (FO) \u0026 ((forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid)) \u003d\u003e (forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid))))","legal sequence application obligation:(forall fos:set of (FO) \u0026 (forall i in set (inds priority) \u0026 ((priority(i) in set fos) \u003d\u003e (i in set (inds priority)))))","legal sequence application obligation:(forall fos:set of (FO) \u0026 (forall i in set (inds priority) \u0026 (i in set (inds priority))))","state invariant holds obligation:(forall newlyDetect:map (FOId) to (FO) \u0026 ((forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid)) \u003d\u003e (forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid))))","state invariant holds obligation:((forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid)) \u003d\u003e (forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid)))","comprehension map injectivity obligation:(forall m1, m2 in set {{(x.getId)() |-\u003e x} | x in set (as.getAirspace)() \u0026 InRange(x)} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","let be st existence obligation:(forall fos:set of (FO) \u0026 ((not (fos \u003d {})) \u003d\u003e (exists fo in set fos \u0026 true)))","recursive function obligation:(forall fos:set of (FO) \u0026 ((not (fos \u003d {})) \u003d\u003e (forall fo in set fos \u0026 (set2seqFOm(fos) \u003e set2seqFOm((fos \\ {fo}))))))","type compatibility obligation:((barrierCount - 1) \u003e\u003d 0)","while loop termination obligation:NotYetImplemented","legal map application obligation:(forall th in set (dom wakeUpMap) \u0026 (th in set (dom wakeUpMap)))","legal map application obligation:(forall th in set (dom wakeUpMap) \u0026 ((wakeUpMap(th) \u003c\u003e nil) \u003d\u003e (th in set (dom wakeUpMap))))","operation establishes postcondition obligation:(forall x in set (rng wakeUpMap) \u0026 ((x \u003d nil) or (x \u003e\u003d currentTime)))","comprehension map injectivity obligation:(forall m1, m2 in set {(r.getDetectedMap)() | r in set radars} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","legal map application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e ((id in set (dom history)) \u003d\u003e (id in set (dom history)))))","legal map application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e (id in set (dom history))))","legal sequence application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e (3 in set (inds hist))))","legal sequence application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e (2 in set (inds hist))))","legal sequence application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e (1 in set (inds hist))))","legal map application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e ((id in set (dom history)) \u003d\u003e (id in set (dom history)))))","legal map application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e (id in set (dom history))))","legal sequence application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e (forall i in set (inds lastHist) \u0026 (i in set (inds lastHist)))))","type compatibility obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e is_(RESULT, seq of (nat))))","legal map application obligation:(forall fo:FO \u0026 (id in set (dom history)))","map compatible obligation:(forall fo:FO \u0026 (forall ldom1 in set (dom history), rdom2 in set (dom {id |-\u003e addHistory([], (fo.getCoordinates)(), (fo.getAltitude)())}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (history(ldom1) \u003d {id |-\u003e addHistory([], (fo.getCoordinates)(), (fo.getAltitude)())}(rdom2)))))","legal function application obligation:(forall hist:History, coord:Coordinates, alt:Altitude \u0026 (((len hist) \u003e 0) \u003d\u003e pre_last(hist)))","non-empty sequence obligation:(forall hist:History, coord:Coordinates, alt:Altitude \u0026 (((len hist) \u003e 0) \u003d\u003e let lastValue:Position \u003d last(hist) in ((not (lastValue \u003d mk_Position(coord, alt))) \u003d\u003e ((not ((len hist) \u003c 3)) \u003d\u003e (hist \u003c\u003e [])))))","legal sequence application obligation:(forall hist:History \u0026 (((len hist) \u003e 0) \u003d\u003e ((len hist) in set (inds hist))))","legal map application obligation:(forall busy5:bool, radars6:set of (Radar), obstacles7:set of (Obstacle), history8:map (FOId) to (seq of (Position)) \u0026 (true \u003d\u003e ((fo.getId)() in set (dom history8))))","operation call obligation:(forall busy5:bool, radars6:set of (Radar), obstacles7:set of (Obstacle), history8:map (FOId) to (seq of (Position)) \u0026 (true \u003d\u003e (((fo.getId)() in set (dom history8)) and ((len history((fo.getId)())) \u003d 3))))","non-empty set obligation:(forall radars:set of (Radar) \u0026 ({(r.getDetected)() | r in set radars} \u003c\u003e {}))","type compatibility obligation:(forall msa:MinimumSafetyAltitude, pos:Position \u0026 ((msa \u003c\u003e \u003cNotAllowed\u003e) \u003d\u003e is_(msa, real)))","legal map application obligation:(forall obs:Obstacle, fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e (((fo.getId)() in set (dom history)) \u003d\u003e ((fo.getId)() in set (dom history)))))","legal map application obligation:(forall fo:FO \u0026 (((fo.getId)() in set (dom history)) \u003d\u003e ((fo.getId)() in set (dom history))))","legal map application obligation:(forall fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e (((fo.getId)() in set (dom history)) \u003d\u003e ((fo.getId)() in set (dom history)))))","legal sequence application obligation:(forall fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e (1 in set (inds vs))))","legal sequence application obligation:(forall fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e (2 in set (inds vs))))","legal sequence application obligation:(forall fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e (1 in set (inds vs))))","legal function application obligation:(forall fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e pre_predictAltitude(getAltitudeHistory(foid))))","legal sequence application obligation:(forall fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e (3 in set (inds history(foid)))))","legal map application obligation:(forall fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e (foid in set (dom history))))","legal sequence application obligation:(forall alts:seq of (nat) \u0026 (((len alts) \u003d 2) \u003d\u003e (1 in set (inds alts))))","legal sequence application obligation:(forall alts:seq of (nat) \u0026 (((len alts) \u003d 2) \u003d\u003e (1 in set (inds alts))))","legal sequence application obligation:(forall alts:seq of (nat) \u0026 (((len alts) \u003d 2) \u003d\u003e (2 in set (inds alts))))","type compatibility obligation:(forall alts:seq of (nat) \u0026 (((len alts) \u003d 2) \u003d\u003e ((alts(1) + (alts(1) - alts(2))) \u003e\u003d 0)))","operation call obligation:(forall text:seq of (char) \u0026 ((\"\" \u003d \"\") \u003c\u003d\u003e (\"\" \u003d nil)))","non-zero obligation:(forall a:real \u0026 ((a \u003c\u003e 0) \u003d\u003e (a \u003c\u003e 0)))"] \ No newline at end of file +["type compatibility obligation:(forall msa:MinimumSafetyAltitude, loc:Coordinates, ra:nat, secRa:nat, tp:ObstacleType \u0026 (ra \u003e 0))","legal function application obligation:(forall fname:String, p:nat1, isP:bool \u0026 pre_(((io.freadval))[InputTP]fname))","legal function application obligation:pre_(((io.writeval))[seq of (outline)]outlines)","while loop termination obligation:...","non-empty sequence obligation:(inlines \u003c\u003e [])","non-empty sequence obligation:(inlines \u003c\u003e [])","non-zero obligation:(forall v:Vector, n:int \u0026 ((n \u003c\u003e 0) \u003d\u003e (n \u003c\u003e 0)))","non-zero obligation:(forall v:Vector, n:int \u0026 ((n \u003c\u003e 0) \u003d\u003e (n \u003c\u003e 0)))","legal function application obligation:(forall v:Vector \u0026 pre_sqrt((((v.X) ** 2) + ((v.Y) ** 2))))","non-zero obligation:(forall v:Vector \u0026 let l:real \u003d vectorLength(v) in (l \u003c\u003e 0))","non-zero obligation:(forall v:Vector \u0026 let l:real \u003d vectorLength(v) in (l \u003c\u003e 0))","legal function application obligation:(forall v1:Vector, v2:Vector \u0026 pre_acos(dvs))","non-zero obligation:(forall r:real \u0026 (MATH`pi \u003c\u003e 0))","legal function application obligation:(forall y:real, x:real \u0026 ((not ((x \u003d 0) and (y \u003d 0))) \u003d\u003e pre_sqrt(((x ** 2) + (y ** 2)))))","non-zero obligation:(forall y:real, x:real \u0026 ((not ((x \u003d 0) and (y \u003d 0))) \u003d\u003e ((MATH`sqrt(((x ** 2) + (y ** 2))) + x) \u003c\u003e 0)))","legal function application obligation:(forall v1:Vector, v2:Vector \u0026 pre_atan2((v2.Y), (v2.X)))","legal function application obligation:(forall v1:Vector, v2:Vector \u0026 pre_atan2((v1.Y), (v1.X)))","legal function application obligation:(forall v:Vector \u0026 pre_acos(((v.X) / MATH`sqrt((((v.X) ** 2) + ((v.Y) ** 2))))))","legal function application obligation:(forall v:Vector \u0026 pre_sqrt((((v.X) ** 2) + ((v.Y) ** 2))))","non-zero obligation:(forall v:Vector \u0026 (MATH`sqrt((((v.X) ** 2) + ((v.Y) ** 2))) \u003c\u003e 0))","legal function application obligation:(forall v:Vector \u0026 pre_asin(((v.Y) / MATH`sqrt((((v.X) ** 2) + ((v.Y) ** 2))))))","legal function application obligation:(forall v:Vector \u0026 pre_sqrt((((v.X) ** 2) + ((v.Y) ** 2))))","non-zero obligation:(forall v:Vector \u0026 (MATH`sqrt((((v.X) ** 2) + ((v.Y) ** 2))) \u003c\u003e 0))","legal function application obligation:(forall x1:real, y1:real, x2:real, y2:real \u0026 pre_atan2(1.0E-6, 0.0))","state invariant initialized obligation:(forall foid1, foid2 in set (dom airspace) \u0026 ((foid1 \u003c\u003e foid2) \u003d\u003e ((airspace(foid1).getId)() \u003c\u003e (airspace(foid2).getId)())))","state invariant satisfiable obligation:(exists airspace:map (FOId) to (FO) \u0026 (forall foid1, foid2 in set (dom airspace) \u0026 ((foid1 \u003c\u003e foid2) \u003d\u003e ((airspace(foid1).getId)() \u003c\u003e (airspace(foid2).getId)()))))","state invariant holds obligation:(forall fo:FO \u0026 (((fo.getId)() not in set (dom airspace)) \u003d\u003e ((forall foid1, foid2 in set (dom airspace) \u0026 ((foid1 \u003c\u003e foid2) \u003d\u003e ((airspace(foid1).getId)() \u003c\u003e (airspace(foid2).getId)()))) \u003d\u003e (forall foid1, foid2 in set (dom airspace) \u0026 ((foid1 \u003c\u003e foid2) \u003d\u003e ((airspace(foid1).getId)() \u003c\u003e (airspace(foid2).getId)()))))))","map compatible obligation:(forall fo:FO \u0026 (((fo.getId)() not in set (dom airspace)) \u003d\u003e (forall ldom1 in set (dom airspace), rdom2 in set (dom {(fo.getId)() |-\u003e fo}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (airspace(ldom1) \u003d {(fo.getId)() |-\u003e fo}(rdom2))))))","state invariant holds obligation:(forall id:FOId \u0026 ((forall foid1, foid2 in set (dom airspace) \u0026 ((foid1 \u003c\u003e foid2) \u003d\u003e ((airspace(foid1).getId)() \u003c\u003e (airspace(foid2).getId)()))) \u003d\u003e (forall foid1, foid2 in set (dom airspace) \u0026 ((foid1 \u003c\u003e foid2) \u003d\u003e ((airspace(foid1).getId)() \u003c\u003e (airspace(foid2).getId)())))))","legal map application obligation:(forall id:FOId \u0026 ((id in set (dom airspace)) \u003d\u003e (id in set (dom airspace))))","legal map application obligation:(forall id:FOId, coord:Coordinates, alt:Altitude \u0026 (id in set (dom airspace)))","state invariant holds obligation:(forall id:FOId, coord:Coordinates, alt:Altitude \u0026 ((forall foid1, foid2 in set (dom airspace) \u0026 ((foid1 \u003c\u003e foid2) \u003d\u003e ((airspace(foid1).getId)() \u003c\u003e (airspace(foid2).getId)()))) \u003d\u003e (forall foid1, foid2 in set (dom airspace) \u0026 ((foid1 \u003c\u003e foid2) \u003d\u003e ((airspace(foid1).getId)() \u003c\u003e (airspace(foid2).getId)())))))","map compatible obligation:(forall id:FOId, coord:Coordinates, alt:Altitude \u0026 (forall ldom1 in set (dom airspace), rdom2 in set (dom {id |-\u003e newfo}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (airspace(ldom1) \u003d {id |-\u003e newfo}(rdom2)))))","state invariant holds obligation:(forall x:int, y:int, r:nat1, p:nat1, isP:bool \u0026 (forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid)))","state invariant holds obligation:(forall as:AirSpace \u0026 ((forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid)) \u003d\u003e (forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid))))","comprehension map injectivity obligation:(forall as:AirSpace \u0026 (forall m1, m2 in set {{(x.getId)() |-\u003e x} | x in set (as.getAirspace)() \u0026 InRange(x)} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4))))))","legal sequence application obligation:(forall i in set (inds priority) \u0026 ((i \u003e (floor (range / 4))) \u003d\u003e (i in set (inds priority))))","state invariant holds obligation:(forall busy1:bool, location2:Coordinates, range3:nat1, detected4:map (FOId) to (FO), priority5:seq of (FO) \u0026 ((forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid)) \u003d\u003e (forall busy6:bool, location7:Coordinates, range8:nat1, detected9:map (FOId) to (FO), priority10:seq of (FO) \u0026 ((forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid)) \u003d\u003e ((forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid)) \u003d\u003e (forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid)))))))","state invariant holds obligation:(forall fos:set of (FO) \u0026 ((forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid)) \u003d\u003e (forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid))))","legal sequence application obligation:(forall fos:set of (FO) \u0026 (forall i in set (inds priority) \u0026 ((priority(i) in set fos) \u003d\u003e (i in set (inds priority)))))","legal sequence application obligation:(forall fos:set of (FO) \u0026 (forall i in set (inds priority) \u0026 (i in set (inds priority))))","state invariant holds obligation:(forall newlyDetect:map (FOId) to (FO) \u0026 ((forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid)) \u003d\u003e (forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid))))","state invariant holds obligation:((forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid)) \u003d\u003e (forall foid in set (dom detected) \u0026 ((detected(foid).getId)() \u003d foid)))","comprehension map injectivity obligation:(forall m1, m2 in set {{(x.getId)() |-\u003e x} | x in set (as.getAirspace)() \u0026 InRange(x)} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","let be st existence obligation:(forall fos:set of (FO) \u0026 ((not (fos \u003d {})) \u003d\u003e (exists fo in set fos \u0026 true)))","recursive function obligation:(forall fos:set of (FO) \u0026 ((not (fos \u003d {})) \u003d\u003e (forall fo in set fos \u0026 (set2seqFOm(fos) \u003e set2seqFOm((fos \\ {fo}))))))","type compatibility obligation:((barrierCount - 1) \u003e\u003d 0)","while loop termination obligation:...","legal map application obligation:(forall th in set (dom wakeUpMap) \u0026 (th in set (dom wakeUpMap)))","legal map application obligation:(forall th in set (dom wakeUpMap) \u0026 ((wakeUpMap(th) \u003c\u003e nil) \u003d\u003e (th in set (dom wakeUpMap))))","operation establishes postcondition obligation:(forall x in set (rng wakeUpMap) \u0026 ((x \u003d nil) or (x \u003e\u003d currentTime)))","comprehension map injectivity obligation:(forall m1, m2 in set {(r.getDetectedMap)() | r in set radars} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","legal map application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e ((id in set (dom history)) \u003d\u003e (id in set (dom history)))))","legal map application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e (id in set (dom history))))","legal sequence application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e (3 in set (inds hist))))","legal sequence application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e (2 in set (inds hist))))","legal sequence application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e (1 in set (inds hist))))","legal map application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e ((id in set (dom history)) \u003d\u003e (id in set (dom history)))))","legal map application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e (id in set (dom history))))","legal sequence application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e (forall i in set (inds lastHist) \u0026 (i in set (inds lastHist)))))","type compatibility obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e is_(RESULT, seq of (nat))))","legal map application obligation:(forall fo:FO \u0026 (id in set (dom history)))","map compatible obligation:(forall fo:FO \u0026 (forall ldom1 in set (dom history), rdom2 in set (dom {id |-\u003e addHistory([], (fo.getCoordinates)(), (fo.getAltitude)())}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (history(ldom1) \u003d {id |-\u003e addHistory([], (fo.getCoordinates)(), (fo.getAltitude)())}(rdom2)))))","legal function application obligation:(forall hist:History, coord:Coordinates, alt:Altitude \u0026 (((len hist) \u003e 0) \u003d\u003e pre_last(hist)))","non-empty sequence obligation:(forall hist:History, coord:Coordinates, alt:Altitude \u0026 (((len hist) \u003e 0) \u003d\u003e let lastValue:Position \u003d last(hist) in ((not (lastValue \u003d mk_Position(coord, alt))) \u003d\u003e ((not ((len hist) \u003c 3)) \u003d\u003e (hist \u003c\u003e [])))))","legal sequence application obligation:(forall hist:History \u0026 (((len hist) \u003e 0) \u003d\u003e ((len hist) in set (inds hist))))","legal map application obligation:(forall busy5:bool, radars6:set of (Radar), obstacles7:set of (Obstacle), history8:map (FOId) to (seq of (Position)) \u0026 (true \u003d\u003e ((fo.getId)() in set (dom history8))))","operation call obligation:(forall busy5:bool, radars6:set of (Radar), obstacles7:set of (Obstacle), history8:map (FOId) to (seq of (Position)) \u0026 (true \u003d\u003e (((fo.getId)() in set (dom history8)) and ((len history((fo.getId)())) \u003d 3))))","non-empty set obligation:(forall radars:set of (Radar) \u0026 ({(r.getDetected)() | r in set radars} \u003c\u003e {}))","type compatibility obligation:(forall msa:MinimumSafetyAltitude, pos:Position \u0026 ((msa \u003c\u003e \u003cNotAllowed\u003e) \u003d\u003e is_(msa, real)))","legal map application obligation:(forall obs:Obstacle, fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e (((fo.getId)() in set (dom history)) \u003d\u003e ((fo.getId)() in set (dom history)))))","legal map application obligation:(forall fo:FO \u0026 (((fo.getId)() in set (dom history)) \u003d\u003e ((fo.getId)() in set (dom history))))","legal map application obligation:(forall fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e (((fo.getId)() in set (dom history)) \u003d\u003e ((fo.getId)() in set (dom history)))))","legal sequence application obligation:(forall fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e (1 in set (inds vs))))","legal sequence application obligation:(forall fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e (2 in set (inds vs))))","legal sequence application obligation:(forall fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e (1 in set (inds vs))))","legal function application obligation:(forall fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e pre_predictAltitude(getAltitudeHistory(foid))))","legal sequence application obligation:(forall fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e (3 in set (inds history(foid)))))","legal map application obligation:(forall fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e (foid in set (dom history))))","legal sequence application obligation:(forall alts:seq of (nat) \u0026 (((len alts) \u003d 2) \u003d\u003e (1 in set (inds alts))))","legal sequence application obligation:(forall alts:seq of (nat) \u0026 (((len alts) \u003d 2) \u003d\u003e (1 in set (inds alts))))","legal sequence application obligation:(forall alts:seq of (nat) \u0026 (((len alts) \u003d 2) \u003d\u003e (2 in set (inds alts))))","type compatibility obligation:(forall alts:seq of (nat) \u0026 (((len alts) \u003d 2) \u003d\u003e ((alts(1) + (alts(1) - alts(2))) \u003e\u003d 0)))","operation call obligation:(forall text:seq of (char) \u0026 ((\"\" \u003d \"\") \u003c\u003d\u003e (\"\" \u003d nil)))","non-zero obligation:(forall a:real \u0026 ((a \u003c\u003e 0) \u003d\u003e (a \u003c\u003e 0)))"] \ No newline at end of file diff --git a/core/pog/src/test/resources/examples/MSAWseqPP.result b/core/pog/src/test/resources/examples/MSAWseqPP.result index e378948b0f..db1a976cb7 100644 --- a/core/pog/src/test/resources/examples/MSAWseqPP.result +++ b/core/pog/src/test/resources/examples/MSAWseqPP.result @@ -1 +1 @@ -["type compatibility obligation:(forall msa:MinimumSafetyAltitude, loc:Coordinates, ra:nat, secRa:nat, tp:ObstacleType \u0026 (ra \u003e 0))","legal function application obligation:(forall fname:String \u0026 pre_(((io.freadval))[seq of (inline)]fname))","type compatibility obligation:(forall fname:String \u0026 is_(input, seq of (inline)))","legal function application obligation:pre_(((io.writeval))[seq of (outline)]outlines)","while loop termination obligation:NotYetImplemented","while loop termination obligation:NotYetImplemented","non-empty sequence obligation:(inlines \u003c\u003e [])","non-empty sequence obligation:(inlines \u003c\u003e [])","type invariant satisfiable obligation:(exists a:Altitude \u0026 (a \u003e\u003d 0))","non-zero obligation:(forall v:Vector, n:int \u0026 ((n \u003c\u003e 0) \u003d\u003e (n \u003c\u003e 0)))","non-zero obligation:(forall v:Vector, n:int \u0026 ((n \u003c\u003e 0) \u003d\u003e (n \u003c\u003e 0)))","legal function application obligation:(forall v:Vector \u0026 pre_sqrt((((v.X) ** 2) + ((v.Y) ** 2))))","non-zero obligation:(forall v:Vector \u0026 let l:real \u003d vectorLength(v) in (l \u003c\u003e 0))","non-zero obligation:(forall v:Vector \u0026 let l:real \u003d vectorLength(v) in (l \u003c\u003e 0))","legal function application obligation:(forall v1:Vector, v2:Vector \u0026 pre_acos(dvs))","non-zero obligation:(forall r:real \u0026 (MATH`pi \u003c\u003e 0))","legal function application obligation:(forall y:real, x:real \u0026 ((not ((x \u003d 0) and (y \u003d 0))) \u003d\u003e pre_sqrt(((x ** 2) + (y ** 2)))))","non-zero obligation:(forall y:real, x:real \u0026 ((not ((x \u003d 0) and (y \u003d 0))) \u003d\u003e ((MATH`sqrt(((x ** 2) + (y ** 2))) + x) \u003c\u003e 0)))","legal function application obligation:(forall v1:Vector, v2:Vector \u0026 pre_atan2((v2.Y), (v2.X)))","legal function application obligation:(forall v1:Vector, v2:Vector \u0026 pre_atan2((v1.Y), (v1.X)))","legal function application obligation:(forall v:Vector \u0026 pre_acos(((v.X) / MATH`sqrt((((v.X) ** 2) + ((v.Y) ** 2))))))","legal function application obligation:(forall v:Vector \u0026 pre_sqrt((((v.X) ** 2) + ((v.Y) ** 2))))","non-zero obligation:(forall v:Vector \u0026 (MATH`sqrt((((v.X) ** 2) + ((v.Y) ** 2))) \u003c\u003e 0))","legal function application obligation:(forall v:Vector \u0026 pre_asin(((v.Y) / MATH`sqrt((((v.X) ** 2) + ((v.Y) ** 2))))))","legal function application obligation:(forall v:Vector \u0026 pre_sqrt((((v.X) ** 2) + ((v.Y) ** 2))))","non-zero obligation:(forall v:Vector \u0026 (MATH`sqrt((((v.X) ** 2) + ((v.Y) ** 2))) \u003c\u003e 0))","legal function application obligation:(forall x1:real, y1:real, x2:real, y2:real \u0026 pre_atan2(1.0E-6, 0.0))","legal map application obligation:(forall id:FOId \u0026 ((id in set (dom airspace)) \u003d\u003e (id in set (dom airspace))))","legal map application obligation:(forall id:FOId, coord:Coordinates, alt:Altitude \u0026 (id in set (dom airspace)))","map compatible obligation:(forall id:FOId, coord:Coordinates, alt:Altitude \u0026 (forall ldom1 in set (dom airspace), rdom2 in set (dom {id |-\u003e newfo}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (airspace(ldom1) \u003d {id |-\u003e newfo}(rdom2)))))","comprehension map injectivity obligation:(forall as:AirSpace \u0026 (forall m1, m2 in set {{(x.getId)() |-\u003e x} | x in set (as.getAirspace)() \u0026 InRange(x)} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4))))))","legal sequence application obligation:(forall i in set (inds priority) \u0026 ((i \u003e (floor (range / 4))) \u003d\u003e (i in set (inds priority))))","legal function application obligation:pre_(token2seq_of_char(fobj.getId)())","legal sequence application obligation:(forall fos:set of (FO) \u0026 (forall i in set (inds priority) \u0026 ((priority(i) in set fos) \u003d\u003e (i in set (inds priority)))))","legal sequence application obligation:(forall fos:set of (FO) \u0026 (forall i in set (inds priority) \u0026 (i in set (inds priority))))","legal function application obligation:(forall r:dk_au_eng_Radar \u0026 pre_(int2seq_of_charx))","type compatibility obligation:(forall r:dk_au_eng_Radar \u0026 is_(x, int))","legal function application obligation:(forall r:dk_au_eng_Radar \u0026 pre_(int2seq_of_chary))","type compatibility obligation:(forall r:dk_au_eng_Radar \u0026 is_(y, int))","let be st existence obligation:(forall fos:set of (FO) \u0026 ((not (fos \u003d {})) \u003d\u003e (exists fo in set fos \u0026 true)))","recursive function obligation:(forall fos:set of (FO) \u0026 ((not (fos \u003d {})) \u003d\u003e (forall fo in set fos \u0026 (set2seqFOm(fos) \u003e set2seqFOm((fos \\ {fo}))))))","legal map application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e ((id in set (dom history)) \u003d\u003e (id in set (dom history)))))","legal map application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e (id in set (dom history))))","legal sequence application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e (3 in set (inds hist))))","legal sequence application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e (2 in set (inds hist))))","legal sequence application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e (1 in set (inds hist))))","legal map application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e ((id in set (dom history)) \u003d\u003e (id in set (dom history)))))","legal map application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e (id in set (dom history))))","legal sequence application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e (forall i in set (inds lastHist) \u0026 (i in set (inds lastHist)))))","type compatibility obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e is_(RESULT, seq of (nat))))","legal map application obligation:(forall fo:FO \u0026 (id in set (dom history)))","map compatible obligation:(forall fo:FO \u0026 (forall ldom1 in set (dom history), rdom2 in set (dom {id |-\u003e addHistory([], coor, alt)}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (history(ldom1) \u003d {id |-\u003e addHistory([], coor, alt)}(rdom2)))))","non-empty sequence obligation:(forall hist:History, coord:Coordinates, alt:Altitude \u0026 ((not ((len hist) \u003c 3)) \u003d\u003e (hist \u003c\u003e [])))","legal map application obligation:(forall radars4:set of (Radar), obstacles5:set of (Obstacle), history6:map (FOId) to (seq of (Position)) \u0026 (true \u003d\u003e ((fo.getId)() in set (dom history6))))","operation call obligation:(forall radars4:set of (Radar), obstacles5:set of (Obstacle), history6:map (FOId) to (seq of (Position)) \u0026 (true \u003d\u003e (((fo.getId)() in set (dom history6)) and ((len history((fo.getId)())) \u003d 3))))","non-empty set obligation:(forall r:set of (Radar) \u0026 ({(rad.getDetected)() | rad in set r} \u003c\u003e {}))","type compatibility obligation:(forall msa:MinimumSafetyAltitude, pos:Position \u0026 ((msa \u003c\u003e \u003cNotAllowed\u003e) \u003d\u003e is_(msa, real)))","legal map application obligation:(forall obs:Obstacle, fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e (((fo.getId)() in set (dom history)) \u003d\u003e ((fo.getId)() in set (dom history)))))","legal map application obligation:(forall fo:FO \u0026 (((fo.getId)() in set (dom history)) \u003d\u003e ((fo.getId)() in set (dom history))))","legal map application obligation:(forall fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e (((fo.getId)() in set (dom history)) \u003d\u003e ((fo.getId)() in set (dom history)))))","legal sequence application obligation:(forall fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e (1 in set (inds vs))))","legal sequence application obligation:(forall fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e (2 in set (inds vs))))","legal sequence application obligation:(forall fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e (1 in set (inds vs))))","legal function application obligation:(forall fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e pre_predictAltitude(getAltitudeHistory(foid))))","legal sequence application obligation:(forall fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e (3 in set (inds history(foid)))))","legal map application obligation:(forall fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e (foid in set (dom history))))","type compatibility obligation:(forall fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e inv_Altitude(estAlt)))","legal sequence application obligation:(forall alts:seq of (nat) \u0026 (((len alts) \u003d 2) \u003d\u003e (1 in set (inds alts))))","legal sequence application obligation:(forall alts:seq of (nat) \u0026 (((len alts) \u003d 2) \u003d\u003e (1 in set (inds alts))))","legal sequence application obligation:(forall alts:seq of (nat) \u0026 (((len alts) \u003d 2) \u003d\u003e (2 in set (inds alts))))","type compatibility obligation:(forall alts:seq of (nat) \u0026 (((len alts) \u003d 2) \u003d\u003e ((alts(1) + (alts(1) - alts(2))) \u003e\u003d 0)))","operation call obligation:(forall text:seq of (char) \u0026 ((\"\" \u003d \"\") \u003c\u003d\u003e (\"\" \u003d nil)))","non-zero obligation:(forall a:real \u0026 ((a \u003c\u003e 0) \u003d\u003e (a \u003c\u003e 0)))"] \ No newline at end of file +["type compatibility obligation:(forall msa:MinimumSafetyAltitude, loc:Coordinates, ra:nat, secRa:nat, tp:ObstacleType \u0026 (ra \u003e 0))","legal function application obligation:(forall fname:String \u0026 pre_(((io.freadval))[seq of (inline)]fname))","type compatibility obligation:(forall fname:String \u0026 is_(input, seq of (inline)))","legal function application obligation:pre_(((io.writeval))[seq of (outline)]outlines)","while loop termination obligation:...","while loop termination obligation:...","non-empty sequence obligation:(inlines \u003c\u003e [])","non-empty sequence obligation:(inlines \u003c\u003e [])","type invariant satisfiable obligation:(exists a:Altitude \u0026 (a \u003e\u003d 0))","non-zero obligation:(forall v:Vector, n:int \u0026 ((n \u003c\u003e 0) \u003d\u003e (n \u003c\u003e 0)))","non-zero obligation:(forall v:Vector, n:int \u0026 ((n \u003c\u003e 0) \u003d\u003e (n \u003c\u003e 0)))","legal function application obligation:(forall v:Vector \u0026 pre_sqrt((((v.X) ** 2) + ((v.Y) ** 2))))","non-zero obligation:(forall v:Vector \u0026 let l:real \u003d vectorLength(v) in (l \u003c\u003e 0))","non-zero obligation:(forall v:Vector \u0026 let l:real \u003d vectorLength(v) in (l \u003c\u003e 0))","legal function application obligation:(forall v1:Vector, v2:Vector \u0026 pre_acos(dvs))","non-zero obligation:(forall r:real \u0026 (MATH`pi \u003c\u003e 0))","legal function application obligation:(forall y:real, x:real \u0026 ((not ((x \u003d 0) and (y \u003d 0))) \u003d\u003e pre_sqrt(((x ** 2) + (y ** 2)))))","non-zero obligation:(forall y:real, x:real \u0026 ((not ((x \u003d 0) and (y \u003d 0))) \u003d\u003e ((MATH`sqrt(((x ** 2) + (y ** 2))) + x) \u003c\u003e 0)))","legal function application obligation:(forall v1:Vector, v2:Vector \u0026 pre_atan2((v2.Y), (v2.X)))","legal function application obligation:(forall v1:Vector, v2:Vector \u0026 pre_atan2((v1.Y), (v1.X)))","legal function application obligation:(forall v:Vector \u0026 pre_acos(((v.X) / MATH`sqrt((((v.X) ** 2) + ((v.Y) ** 2))))))","legal function application obligation:(forall v:Vector \u0026 pre_sqrt((((v.X) ** 2) + ((v.Y) ** 2))))","non-zero obligation:(forall v:Vector \u0026 (MATH`sqrt((((v.X) ** 2) + ((v.Y) ** 2))) \u003c\u003e 0))","legal function application obligation:(forall v:Vector \u0026 pre_asin(((v.Y) / MATH`sqrt((((v.X) ** 2) + ((v.Y) ** 2))))))","legal function application obligation:(forall v:Vector \u0026 pre_sqrt((((v.X) ** 2) + ((v.Y) ** 2))))","non-zero obligation:(forall v:Vector \u0026 (MATH`sqrt((((v.X) ** 2) + ((v.Y) ** 2))) \u003c\u003e 0))","legal function application obligation:(forall x1:real, y1:real, x2:real, y2:real \u0026 pre_atan2(1.0E-6, 0.0))","legal map application obligation:(forall id:FOId \u0026 ((id in set (dom airspace)) \u003d\u003e (id in set (dom airspace))))","legal map application obligation:(forall id:FOId, coord:Coordinates, alt:Altitude \u0026 (id in set (dom airspace)))","map compatible obligation:(forall id:FOId, coord:Coordinates, alt:Altitude \u0026 (forall ldom1 in set (dom airspace), rdom2 in set (dom {id |-\u003e newfo}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (airspace(ldom1) \u003d {id |-\u003e newfo}(rdom2)))))","comprehension map injectivity obligation:(forall as:AirSpace \u0026 (forall m1, m2 in set {{(x.getId)() |-\u003e x} | x in set (as.getAirspace)() \u0026 InRange(x)} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4))))))","legal sequence application obligation:(forall i in set (inds priority) \u0026 ((i \u003e (floor (range / 4))) \u003d\u003e (i in set (inds priority))))","legal function application obligation:pre_(token2seq_of_char(fobj.getId)())","legal sequence application obligation:(forall fos:set of (FO) \u0026 (forall i in set (inds priority) \u0026 ((priority(i) in set fos) \u003d\u003e (i in set (inds priority)))))","legal sequence application obligation:(forall fos:set of (FO) \u0026 (forall i in set (inds priority) \u0026 (i in set (inds priority))))","legal function application obligation:(forall r:dk_au_eng_Radar \u0026 pre_(int2seq_of_charx))","type compatibility obligation:(forall r:dk_au_eng_Radar \u0026 is_(x, int))","legal function application obligation:(forall r:dk_au_eng_Radar \u0026 pre_(int2seq_of_chary))","type compatibility obligation:(forall r:dk_au_eng_Radar \u0026 is_(y, int))","let be st existence obligation:(forall fos:set of (FO) \u0026 ((not (fos \u003d {})) \u003d\u003e (exists fo in set fos \u0026 true)))","recursive function obligation:(forall fos:set of (FO) \u0026 ((not (fos \u003d {})) \u003d\u003e (forall fo in set fos \u0026 (set2seqFOm(fos) \u003e set2seqFOm((fos \\ {fo}))))))","legal map application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e ((id in set (dom history)) \u003d\u003e (id in set (dom history)))))","legal map application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e (id in set (dom history))))","legal sequence application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e (3 in set (inds hist))))","legal sequence application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e (2 in set (inds hist))))","legal sequence application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e (1 in set (inds hist))))","legal map application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e ((id in set (dom history)) \u003d\u003e (id in set (dom history)))))","legal map application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e (id in set (dom history))))","legal sequence application obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e (forall i in set (inds lastHist) \u0026 (i in set (inds lastHist)))))","type compatibility obligation:(forall id:FOId \u0026 (((id in set (dom history)) and ((len history(id)) \u003d 3)) \u003d\u003e is_(RESULT, seq of (nat))))","legal map application obligation:(forall fo:FO \u0026 (id in set (dom history)))","map compatible obligation:(forall fo:FO \u0026 (forall ldom1 in set (dom history), rdom2 in set (dom {id |-\u003e addHistory([], coor, alt)}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (history(ldom1) \u003d {id |-\u003e addHistory([], coor, alt)}(rdom2)))))","non-empty sequence obligation:(forall hist:History, coord:Coordinates, alt:Altitude \u0026 ((not ((len hist) \u003c 3)) \u003d\u003e (hist \u003c\u003e [])))","legal map application obligation:(forall radars4:set of (Radar), obstacles5:set of (Obstacle), history6:map (FOId) to (seq of (Position)) \u0026 (true \u003d\u003e ((fo.getId)() in set (dom history6))))","operation call obligation:(forall radars4:set of (Radar), obstacles5:set of (Obstacle), history6:map (FOId) to (seq of (Position)) \u0026 (true \u003d\u003e (((fo.getId)() in set (dom history6)) and ((len history((fo.getId)())) \u003d 3))))","non-empty set obligation:(forall r:set of (Radar) \u0026 ({(rad.getDetected)() | rad in set r} \u003c\u003e {}))","type compatibility obligation:(forall msa:MinimumSafetyAltitude, pos:Position \u0026 ((msa \u003c\u003e \u003cNotAllowed\u003e) \u003d\u003e is_(msa, real)))","legal map application obligation:(forall obs:Obstacle, fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e (((fo.getId)() in set (dom history)) \u003d\u003e ((fo.getId)() in set (dom history)))))","legal map application obligation:(forall fo:FO \u0026 (((fo.getId)() in set (dom history)) \u003d\u003e ((fo.getId)() in set (dom history))))","legal map application obligation:(forall fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e (((fo.getId)() in set (dom history)) \u003d\u003e ((fo.getId)() in set (dom history)))))","legal sequence application obligation:(forall fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e (1 in set (inds vs))))","legal sequence application obligation:(forall fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e (2 in set (inds vs))))","legal sequence application obligation:(forall fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e (1 in set (inds vs))))","legal function application obligation:(forall fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e pre_predictAltitude(getAltitudeHistory(foid))))","legal sequence application obligation:(forall fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e (3 in set (inds history(foid)))))","legal map application obligation:(forall fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e (foid in set (dom history))))","type compatibility obligation:(forall fo:FO \u0026 ((((fo.getId)() in set (dom history)) and ((len history((fo.getId)())) \u003d 3)) \u003d\u003e inv_Altitude(estAlt)))","legal sequence application obligation:(forall alts:seq of (nat) \u0026 (((len alts) \u003d 2) \u003d\u003e (1 in set (inds alts))))","legal sequence application obligation:(forall alts:seq of (nat) \u0026 (((len alts) \u003d 2) \u003d\u003e (1 in set (inds alts))))","legal sequence application obligation:(forall alts:seq of (nat) \u0026 (((len alts) \u003d 2) \u003d\u003e (2 in set (inds alts))))","type compatibility obligation:(forall alts:seq of (nat) \u0026 (((len alts) \u003d 2) \u003d\u003e ((alts(1) + (alts(1) - alts(2))) \u003e\u003d 0)))","operation call obligation:(forall text:seq of (char) \u0026 ((\"\" \u003d \"\") \u003c\u003d\u003e (\"\" \u003d nil)))","non-zero obligation:(forall a:real \u0026 ((a \u003c\u003e 0) \u003d\u003e (a \u003c\u003e 0)))"] \ No newline at end of file diff --git a/core/pog/src/test/resources/examples/PacemakerConcPP.result b/core/pog/src/test/resources/examples/PacemakerConcPP.result index 7d6125244f..a0e76e60c9 100644 --- a/core/pog/src/test/resources/examples/PacemakerConcPP.result +++ b/core/pog/src/test/resources/examples/PacemakerConcPP.result @@ -1 +1 @@ -["type compatibility obligation:(forall p:nat1, isP:bool \u0026 inv_PPM(60))","type compatibility obligation:(forall p:nat1, isP:bool \u0026 inv_PPM(120))","non-zero obligation:(forall p:nat1, isP:bool \u0026 (((60 / 60) / 1000) \u003c\u003e 0))","type compatibility obligation:(forall p:nat1, isP:bool \u0026 is_((1 / ((LRL / 60) / 1000)), nat))","state invariant holds obligation:(forall p:nat1, isP:bool \u0026 ((MED \u003c 8) and ((10 in set {10, ... ,50}) and ((2 in set {2, ... ,16}) and (8 \u003c\u003d 16)))))","state invariant holds obligation:(forall rateplan1:map (Time) to (Time), sensed2:[ActivityData], interval3:Time, finished4:bool, LRL5:PPM, MSR6:PPM, threshold7:nat1, reactionT8:Time, recoveryT9:Time, responseF10:nat1 \u0026 (((threshold7 \u003c 8) and ((reactionT8 in set {10, ... ,50}) and ((recoveryT9 in set {2, ... ,16}) and (responseF10 \u003c\u003d 16)))) \u003d\u003e (forall rateplan11:map (Time) to (Time), sensed12:[ActivityData], interval13:Time, finished14:bool, LRL15:PPM, MSR16:PPM, threshold17:nat1, reactionT18:Time, recoveryT19:Time, responseF20:nat1 \u0026 (((threshold17 \u003c 8) and ((reactionT18 in set {10, ... ,50}) and ((recoveryT19 in set {2, ... ,16}) and (responseF20 \u003c\u003d 16)))) \u003d\u003e (((threshold17 \u003c 8) and ((reactionT18 in set {10, ... ,50}) and ((recoveryT19 in set {2, ... ,16}) and (responseF20 \u003c\u003d 16)))) \u003d\u003e ((threshold17 \u003c 8) and ((reactionT18 in set {10, ... ,50}) and ((recoveryT19 in set {2, ... ,16}) and (responseF20 \u003c\u003d 16)))))))))","state invariant holds obligation:(forall ad:ActivityData \u0026 (((threshold \u003c 8) and ((reactionT in set {10, ... ,50}) and ((recoveryT in set {2, ... ,16}) and (responseF \u003c\u003d 16)))) \u003d\u003e ((threshold \u003c 8) and ((reactionT in set {10, ... ,50}) and ((recoveryT in set {2, ... ,16}) and (responseF \u003c\u003d 16))))))","type compatibility obligation:(forall ad:ActivityData \u0026 is_(ad, [ActivityData]))","state invariant holds obligation:(((threshold \u003c 8) and ((reactionT in set {10, ... ,50}) and ((recoveryT in set {2, ... ,16}) and (responseF \u003c\u003d 16)))) \u003d\u003e ((threshold \u003c 8) and ((reactionT in set {10, ... ,50}) and ((recoveryT in set {2, ... ,16}) and (responseF \u003c\u003d 16)))))","non-zero obligation:(((MSR / 60) / 1000) \u003c\u003e 0)","type compatibility obligation:is_((1 / ((MSR / 60) / 1000)), nat)","state invariant holds obligation:(((threshold \u003c 8) and ((reactionT in set {10, ... ,50}) and ((recoveryT in set {2, ... ,16}) and (responseF \u003c\u003d 16)))) \u003d\u003e ((threshold \u003c 8) and ((reactionT in set {10, ... ,50}) and ((recoveryT in set {2, ... ,16}) and (responseF \u003c\u003d 16)))))","non-zero obligation:(((LRL / 60) / 1000) \u003c\u003e 0)","type compatibility obligation:is_((1 / ((LRL / 60) / 1000)), nat)","state invariant holds obligation:(((threshold \u003c 8) and ((reactionT in set {10, ... ,50}) and ((recoveryT in set {2, ... ,16}) and (responseF \u003c\u003d 16)))) \u003d\u003e ((threshold \u003c 8) and ((reactionT in set {10, ... ,50}) and ((recoveryT in set {2, ... ,16}) and (responseF \u003c\u003d 16)))))","type compatibility obligation:inv_ActivityData(4)","type invariant satisfiable obligation:(exists a:ActivityData \u0026 (a \u003c\u003d 7))","type invariant satisfiable obligation:(exists ppm:PPM \u0026 ((ppm \u003e\u003d 30) and (ppm \u003c\u003d 175)))","legal map application obligation:((\u003cATRIA\u003e in set (dom sensed)) \u003d\u003e (\u003cATRIA\u003e in set (dom sensed)))","type compatibility obligation:((barrierCount - 1) \u003e\u003d 0)","while loop termination obligation:NotYetImplemented","legal map application obligation:(forall th in set (dom wakeUpMap) \u0026 (th in set (dom wakeUpMap)))","legal map application obligation:(forall th in set (dom wakeUpMap) \u0026 ((wakeUpMap(th) \u003c\u003e nil) \u003d\u003e (th in set (dom wakeUpMap))))","operation establishes postcondition obligation:(forall x in set (rng wakeUpMap) \u0026 ((x \u003d nil) or (x \u003e\u003d currentTime)))","type invariant satisfiable obligation:(exists inp:InputTP \u0026 (forall line in set (elems (inp.#2)) \u0026 ((inp.#1) \u003e\u003d (line.#4))))","legal function application obligation:(forall fname:seq of (char), p:nat1, isP:bool \u0026 pre_(((io.freadval))[InputTP]fname))","while loop termination obligation:NotYetImplemented","non-empty sequence obligation:(inplines \u003c\u003e [])","non-empty sequence obligation:(inplines \u003c\u003e [])","legal function application obligation:pre_(((io.writeval))[seq of (Outline)]outlines)","operation call obligation:(forall text:seq of (char) \u0026 ((\"\" \u003d \"\") \u003c\u003d\u003e (\"\" \u003d nil)))"] \ No newline at end of file +["type compatibility obligation:(forall p:nat1, isP:bool \u0026 inv_PPM(60))","type compatibility obligation:(forall p:nat1, isP:bool \u0026 inv_PPM(120))","non-zero obligation:(forall p:nat1, isP:bool \u0026 (((60 / 60) / 1000) \u003c\u003e 0))","type compatibility obligation:(forall p:nat1, isP:bool \u0026 is_((1 / ((LRL / 60) / 1000)), nat))","state invariant holds obligation:(forall p:nat1, isP:bool \u0026 ((MED \u003c 8) and ((10 in set {10, ... ,50}) and ((2 in set {2, ... ,16}) and (8 \u003c\u003d 16)))))","state invariant holds obligation:(forall rateplan1:map (Time) to (Time), sensed2:[ActivityData], interval3:Time, finished4:bool, LRL5:PPM, MSR6:PPM, threshold7:nat1, reactionT8:Time, recoveryT9:Time, responseF10:nat1 \u0026 (((threshold7 \u003c 8) and ((reactionT8 in set {10, ... ,50}) and ((recoveryT9 in set {2, ... ,16}) and (responseF10 \u003c\u003d 16)))) \u003d\u003e (forall rateplan11:map (Time) to (Time), sensed12:[ActivityData], interval13:Time, finished14:bool, LRL15:PPM, MSR16:PPM, threshold17:nat1, reactionT18:Time, recoveryT19:Time, responseF20:nat1 \u0026 (((threshold17 \u003c 8) and ((reactionT18 in set {10, ... ,50}) and ((recoveryT19 in set {2, ... ,16}) and (responseF20 \u003c\u003d 16)))) \u003d\u003e (((threshold17 \u003c 8) and ((reactionT18 in set {10, ... ,50}) and ((recoveryT19 in set {2, ... ,16}) and (responseF20 \u003c\u003d 16)))) \u003d\u003e ((threshold17 \u003c 8) and ((reactionT18 in set {10, ... ,50}) and ((recoveryT19 in set {2, ... ,16}) and (responseF20 \u003c\u003d 16)))))))))","state invariant holds obligation:(forall ad:ActivityData \u0026 (((threshold \u003c 8) and ((reactionT in set {10, ... ,50}) and ((recoveryT in set {2, ... ,16}) and (responseF \u003c\u003d 16)))) \u003d\u003e ((threshold \u003c 8) and ((reactionT in set {10, ... ,50}) and ((recoveryT in set {2, ... ,16}) and (responseF \u003c\u003d 16))))))","type compatibility obligation:(forall ad:ActivityData \u0026 is_(ad, [ActivityData]))","state invariant holds obligation:(((threshold \u003c 8) and ((reactionT in set {10, ... ,50}) and ((recoveryT in set {2, ... ,16}) and (responseF \u003c\u003d 16)))) \u003d\u003e ((threshold \u003c 8) and ((reactionT in set {10, ... ,50}) and ((recoveryT in set {2, ... ,16}) and (responseF \u003c\u003d 16)))))","non-zero obligation:(((MSR / 60) / 1000) \u003c\u003e 0)","type compatibility obligation:is_((1 / ((MSR / 60) / 1000)), nat)","state invariant holds obligation:(((threshold \u003c 8) and ((reactionT in set {10, ... ,50}) and ((recoveryT in set {2, ... ,16}) and (responseF \u003c\u003d 16)))) \u003d\u003e ((threshold \u003c 8) and ((reactionT in set {10, ... ,50}) and ((recoveryT in set {2, ... ,16}) and (responseF \u003c\u003d 16)))))","non-zero obligation:(((LRL / 60) / 1000) \u003c\u003e 0)","type compatibility obligation:is_((1 / ((LRL / 60) / 1000)), nat)","state invariant holds obligation:(((threshold \u003c 8) and ((reactionT in set {10, ... ,50}) and ((recoveryT in set {2, ... ,16}) and (responseF \u003c\u003d 16)))) \u003d\u003e ((threshold \u003c 8) and ((reactionT in set {10, ... ,50}) and ((recoveryT in set {2, ... ,16}) and (responseF \u003c\u003d 16)))))","type compatibility obligation:inv_ActivityData(4)","type invariant satisfiable obligation:(exists a:ActivityData \u0026 (a \u003c\u003d 7))","type invariant satisfiable obligation:(exists ppm:PPM \u0026 ((ppm \u003e\u003d 30) and (ppm \u003c\u003d 175)))","legal map application obligation:((\u003cATRIA\u003e in set (dom sensed)) \u003d\u003e (\u003cATRIA\u003e in set (dom sensed)))","type compatibility obligation:((barrierCount - 1) \u003e\u003d 0)","while loop termination obligation:...","legal map application obligation:(forall th in set (dom wakeUpMap) \u0026 (th in set (dom wakeUpMap)))","legal map application obligation:(forall th in set (dom wakeUpMap) \u0026 ((wakeUpMap(th) \u003c\u003e nil) \u003d\u003e (th in set (dom wakeUpMap))))","operation establishes postcondition obligation:(forall x in set (rng wakeUpMap) \u0026 ((x \u003d nil) or (x \u003e\u003d currentTime)))","type invariant satisfiable obligation:(exists inp:InputTP \u0026 (forall line in set (elems (inp.#2)) \u0026 ((inp.#1) \u003e\u003d (line.#4))))","legal function application obligation:(forall fname:seq of (char), p:nat1, isP:bool \u0026 pre_(((io.freadval))[InputTP]fname))","while loop termination obligation:...","non-empty sequence obligation:(inplines \u003c\u003e [])","non-empty sequence obligation:(inplines \u003c\u003e [])","legal function application obligation:pre_(((io.writeval))[seq of (Outline)]outlines)","operation call obligation:(forall text:seq of (char) \u0026 ((\"\" \u003d \"\") \u003c\u003d\u003e (\"\" \u003d nil)))"] \ No newline at end of file diff --git a/core/pog/src/test/resources/examples/PacemakerRT.result b/core/pog/src/test/resources/examples/PacemakerRT.result index d9d7cf963e..f34393cac5 100644 --- a/core/pog/src/test/resources/examples/PacemakerRT.result +++ b/core/pog/src/test/resources/examples/PacemakerRT.result @@ -1 +1 @@ -["type invariant satisfiable obligation:(exists a:ActivityData \u0026 (a \u003c\u003d 7))","type invariant satisfiable obligation:(exists ppm:PPM \u0026 ((ppm \u003e\u003d 30) and (ppm \u003c\u003d 175)))","type compatibility obligation:inv_PPM(60)","type compatibility obligation:inv_PPM(120)","non-zero obligation:(((60 / 60) / 10000) \u003c\u003e 0)","type compatibility obligation:is_((1 / ((LRL / 60) / 10000)), nat)","state invariant holds obligation:((MED \u003c 8) and ((10 in set {10, ... ,50}) and ((2 in set {2, ... ,16}) and (8 \u003c\u003d 16))))","state invariant holds obligation:(forall rateplan1:map (Time) to (Time), sensed2:[ActivityData], interval3:Time, finished4:bool, LRL5:PPM, MSR6:PPM, threshold7:nat1, reactionT8:Time, recoveryT9:Time, responseF10:nat1 \u0026 (((threshold7 \u003c 8) and ((reactionT8 in set {10, ... ,50}) and ((recoveryT9 in set {2, ... ,16}) and (responseF10 \u003c\u003d 16)))) \u003d\u003e (forall rateplan11:map (Time) to (Time), sensed12:[ActivityData], interval13:Time, finished14:bool, LRL15:PPM, MSR16:PPM, threshold17:nat1, reactionT18:Time, recoveryT19:Time, responseF20:nat1 \u0026 (((threshold17 \u003c 8) and ((reactionT18 in set {10, ... ,50}) and ((recoveryT19 in set {2, ... ,16}) and (responseF20 \u003c\u003d 16)))) \u003d\u003e (((threshold17 \u003c 8) and ((reactionT18 in set {10, ... ,50}) and ((recoveryT19 in set {2, ... ,16}) and (responseF20 \u003c\u003d 16)))) \u003d\u003e ((threshold17 \u003c 8) and ((reactionT18 in set {10, ... ,50}) and ((recoveryT19 in set {2, ... ,16}) and (responseF20 \u003c\u003d 16)))))))))","state invariant holds obligation:(forall ad:ActivityData \u0026 (((threshold \u003c 8) and ((reactionT in set {10, ... ,50}) and ((recoveryT in set {2, ... ,16}) and (responseF \u003c\u003d 16)))) \u003d\u003e ((threshold \u003c 8) and ((reactionT in set {10, ... ,50}) and ((recoveryT in set {2, ... ,16}) and (responseF \u003c\u003d 16))))))","type compatibility obligation:(forall ad:ActivityData \u0026 is_(ad, [ActivityData]))","state invariant holds obligation:(((threshold \u003c 8) and ((reactionT in set {10, ... ,50}) and ((recoveryT in set {2, ... ,16}) and (responseF \u003c\u003d 16)))) \u003d\u003e ((threshold \u003c 8) and ((reactionT in set {10, ... ,50}) and ((recoveryT in set {2, ... ,16}) and (responseF \u003c\u003d 16)))))","non-zero obligation:(((MSR / 60) / 10000) \u003c\u003e 0)","type compatibility obligation:is_((1 / ((MSR / 60) / 10000)), nat)","state invariant holds obligation:(((threshold \u003c 8) and ((reactionT in set {10, ... ,50}) and ((recoveryT in set {2, ... ,16}) and (responseF \u003c\u003d 16)))) \u003d\u003e ((threshold \u003c 8) and ((reactionT in set {10, ... ,50}) and ((recoveryT in set {2, ... ,16}) and (responseF \u003c\u003d 16)))))","non-zero obligation:(((LRL / 60) / 10000) \u003c\u003e 0)","type compatibility obligation:is_((1 / ((LRL / 60) / 10000)), nat)","state invariant holds obligation:(((threshold \u003c 8) and ((reactionT in set {10, ... ,50}) and ((recoveryT in set {2, ... ,16}) and (responseF \u003c\u003d 16)))) \u003d\u003e ((threshold \u003c 8) and ((reactionT in set {10, ... ,50}) and ((recoveryT in set {2, ... ,16}) and (responseF \u003c\u003d 16)))))","type compatibility obligation:inv_ActivityData(4)","legal map application obligation:((\u003cATRIA\u003e in set (dom sensed)) \u003d\u003e (\u003cATRIA\u003e in set (dom sensed)))","type invariant satisfiable obligation:(exists inp:InputTP \u0026 (forall line in set (elems (inp.#2)) \u0026 ((inp.#1) \u003e\u003d (line.#4))))","legal function application obligation:(forall fname:seq1 of (char) \u0026 pre_(((io.freadval))[InputTP]fname))","while loop termination obligation:NotYetImplemented","non-empty sequence obligation:(inplines \u003c\u003e [])","legal function application obligation:pre_(((io.writeval))[seq of (Outline)]convert(outlines))","legal sequence application obligation:(forall s:seq of (Outline) \u0026 (forall i in set (inds s) \u0026 (i in set (inds s))))","legal sequence application obligation:(forall s:seq of (Outline) \u0026 (forall i in set (inds s) \u0026 (i in set (inds s))))","legal sequence application obligation:(forall s:seq of (Outline) \u0026 (forall i in set (inds s) \u0026 (i in set (inds s))))","type compatibility obligation:(forall s:seq of (Outline) \u0026 is_([mk_((s(i).#1), (s(i).#2), (floor ((s(i).#3) / 10))) | i in set (inds s)], seq of (Outline)))","operation call obligation:(forall text:seq of (char) \u0026 ((\"\" \u003d \"\") \u003c\u003d\u003e (\"\" \u003d nil)))"] \ No newline at end of file +["type invariant satisfiable obligation:(exists a:ActivityData \u0026 (a \u003c\u003d 7))","type invariant satisfiable obligation:(exists ppm:PPM \u0026 ((ppm \u003e\u003d 30) and (ppm \u003c\u003d 175)))","type compatibility obligation:inv_PPM(60)","type compatibility obligation:inv_PPM(120)","non-zero obligation:(((60 / 60) / 10000) \u003c\u003e 0)","type compatibility obligation:is_((1 / ((LRL / 60) / 10000)), nat)","state invariant holds obligation:((MED \u003c 8) and ((10 in set {10, ... ,50}) and ((2 in set {2, ... ,16}) and (8 \u003c\u003d 16))))","state invariant holds obligation:(forall rateplan1:map (Time) to (Time), sensed2:[ActivityData], interval3:Time, finished4:bool, LRL5:PPM, MSR6:PPM, threshold7:nat1, reactionT8:Time, recoveryT9:Time, responseF10:nat1 \u0026 (((threshold7 \u003c 8) and ((reactionT8 in set {10, ... ,50}) and ((recoveryT9 in set {2, ... ,16}) and (responseF10 \u003c\u003d 16)))) \u003d\u003e (forall rateplan11:map (Time) to (Time), sensed12:[ActivityData], interval13:Time, finished14:bool, LRL15:PPM, MSR16:PPM, threshold17:nat1, reactionT18:Time, recoveryT19:Time, responseF20:nat1 \u0026 (((threshold17 \u003c 8) and ((reactionT18 in set {10, ... ,50}) and ((recoveryT19 in set {2, ... ,16}) and (responseF20 \u003c\u003d 16)))) \u003d\u003e (((threshold17 \u003c 8) and ((reactionT18 in set {10, ... ,50}) and ((recoveryT19 in set {2, ... ,16}) and (responseF20 \u003c\u003d 16)))) \u003d\u003e ((threshold17 \u003c 8) and ((reactionT18 in set {10, ... ,50}) and ((recoveryT19 in set {2, ... ,16}) and (responseF20 \u003c\u003d 16)))))))))","state invariant holds obligation:(forall ad:ActivityData \u0026 (((threshold \u003c 8) and ((reactionT in set {10, ... ,50}) and ((recoveryT in set {2, ... ,16}) and (responseF \u003c\u003d 16)))) \u003d\u003e ((threshold \u003c 8) and ((reactionT in set {10, ... ,50}) and ((recoveryT in set {2, ... ,16}) and (responseF \u003c\u003d 16))))))","type compatibility obligation:(forall ad:ActivityData \u0026 is_(ad, [ActivityData]))","state invariant holds obligation:(((threshold \u003c 8) and ((reactionT in set {10, ... ,50}) and ((recoveryT in set {2, ... ,16}) and (responseF \u003c\u003d 16)))) \u003d\u003e ((threshold \u003c 8) and ((reactionT in set {10, ... ,50}) and ((recoveryT in set {2, ... ,16}) and (responseF \u003c\u003d 16)))))","non-zero obligation:(((MSR / 60) / 10000) \u003c\u003e 0)","type compatibility obligation:is_((1 / ((MSR / 60) / 10000)), nat)","state invariant holds obligation:(((threshold \u003c 8) and ((reactionT in set {10, ... ,50}) and ((recoveryT in set {2, ... ,16}) and (responseF \u003c\u003d 16)))) \u003d\u003e ((threshold \u003c 8) and ((reactionT in set {10, ... ,50}) and ((recoveryT in set {2, ... ,16}) and (responseF \u003c\u003d 16)))))","non-zero obligation:(((LRL / 60) / 10000) \u003c\u003e 0)","type compatibility obligation:is_((1 / ((LRL / 60) / 10000)), nat)","state invariant holds obligation:(((threshold \u003c 8) and ((reactionT in set {10, ... ,50}) and ((recoveryT in set {2, ... ,16}) and (responseF \u003c\u003d 16)))) \u003d\u003e ((threshold \u003c 8) and ((reactionT in set {10, ... ,50}) and ((recoveryT in set {2, ... ,16}) and (responseF \u003c\u003d 16)))))","type compatibility obligation:inv_ActivityData(4)","legal map application obligation:((\u003cATRIA\u003e in set (dom sensed)) \u003d\u003e (\u003cATRIA\u003e in set (dom sensed)))","type invariant satisfiable obligation:(exists inp:InputTP \u0026 (forall line in set (elems (inp.#2)) \u0026 ((inp.#1) \u003e\u003d (line.#4))))","legal function application obligation:(forall fname:seq1 of (char) \u0026 pre_(((io.freadval))[InputTP]fname))","while loop termination obligation:...","non-empty sequence obligation:(inplines \u003c\u003e [])","legal function application obligation:pre_(((io.writeval))[seq of (Outline)]convert(outlines))","legal sequence application obligation:(forall s:seq of (Outline) \u0026 (forall i in set (inds s) \u0026 (i in set (inds s))))","legal sequence application obligation:(forall s:seq of (Outline) \u0026 (forall i in set (inds s) \u0026 (i in set (inds s))))","legal sequence application obligation:(forall s:seq of (Outline) \u0026 (forall i in set (inds s) \u0026 (i in set (inds s))))","type compatibility obligation:(forall s:seq of (Outline) \u0026 is_([mk_((s(i).#1), (s(i).#2), (floor ((s(i).#3) / 10))) | i in set (inds s)], seq of (Outline)))","operation call obligation:(forall text:seq of (char) \u0026 ((\"\" \u003d \"\") \u003c\u003d\u003e (\"\" \u003d nil)))"] \ No newline at end of file diff --git a/core/pog/src/test/resources/examples/PacemakerSeqPP.result b/core/pog/src/test/resources/examples/PacemakerSeqPP.result index 1aaf1d02f4..37e53fe94c 100644 --- a/core/pog/src/test/resources/examples/PacemakerSeqPP.result +++ b/core/pog/src/test/resources/examples/PacemakerSeqPP.result @@ -1 +1 @@ -["type compatibility obligation:inv_PPM(60)","type compatibility obligation:inv_PPM(120)","non-zero obligation:(((60 / 60) / 1000) \u003c\u003e 0)","type compatibility obligation:is_((1 / ((LRL / 60) / 1000)), nat)","state invariant holds obligation:((MED \u003c 8) and ((10 in set {10, ... ,50}) and ((2 in set {2, ... ,16}) and (8 \u003c\u003d 16))))","state invariant holds obligation:(forall sensed1:[ActivityData], interval2:Time, finished3:bool, LRL4:PPM, MSR5:PPM, threshold6:nat1, reactionT7:Time, recoveryT8:Time, responseF9:nat1 \u0026 (((threshold6 \u003c 8) and ((reactionT7 in set {10, ... ,50}) and ((recoveryT8 in set {2, ... ,16}) and (responseF9 \u003c\u003d 16)))) \u003d\u003e (forall sensed10:[ActivityData], interval11:Time, finished12:bool, LRL13:PPM, MSR14:PPM, threshold15:nat1, reactionT16:Time, recoveryT17:Time, responseF18:nat1 \u0026 (((threshold15 \u003c 8) and ((reactionT16 in set {10, ... ,50}) and ((recoveryT17 in set {2, ... ,16}) and (responseF18 \u003c\u003d 16)))) \u003d\u003e (((threshold15 \u003c 8) and ((reactionT16 in set {10, ... ,50}) and ((recoveryT17 in set {2, ... ,16}) and (responseF18 \u003c\u003d 16)))) \u003d\u003e ((threshold15 \u003c 8) and ((reactionT16 in set {10, ... ,50}) and ((recoveryT17 in set {2, ... ,16}) and (responseF18 \u003c\u003d 16)))))))))","state invariant holds obligation:(forall ad:ActivityData \u0026 (((threshold \u003c 8) and ((reactionT in set {10, ... ,50}) and ((recoveryT in set {2, ... ,16}) and (responseF \u003c\u003d 16)))) \u003d\u003e ((threshold \u003c 8) and ((reactionT in set {10, ... ,50}) and ((recoveryT in set {2, ... ,16}) and (responseF \u003c\u003d 16))))))","type compatibility obligation:(forall ad:ActivityData \u0026 is_(ad, [ActivityData]))","state invariant holds obligation:(((threshold \u003c 8) and ((reactionT in set {10, ... ,50}) and ((recoveryT in set {2, ... ,16}) and (responseF \u003c\u003d 16)))) \u003d\u003e ((threshold \u003c 8) and ((reactionT in set {10, ... ,50}) and ((recoveryT in set {2, ... ,16}) and (responseF \u003c\u003d 16)))))","non-zero obligation:(((MSR / 60) / 1000) \u003c\u003e 0)","type compatibility obligation:is_((1 / ((MSR / 60) / 1000)), nat)","state invariant holds obligation:(((threshold \u003c 8) and ((reactionT in set {10, ... ,50}) and ((recoveryT in set {2, ... ,16}) and (responseF \u003c\u003d 16)))) \u003d\u003e ((threshold \u003c 8) and ((reactionT in set {10, ... ,50}) and ((recoveryT in set {2, ... ,16}) and (responseF \u003c\u003d 16)))))","non-zero obligation:(((LRL / 60) / 1000) \u003c\u003e 0)","type compatibility obligation:is_((1 / ((LRL / 60) / 1000)), nat)","type compatibility obligation:inv_ActivityData(1)","type compatibility obligation:inv_ActivityData(2)","type compatibility obligation:inv_ActivityData(3)","type compatibility obligation:inv_ActivityData(4)","type compatibility obligation:inv_ActivityData(5)","type compatibility obligation:inv_ActivityData(6)","type compatibility obligation:inv_ActivityData(7)","type invariant satisfiable obligation:(exists a:ActivityData \u0026 (a \u003c\u003d 7))","type invariant satisfiable obligation:(exists ppm:PPM \u0026 ((ppm \u003e\u003d 30) and (ppm \u003c\u003d 175)))","operation call obligation:(\u003cATRIA\u003e in set (dom leads))","operation call obligation:(forall leads1:map (Chamber) to (Lead), sensed2:map (Chamber) to (Sense), mode3:Mode, FixedAV4:Time, lastPulse5:Time, ARP6:Time, interval7:Time \u0026 (true \u003d\u003e (\u003cATRIA\u003e in set (dom leads1))))","operation call obligation:(forall leads1:map (Chamber) to (Lead), sensed2:map (Chamber) to (Sense), mode3:Mode, FixedAV4:Time, lastPulse5:Time, ARP6:Time, interval7:Time \u0026 (true \u003d\u003e (forall leads8:map (Chamber) to (Lead), sensed9:map (Chamber) to (Sense), mode10:Mode, FixedAV11:Time, lastPulse12:Time, ARP13:Time, interval14:Time \u0026 (true \u003d\u003e ({\u003cATRIA\u003e, \u003cVENTRICLE\u003e} subset (dom leads8))))))","legal map application obligation:((\u003cATRIA\u003e in set (dom leads)) \u003d\u003e ((\u003cATRIA\u003e in set (dom sensed)) \u003d\u003e (\u003cATRIA\u003e in set (dom sensed))))","legal map application obligation:(forall key in set (dom leads) \u0026 (key in set (dom leads)))","type invariant satisfiable obligation:(exists inp:InputTP \u0026 (forall line in set (elems (inp.#2)) \u0026 ((inp.#1) \u003e\u003d (line.#4))))","legal function application obligation:(forall fname:seq of (char) \u0026 pre_(((io.freadval))[InputTP]fname))","while loop termination obligation:NotYetImplemented","while loop termination obligation:NotYetImplemented","non-empty sequence obligation:(inplines \u003c\u003e [])","non-empty sequence obligation:(inplines \u003c\u003e [])","legal function application obligation:pre_(((io.writeval))[seq of (Outline)]outlines)","operation call obligation:(forall text:seq of (char) \u0026 ((\"\" \u003d \"\") \u003c\u003d\u003e (\"\" \u003d nil)))"] \ No newline at end of file +["type compatibility obligation:inv_PPM(60)","type compatibility obligation:inv_PPM(120)","non-zero obligation:(((60 / 60) / 1000) \u003c\u003e 0)","type compatibility obligation:is_((1 / ((LRL / 60) / 1000)), nat)","state invariant holds obligation:((MED \u003c 8) and ((10 in set {10, ... ,50}) and ((2 in set {2, ... ,16}) and (8 \u003c\u003d 16))))","state invariant holds obligation:(forall sensed1:[ActivityData], interval2:Time, finished3:bool, LRL4:PPM, MSR5:PPM, threshold6:nat1, reactionT7:Time, recoveryT8:Time, responseF9:nat1 \u0026 (((threshold6 \u003c 8) and ((reactionT7 in set {10, ... ,50}) and ((recoveryT8 in set {2, ... ,16}) and (responseF9 \u003c\u003d 16)))) \u003d\u003e (forall sensed10:[ActivityData], interval11:Time, finished12:bool, LRL13:PPM, MSR14:PPM, threshold15:nat1, reactionT16:Time, recoveryT17:Time, responseF18:nat1 \u0026 (((threshold15 \u003c 8) and ((reactionT16 in set {10, ... ,50}) and ((recoveryT17 in set {2, ... ,16}) and (responseF18 \u003c\u003d 16)))) \u003d\u003e (((threshold15 \u003c 8) and ((reactionT16 in set {10, ... ,50}) and ((recoveryT17 in set {2, ... ,16}) and (responseF18 \u003c\u003d 16)))) \u003d\u003e ((threshold15 \u003c 8) and ((reactionT16 in set {10, ... ,50}) and ((recoveryT17 in set {2, ... ,16}) and (responseF18 \u003c\u003d 16)))))))))","state invariant holds obligation:(forall ad:ActivityData \u0026 (((threshold \u003c 8) and ((reactionT in set {10, ... ,50}) and ((recoveryT in set {2, ... ,16}) and (responseF \u003c\u003d 16)))) \u003d\u003e ((threshold \u003c 8) and ((reactionT in set {10, ... ,50}) and ((recoveryT in set {2, ... ,16}) and (responseF \u003c\u003d 16))))))","type compatibility obligation:(forall ad:ActivityData \u0026 is_(ad, [ActivityData]))","state invariant holds obligation:(((threshold \u003c 8) and ((reactionT in set {10, ... ,50}) and ((recoveryT in set {2, ... ,16}) and (responseF \u003c\u003d 16)))) \u003d\u003e ((threshold \u003c 8) and ((reactionT in set {10, ... ,50}) and ((recoveryT in set {2, ... ,16}) and (responseF \u003c\u003d 16)))))","non-zero obligation:(((MSR / 60) / 1000) \u003c\u003e 0)","type compatibility obligation:is_((1 / ((MSR / 60) / 1000)), nat)","state invariant holds obligation:(((threshold \u003c 8) and ((reactionT in set {10, ... ,50}) and ((recoveryT in set {2, ... ,16}) and (responseF \u003c\u003d 16)))) \u003d\u003e ((threshold \u003c 8) and ((reactionT in set {10, ... ,50}) and ((recoveryT in set {2, ... ,16}) and (responseF \u003c\u003d 16)))))","non-zero obligation:(((LRL / 60) / 1000) \u003c\u003e 0)","type compatibility obligation:is_((1 / ((LRL / 60) / 1000)), nat)","type compatibility obligation:inv_ActivityData(1)","type compatibility obligation:inv_ActivityData(2)","type compatibility obligation:inv_ActivityData(3)","type compatibility obligation:inv_ActivityData(4)","type compatibility obligation:inv_ActivityData(5)","type compatibility obligation:inv_ActivityData(6)","type compatibility obligation:inv_ActivityData(7)","type invariant satisfiable obligation:(exists a:ActivityData \u0026 (a \u003c\u003d 7))","type invariant satisfiable obligation:(exists ppm:PPM \u0026 ((ppm \u003e\u003d 30) and (ppm \u003c\u003d 175)))","operation call obligation:(\u003cATRIA\u003e in set (dom leads))","operation call obligation:(forall leads1:map (Chamber) to (Lead), sensed2:map (Chamber) to (Sense), mode3:Mode, FixedAV4:Time, lastPulse5:Time, ARP6:Time, interval7:Time \u0026 (true \u003d\u003e (\u003cATRIA\u003e in set (dom leads1))))","operation call obligation:(forall leads1:map (Chamber) to (Lead), sensed2:map (Chamber) to (Sense), mode3:Mode, FixedAV4:Time, lastPulse5:Time, ARP6:Time, interval7:Time \u0026 (true \u003d\u003e (forall leads8:map (Chamber) to (Lead), sensed9:map (Chamber) to (Sense), mode10:Mode, FixedAV11:Time, lastPulse12:Time, ARP13:Time, interval14:Time \u0026 (true \u003d\u003e ({\u003cATRIA\u003e, \u003cVENTRICLE\u003e} subset (dom leads8))))))","legal map application obligation:((\u003cATRIA\u003e in set (dom leads)) \u003d\u003e ((\u003cATRIA\u003e in set (dom sensed)) \u003d\u003e (\u003cATRIA\u003e in set (dom sensed))))","legal map application obligation:(forall key in set (dom leads) \u0026 (key in set (dom leads)))","type invariant satisfiable obligation:(exists inp:InputTP \u0026 (forall line in set (elems (inp.#2)) \u0026 ((inp.#1) \u003e\u003d (line.#4))))","legal function application obligation:(forall fname:seq of (char) \u0026 pre_(((io.freadval))[InputTP]fname))","while loop termination obligation:...","while loop termination obligation:...","non-empty sequence obligation:(inplines \u003c\u003e [])","non-empty sequence obligation:(inplines \u003c\u003e [])","legal function application obligation:pre_(((io.writeval))[seq of (Outline)]outlines)","operation call obligation:(forall text:seq of (char) \u0026 ((\"\" \u003d \"\") \u003c\u003d\u003e (\"\" \u003d nil)))"] \ No newline at end of file diff --git a/core/pog/src/test/resources/examples/ProductLinePP.result b/core/pog/src/test/resources/examples/ProductLinePP.result index 7fbb2ccda5..1553553849 100644 --- a/core/pog/src/test/resources/examples/ProductLinePP.result +++ b/core/pog/src/test/resources/examples/ProductLinePP.result @@ -1 +1 @@ -["state invariant initialized obligation:(atm \u003c 1)","state invariant satisfiable obligation:(exists \u0026 (atm \u003c 1))","enumeration map injectivity obligation:(forall m1, m2 in set {{1.0 |-\u003e 100.0}, {0.53 |-\u003e 85.0}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","legal map application obligation:(forall atm:real \u0026 ((atm in set (dom boiling_point)) \u003d\u003e (atm in set (dom boiling_point))))","legal map application obligation:((((aap.GetAtm)() in set (dom boiling_point)) and (temperature \u003c\u003d boiling_point((aap.GetAtm)()))) \u003d\u003e (((aap.GetAtm)() in set (dom boiling_point)) \u003d\u003e ((aap.GetAtm)() in set (dom boiling_point))))","legal map application obligation:((((aap.GetAtm)() in set (dom boiling_point)) and (temperature \u003c\u003d boiling_point((aap.GetAtm)()))) \u003d\u003e ((aap.GetAtm)() in set (dom boiling_point)))","legal map application obligation:((((aap.GetAtm)() in set (dom boiling_point)) and (temperature \u003c\u003d boiling_point((aap.GetAtm)()))) \u003d\u003e ((aap.GetAtm)() in set (dom boiling_point)))","legal map application obligation:((((aap.GetAtm)() in set (dom boiling_point)) and (temperature \u003c\u003d boiling_point((aap.GetAtm)()))) \u003d\u003e ((aap.GetAtm)() in set (dom boiling_point)))","operation establishes postcondition obligation:((((aap.GetAtm)() in set (dom boiling_point)) and (temperature \u003c\u003d boiling_point((aap.GetAtm)()))) \u003d\u003e (boiling_point((aap.GetAtm)()) \u003c\u003d boiling_point((aap.GetAtm)())))","state invariant initialized obligation:(atm \u003d 1)","state invariant satisfiable obligation:(exists \u0026 (atm \u003d 1))","state invariant initialized obligation:(atm \u003e 1)","state invariant satisfiable obligation:(exists \u0026 (atm \u003e 1))","while loop termination obligation:NotYetImplemented","operation establishes postcondition obligation:((liquid_level_sensor.IsOn)() \u003d\u003e (liquid_level_sensor.IsOn)())"] \ No newline at end of file +["state invariant initialized obligation:(atm \u003c 1)","state invariant satisfiable obligation:(exists \u0026 (atm \u003c 1))","enumeration map injectivity obligation:(forall m1, m2 in set {{1.0 |-\u003e 100.0}, {0.53 |-\u003e 85.0}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","legal map application obligation:(forall atm:real \u0026 ((atm in set (dom boiling_point)) \u003d\u003e (atm in set (dom boiling_point))))","legal map application obligation:((((aap.GetAtm)() in set (dom boiling_point)) and (temperature \u003c\u003d boiling_point((aap.GetAtm)()))) \u003d\u003e (((aap.GetAtm)() in set (dom boiling_point)) \u003d\u003e ((aap.GetAtm)() in set (dom boiling_point))))","legal map application obligation:((((aap.GetAtm)() in set (dom boiling_point)) and (temperature \u003c\u003d boiling_point((aap.GetAtm)()))) \u003d\u003e ((aap.GetAtm)() in set (dom boiling_point)))","legal map application obligation:((((aap.GetAtm)() in set (dom boiling_point)) and (temperature \u003c\u003d boiling_point((aap.GetAtm)()))) \u003d\u003e ((aap.GetAtm)() in set (dom boiling_point)))","legal map application obligation:((((aap.GetAtm)() in set (dom boiling_point)) and (temperature \u003c\u003d boiling_point((aap.GetAtm)()))) \u003d\u003e ((aap.GetAtm)() in set (dom boiling_point)))","operation establishes postcondition obligation:((((aap.GetAtm)() in set (dom boiling_point)) and (temperature \u003c\u003d boiling_point((aap.GetAtm)()))) \u003d\u003e (boiling_point((aap.GetAtm)()) \u003c\u003d boiling_point((aap.GetAtm)())))","state invariant initialized obligation:(atm \u003d 1)","state invariant satisfiable obligation:(exists \u0026 (atm \u003d 1))","state invariant initialized obligation:(atm \u003e 1)","state invariant satisfiable obligation:(exists \u0026 (atm \u003e 1))","while loop termination obligation:...","operation establishes postcondition obligation:((liquid_level_sensor.IsOn)() \u003d\u003e (liquid_level_sensor.IsOn)())"] \ No newline at end of file diff --git a/core/pog/src/test/resources/examples/RobotRT.result b/core/pog/src/test/resources/examples/RobotRT.result index 336e4edcbd..128cab6752 100644 --- a/core/pog/src/test/resources/examples/RobotRT.result +++ b/core/pog/src/test/resources/examples/RobotRT.result @@ -1 +1 @@ -["while loop termination obligation:NotYetImplemented","legal function application obligation:(forall p1:Point, p2:Point \u0026 def a \u003d ((((p2.X) - (p1.X)) * ((p2.X) - (p1.X))) + (((p2.Y) - (p1.Y)) * ((p2.Y) - (p1.Y)))) in\n((0 \u003c\u003d a) \u003d\u003e pre_sqrt(a)))","type compatibility obligation:(forall p1:Point, p2:Point \u0026 (def a \u003d ((((p2.X) - (p1.X)) * ((p2.X) - (p1.X))) + (((p2.Y) - (p1.Y)) * ((p2.Y) - (p1.Y)))) in\n(if (0 \u003c\u003d a)\nthen (floor MATH`sqrt(a))\nelse 0) \u003e\u003d 0))","legal sequence application obligation:(((len routes) \u003e 0) \u003d\u003e ((len routes) in set (inds routes)))","legal sequence application obligation:((len routes) in set (inds routes))","legal sequence application obligation:((len r) in set (inds r))","operation establishes postcondition obligation:((RESULT \u003d let cPos:Point \u003d GetPos() in (({mk_Grid`Point((cPos.X), y) | y in set {((cPos.Y) + 1), ((cPos.Y) - 1)} \u0026 (y \u003e\u003d 0)} union {mk_Grid`Point(x, (cPos.Y)) | x in set {((cPos.X) + 1), ((cPos.X) - 1)} \u0026 (x \u003e\u003d 0)}) \\ {cPos})) and (forall p in set RESULT \u0026 (workingGrid.IsValidGridPoint)(p)))","legal sequence application obligation:((len routes) in set (inds routes))","legal sequence application obligation:(forall p:Point \u0026 (forall x in set (inds r) \u0026 ((r(x) \u003d p) \u003d\u003e (x in set (inds r)))))","legal sequence application obligation:(forall p:Point \u0026 (forall x in set (inds r) \u0026 (x in set (inds r))))","legal sequence application obligation:((len routes) in set (inds routes))","legal sequence application obligation:((len routes) in set (inds routes))","legal sequence application obligation:(forall p:Point \u0026 ((((GetBatUsage() * 2) \u003c\u003d batCap) and ((batCap \u003e 1) and let cp:Point \u003d routes((len routes))((len routes((len routes)))) in (((p.X) \u003c\u003e (cp.X)) or ((p.Y) \u003c\u003e (cp.Y))))) \u003d\u003e (((GetBatUsage() * 2) \u003c\u003d batCap) \u003d\u003e ((batCap \u003e 1) \u003d\u003e ((len routes((len routes))) in set (inds routes((len routes))))))))","legal sequence application obligation:(forall p:Point \u0026 ((((GetBatUsage() * 2) \u003c\u003d batCap) and ((batCap \u003e 1) and let cp:Point \u003d routes((len routes))((len routes((len routes)))) in (((p.X) \u003c\u003e (cp.X)) or ((p.Y) \u003c\u003e (cp.Y))))) \u003d\u003e (((GetBatUsage() * 2) \u003c\u003d batCap) \u003d\u003e ((batCap \u003e 1) \u003d\u003e ((len routes) in set (inds routes))))))","legal sequence application obligation:(forall p:Point \u0026 ((((GetBatUsage() * 2) \u003c\u003d batCap) and ((batCap \u003e 1) and let cp:Point \u003d routes((len routes))((len routes((len routes)))) in (((p.X) \u003c\u003e (cp.X)) or ((p.Y) \u003c\u003e (cp.Y))))) \u003d\u003e (((GetBatUsage() * 2) \u003c\u003d batCap) \u003d\u003e ((batCap \u003e 1) \u003d\u003e ((len routes) in set (inds routes))))))","legal sequence application obligation:(forall p:Point \u0026 ((((GetBatUsage() * 2) \u003c\u003d batCap) and ((batCap \u003e 1) and let cp:Point \u003d routes((len routes))((len routes((len routes)))) in (((p.X) \u003c\u003e (cp.X)) or ((p.Y) \u003c\u003e (cp.Y))))) \u003d\u003e ((len routes((len routes))) in set (inds routes((len routes))))))","legal sequence application obligation:(forall p:Point \u0026 ((((GetBatUsage() * 2) \u003c\u003d batCap) and ((batCap \u003e 1) and let cp:Point \u003d routes((len routes))((len routes((len routes)))) in (((p.X) \u003c\u003e (cp.X)) or ((p.Y) \u003c\u003e (cp.Y))))) \u003d\u003e ((len routes) in set (inds routes))))","legal sequence application obligation:(forall p:Point \u0026 ((((GetBatUsage() * 2) \u003c\u003d batCap) and ((batCap \u003e 1) and let cp:Point \u003d routes((len routes))((len routes((len routes)))) in (((p.X) \u003c\u003e (cp.X)) or ((p.Y) \u003c\u003e (cp.Y))))) \u003d\u003e ((len routes) in set (inds routes))))","operation establishes postcondition obligation:(forall p:Point \u0026 ((((GetBatUsage() * 2) \u003c\u003d batCap) and ((batCap \u003e 1) and let cp:Point \u003d routes((len routes))((len routes((len routes)))) in (((p.X) \u003c\u003e (cp.X)) or ((p.Y) \u003c\u003e (cp.Y))))) \u003d\u003e (p \u003d routes((len routes))((len routes((len routes)))))))","while loop termination obligation:NotYetImplemented","operation call obligation:(forall p in set neighbourPoints \u0026 (workingGrid.IsValidGridPoint)(p))","operation call obligation:(forall routes25:seq of (Route), obsSensors26:set of (ObstacleSensor), batCap27:int, dest28:Point, workingGrid29:Grid, busy30:bool \u0026 (true \u003d\u003e (((GetBatUsage() * 2) \u003c\u003d batCap27) and ((batCap27 \u003e 1) and let cp:Point \u003d routes((len routes))((len routes((len routes)))) in (((p.X) \u003c\u003e (cp.X)) or ((p.Y) \u003c\u003e (cp.Y)))))))","comprehension map injectivity obligation:(forall neighbourPoints:set of (Point) \u0026 ((forall p in set neighbourPoints \u0026 (workingGrid.IsValidGridPoint)(p)) \u003d\u003e (forall m1, m2 in set {{p |-\u003e (obs.GetPointAvalibility)(p)} | obs in set obsSensors, p in set unknownPoints \u0026 ((obs.GetDirection)() \u003d GetPointDirection(p))} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))))","legal function application obligation:(forall p:Point \u0026 pre_(((file.writeval))[(int * int)]mk_((p.X), (p.Y))))","legal function application obligation:(forall i:int \u0026 pre_(((file.writeval))[int]i))","state invariant holds obligation:(forall startPoint:Point, p:Point \u0026 ((IsValidGridPoint(startPoint) and IsValidGridPoint(p)) \u003d\u003e (forall p in set (dom points) \u0026 IsValidGridPoint(p))))","legal map application obligation:(forall x:int, y:int \u0026 (IsValidGridPoint(mk_Point(x, y)) \u003d\u003e (mk_Point(x, y) in set (dom points))))","state invariant holds obligation:(forall mapping:map (Point) to (PointAvalibility) \u0026 ((forall p in set (dom mapping) \u0026 IsValidGridPoint(p)) \u003d\u003e ((forall p in set (dom points) \u0026 IsValidGridPoint(p)) \u003d\u003e (forall p in set (dom points) \u0026 IsValidGridPoint(p)))))","state invariant holds obligation:((((inputFileName \u003c\u003e []) and (\"TestRun.txt\" \u003c\u003e [])) and (0 \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0))))","state invariant holds obligation:(forall newFileName:seq of (char) \u0026 ((newFileName \u003c\u003e []) \u003d\u003e (((((inputFileName \u003c\u003e []) and (outputFileName \u003c\u003e [])) and (battery \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e ((((newFileName \u003c\u003e []) and (outputFileName \u003c\u003e [])) and (battery \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))))))","state invariant holds obligation:(forall newFileName:seq of (char) \u0026 ((newFileName \u003c\u003e []) \u003d\u003e (((((newFileName \u003c\u003e []) and (outputFileName \u003c\u003e [])) and (battery \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e ((((newFileName \u003c\u003e []) and (outputFileName \u003c\u003e [])) and (battery \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))))))","legal function application obligation:(forall newFileName:seq of (char) \u0026 ((newFileName \u003c\u003e []) \u003d\u003e pre_(((file.freadval))[seq of (inDataType)]inputFileName)))","state invariant holds obligation:(forall newFileName:seq of (char) \u0026 ((newFileName \u003c\u003e []) \u003d\u003e (((((newFileName \u003c\u003e []) and (outputFileName \u003c\u003e [])) and (battery \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e ((((newFileName \u003c\u003e []) and (outputFileName \u003c\u003e [])) and (battery \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))))))","type compatibility obligation:(forall newFileName:seq of (char) \u0026 ((newFileName \u003c\u003e []) \u003d\u003e is_(input, seq of (inDataType))))","state invariant holds obligation:(forall data:seq of (inDataType) \u0026 (((startIndex in set (inds data)) and ((destIndex in set (inds data)) and (batCapIndex in set (inds data)))) \u003d\u003e (((((inputFileName \u003c\u003e []) and (outputFileName \u003c\u003e [])) and (battery \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e ((((inputFileName \u003c\u003e []) and (outputFileName \u003c\u003e [])) and (battery \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))))))","legal sequence application obligation:(forall data:seq of (inDataType) \u0026 (((startIndex in set (inds data)) and ((destIndex in set (inds data)) and (batCapIndex in set (inds data)))) \u003d\u003e (startIndex in set (inds data))))","legal sequence application obligation:(forall data:seq of (inDataType) \u0026 (((startIndex in set (inds data)) and ((destIndex in set (inds data)) and (batCapIndex in set (inds data)))) \u003d\u003e (startIndex in set (inds data))))","state invariant holds obligation:(forall data:seq of (inDataType) \u0026 (((startIndex in set (inds data)) and ((destIndex in set (inds data)) and (batCapIndex in set (inds data)))) \u003d\u003e (((((inputFileName \u003c\u003e []) and (outputFileName \u003c\u003e [])) and (battery \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e ((((inputFileName \u003c\u003e []) and (outputFileName \u003c\u003e [])) and (battery \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))))))","legal sequence application obligation:(forall data:seq of (inDataType) \u0026 (((startIndex in set (inds data)) and ((destIndex in set (inds data)) and (batCapIndex in set (inds data)))) \u003d\u003e (destIndex in set (inds data))))","legal sequence application obligation:(forall data:seq of (inDataType) \u0026 (((startIndex in set (inds data)) and ((destIndex in set (inds data)) and (batCapIndex in set (inds data)))) \u003d\u003e (destIndex in set (inds data))))","state invariant holds obligation:(forall data:seq of (inDataType) \u0026 (((startIndex in set (inds data)) and ((destIndex in set (inds data)) and (batCapIndex in set (inds data)))) \u003d\u003e (((((inputFileName \u003c\u003e []) and (outputFileName \u003c\u003e [])) and (battery \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e ((((inputFileName \u003c\u003e []) and (outputFileName \u003c\u003e [])) and ((inData(batCapIndex).#1) \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))))))","legal sequence application obligation:(forall data:seq of (inDataType) \u0026 (((startIndex in set (inds data)) and ((destIndex in set (inds data)) and (batCapIndex in set (inds data)))) \u003d\u003e (batCapIndex in set (inds inData))))","state invariant holds obligation:(forall data:seq of (inDataType) \u0026 (((startIndex in set (inds data)) and ((destIndex in set (inds data)) and (batCapIndex in set (inds data)))) \u003d\u003e (((((inputFileName \u003c\u003e []) and (outputFileName \u003c\u003e [])) and ((inData(batCapIndex).#1) \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e ((((inputFileName \u003c\u003e []) and (outputFileName \u003c\u003e [])) and ((inData(batCapIndex).#1) \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))))))","type compatibility obligation:(forall data:seq of (inDataType) \u0026 (((startIndex in set (inds data)) and ((destIndex in set (inds data)) and (batCapIndex in set (inds data)))) \u003d\u003e (((len data) - 2) \u003e\u003d 0)))","comprehension map injectivity obligation:(forall data:seq of (inDataType) \u0026 (((startIndex in set (inds data)) and ((destIndex in set (inds data)) and (batCapIndex in set (inds data)))) \u003d\u003e (forall m1, m2 in set {{mk_Grid`Point((data(i).#1), (inData(i).#2)) |-\u003e \u003cOccupied\u003e} | i in set {4, ... ,(len data)}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))))","legal sequence application obligation:(forall data:seq of (inDataType) \u0026 (((startIndex in set (inds data)) and ((destIndex in set (inds data)) and (batCapIndex in set (inds data)))) \u003d\u003e (forall i in set {4, ... ,(len data)} \u0026 (i in set (inds data)))))","legal sequence application obligation:(forall data:seq of (inDataType) \u0026 (((startIndex in set (inds data)) and ((destIndex in set (inds data)) and (batCapIndex in set (inds data)))) \u003d\u003e (forall i in set {4, ... ,(len data)} \u0026 (i in set (inds inData)))))","legal function application obligation:(forall g:Grid, routes:seq of (Route), dest:Point, b:bool \u0026 (forall file1:IO, inputFileName2:seq of (char), outputFileName3:seq of (char), inData4:seq of (inDataType), dest5:Point, startingPoint6:Point, battery7:nat, counter8:nat, fields9:nat \u0026 (((((inputFileName2 \u003c\u003e []) and (outputFileName3 \u003c\u003e [])) and (battery7 \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e (forall file10:IO, inputFileName11:seq of (char), outputFileName12:seq of (char), inData13:seq of (inDataType), dest14:Point, startingPoint15:Point, battery16:nat, counter17:nat, fields18:nat \u0026 (((((inputFileName11 \u003c\u003e []) and (outputFileName12 \u003c\u003e [])) and (battery16 \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e pre_(((file.fwriteval))[(bool * Point)]outputFileName, mk_(b, dest), \u003cappend\u003e))))))","legal map application obligation:(forall g:Grid, routes:seq of (Route), dest:Point, b:bool \u0026 (forall file1:IO, inputFileName2:seq of (char), outputFileName3:seq of (char), inData4:seq of (inDataType), dest5:Point, startingPoint6:Point, battery7:nat, counter8:nat, fields9:nat \u0026 (((((inputFileName2 \u003c\u003e []) and (outputFileName3 \u003c\u003e [])) and (battery7 \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e (forall file10:IO, inputFileName11:seq of (char), outputFileName12:seq of (char), inData13:seq of (inDataType), dest14:Point, startingPoint15:Point, battery16:nat, counter17:nat, fields18:nat \u0026 (((((inputFileName11 \u003c\u003e []) and (outputFileName12 \u003c\u003e [])) and (battery16 \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e (forall file19:IO, inputFileName20:seq of (char), outputFileName21:seq of (char), inData22:seq of (inDataType), dest23:Point, startingPoint24:Point, battery25:nat, counter26:nat, fields27:nat \u0026 (((((inputFileName20 \u003c\u003e []) and (outputFileName21 \u003c\u003e [])) and (battery25 \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e (forall file28:IO, inputFileName29:seq of (char), outputFileName30:seq of (char), inData31:seq of (inDataType), dest32:Point, startingPoint33:Point, battery34:nat, counter35:nat, fields36:nat \u0026 (((((inputFileName29 \u003c\u003e []) and (outputFileName30 \u003c\u003e [])) and (battery34 \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e (x in set (dom (g.points))))))))))))","legal sequence application obligation:(forall g:Grid, routes:seq of (Route), dest:Point, b:bool \u0026 (forall file1:IO, inputFileName2:seq of (char), outputFileName3:seq of (char), inData4:seq of (inDataType), dest5:Point, startingPoint6:Point, battery7:nat, counter8:nat, fields9:nat \u0026 (((((inputFileName2 \u003c\u003e []) and (outputFileName3 \u003c\u003e [])) and (battery7 \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e (forall file10:IO, inputFileName11:seq of (char), outputFileName12:seq of (char), inData13:seq of (inDataType), dest14:Point, startingPoint15:Point, battery16:nat, counter17:nat, fields18:nat \u0026 (((((inputFileName11 \u003c\u003e []) and (outputFileName12 \u003c\u003e [])) and (battery16 \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e (forall file19:IO, inputFileName20:seq of (char), outputFileName21:seq of (char), inData22:seq of (inDataType), dest23:Point, startingPoint24:Point, battery25:nat, counter26:nat, fields27:nat \u0026 (((((inputFileName20 \u003c\u003e []) and (outputFileName21 \u003c\u003e [])) and (battery25 \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e (forall file28:IO, inputFileName29:seq of (char), outputFileName30:seq of (char), inData31:seq of (inDataType), dest32:Point, startingPoint33:Point, battery34:nat, counter35:nat, fields36:nat \u0026 (((((inputFileName29 \u003c\u003e []) and (outputFileName30 \u003c\u003e [])) and (battery34 \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e (forall file37:IO, inputFileName38:seq of (char), outputFileName39:seq of (char), inData40:seq of (inDataType), dest41:Point, startingPoint42:Point, battery43:nat, counter44:nat, fields45:nat \u0026 (((((inputFileName38 \u003c\u003e []) and (outputFileName39 \u003c\u003e [])) and (battery43 \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e (forall file46:IO, inputFileName47:seq of (char), outputFileName48:seq of (char), inData49:seq of (inDataType), dest50:Point, startingPoint51:Point, battery52:nat, counter53:nat, fields54:nat \u0026 (((((inputFileName47 \u003c\u003e []) and (outputFileName48 \u003c\u003e [])) and (battery52 \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e (forall file55:IO, inputFileName56:seq of (char), outputFileName57:seq of (char), inData58:seq of (inDataType), dest59:Point, startingPoint60:Point, battery61:nat, counter62:nat, fields63:nat \u0026 (((((inputFileName56 \u003c\u003e []) and (outputFileName57 \u003c\u003e [])) and (battery61 \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e (forall file64:IO, inputFileName65:seq of (char), outputFileName66:seq of (char), inData67:seq of (inDataType), dest68:Point, startingPoint69:Point, battery70:nat, counter71:nat, fields72:nat \u0026 (((((inputFileName65 \u003c\u003e []) and (outputFileName66 \u003c\u003e [])) and (battery70 \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e (x in set (inds routes)))))))))))))))))))","state invariant holds obligation:(forall g:Point, p:PointAvalibility \u0026 (((((inputFileName \u003c\u003e []) and (outputFileName \u003c\u003e [])) and (battery \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e ((((inputFileName \u003c\u003e []) and (outputFileName \u003c\u003e [])) and (battery \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0))))))","legal function application obligation:(forall g:Point, p:PointAvalibility \u0026 pre_(((file.fwriteval))[(Point * PointAvalibility)]outputFileName, mk_(g, p), \u003cappend\u003e))","state invariant holds obligation:(forall r:Route \u0026 (((((inputFileName \u003c\u003e []) and (outputFileName \u003c\u003e [])) and (battery \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e ((((inputFileName \u003c\u003e []) and (outputFileName \u003c\u003e [])) and (battery \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0))))))","legal function application obligation:(forall r:Route \u0026 pre_(((file.fwriteval))[Point]outputFileName, r(x), \u003cappend\u003e))","legal sequence application obligation:(forall r:Route \u0026 (x in set (inds r)))","state invariant holds obligation:(forall i:nat \u0026 (((((inputFileName \u003c\u003e []) and (outputFileName \u003c\u003e [])) and (battery \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e ((((inputFileName \u003c\u003e []) and (outputFileName \u003c\u003e [])) and (battery \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0))))))","legal function application obligation:(forall i:nat \u0026 pre_(((file.fwriteval))[nat]outputFileName, i, \u003cappend\u003e))","state invariant holds obligation:(forall line:seq of (char) \u0026 (((((inputFileName \u003c\u003e []) and (outputFileName \u003c\u003e [])) and (battery \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e ((((inputFileName \u003c\u003e []) and (outputFileName \u003c\u003e [])) and (battery \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0))))))","legal function application obligation:(forall line:seq of (char) \u0026 pre_(((file.fwriteval))[seq of (char)]outputFileName, line, \u003cappend\u003e))","operation call obligation:(forall text:seq of (char) \u0026 ((\"\" \u003d \"\") \u003c\u003d\u003e (\"\" \u003d nil)))","non-zero obligation:(forall a:real \u0026 ((a \u003c\u003e 0) \u003d\u003e (a \u003c\u003e 0)))"] \ No newline at end of file +["while loop termination obligation:...","legal function application obligation:(forall p1:Point, p2:Point \u0026 def a \u003d ((((p2.X) - (p1.X)) * ((p2.X) - (p1.X))) + (((p2.Y) - (p1.Y)) * ((p2.Y) - (p1.Y)))) in\n((0 \u003c\u003d a) \u003d\u003e pre_sqrt(a)))","type compatibility obligation:(forall p1:Point, p2:Point \u0026 (def a \u003d ((((p2.X) - (p1.X)) * ((p2.X) - (p1.X))) + (((p2.Y) - (p1.Y)) * ((p2.Y) - (p1.Y)))) in\n(if (0 \u003c\u003d a)\nthen (floor MATH`sqrt(a))\nelse 0) \u003e\u003d 0))","legal sequence application obligation:(((len routes) \u003e 0) \u003d\u003e ((len routes) in set (inds routes)))","legal sequence application obligation:((len routes) in set (inds routes))","legal sequence application obligation:((len r) in set (inds r))","operation establishes postcondition obligation:((RESULT \u003d let cPos:Point \u003d GetPos() in (({mk_Grid`Point((cPos.X), y) | y in set {((cPos.Y) + 1), ((cPos.Y) - 1)} \u0026 (y \u003e\u003d 0)} union {mk_Grid`Point(x, (cPos.Y)) | x in set {((cPos.X) + 1), ((cPos.X) - 1)} \u0026 (x \u003e\u003d 0)}) \\ {cPos})) and (forall p in set RESULT \u0026 (workingGrid.IsValidGridPoint)(p)))","legal sequence application obligation:((len routes) in set (inds routes))","legal sequence application obligation:(forall p:Point \u0026 (forall x in set (inds r) \u0026 ((r(x) \u003d p) \u003d\u003e (x in set (inds r)))))","legal sequence application obligation:(forall p:Point \u0026 (forall x in set (inds r) \u0026 (x in set (inds r))))","legal sequence application obligation:((len routes) in set (inds routes))","legal sequence application obligation:((len routes) in set (inds routes))","legal sequence application obligation:(forall p:Point \u0026 ((((GetBatUsage() * 2) \u003c\u003d batCap) and ((batCap \u003e 1) and let cp:Point \u003d routes((len routes))((len routes((len routes)))) in (((p.X) \u003c\u003e (cp.X)) or ((p.Y) \u003c\u003e (cp.Y))))) \u003d\u003e (((GetBatUsage() * 2) \u003c\u003d batCap) \u003d\u003e ((batCap \u003e 1) \u003d\u003e ((len routes((len routes))) in set (inds routes((len routes))))))))","legal sequence application obligation:(forall p:Point \u0026 ((((GetBatUsage() * 2) \u003c\u003d batCap) and ((batCap \u003e 1) and let cp:Point \u003d routes((len routes))((len routes((len routes)))) in (((p.X) \u003c\u003e (cp.X)) or ((p.Y) \u003c\u003e (cp.Y))))) \u003d\u003e (((GetBatUsage() * 2) \u003c\u003d batCap) \u003d\u003e ((batCap \u003e 1) \u003d\u003e ((len routes) in set (inds routes))))))","legal sequence application obligation:(forall p:Point \u0026 ((((GetBatUsage() * 2) \u003c\u003d batCap) and ((batCap \u003e 1) and let cp:Point \u003d routes((len routes))((len routes((len routes)))) in (((p.X) \u003c\u003e (cp.X)) or ((p.Y) \u003c\u003e (cp.Y))))) \u003d\u003e (((GetBatUsage() * 2) \u003c\u003d batCap) \u003d\u003e ((batCap \u003e 1) \u003d\u003e ((len routes) in set (inds routes))))))","legal sequence application obligation:(forall p:Point \u0026 ((((GetBatUsage() * 2) \u003c\u003d batCap) and ((batCap \u003e 1) and let cp:Point \u003d routes((len routes))((len routes((len routes)))) in (((p.X) \u003c\u003e (cp.X)) or ((p.Y) \u003c\u003e (cp.Y))))) \u003d\u003e ((len routes((len routes))) in set (inds routes((len routes))))))","legal sequence application obligation:(forall p:Point \u0026 ((((GetBatUsage() * 2) \u003c\u003d batCap) and ((batCap \u003e 1) and let cp:Point \u003d routes((len routes))((len routes((len routes)))) in (((p.X) \u003c\u003e (cp.X)) or ((p.Y) \u003c\u003e (cp.Y))))) \u003d\u003e ((len routes) in set (inds routes))))","legal sequence application obligation:(forall p:Point \u0026 ((((GetBatUsage() * 2) \u003c\u003d batCap) and ((batCap \u003e 1) and let cp:Point \u003d routes((len routes))((len routes((len routes)))) in (((p.X) \u003c\u003e (cp.X)) or ((p.Y) \u003c\u003e (cp.Y))))) \u003d\u003e ((len routes) in set (inds routes))))","operation establishes postcondition obligation:(forall p:Point \u0026 ((((GetBatUsage() * 2) \u003c\u003d batCap) and ((batCap \u003e 1) and let cp:Point \u003d routes((len routes))((len routes((len routes)))) in (((p.X) \u003c\u003e (cp.X)) or ((p.Y) \u003c\u003e (cp.Y))))) \u003d\u003e (p \u003d routes((len routes))((len routes((len routes)))))))","while loop termination obligation:...","operation call obligation:(forall p in set neighbourPoints \u0026 (workingGrid.IsValidGridPoint)(p))","operation call obligation:(forall routes25:seq of (Route), obsSensors26:set of (ObstacleSensor), batCap27:int, dest28:Point, workingGrid29:Grid, busy30:bool \u0026 (true \u003d\u003e (((GetBatUsage() * 2) \u003c\u003d batCap27) and ((batCap27 \u003e 1) and let cp:Point \u003d routes((len routes))((len routes((len routes)))) in (((p.X) \u003c\u003e (cp.X)) or ((p.Y) \u003c\u003e (cp.Y)))))))","comprehension map injectivity obligation:(forall neighbourPoints:set of (Point) \u0026 ((forall p in set neighbourPoints \u0026 (workingGrid.IsValidGridPoint)(p)) \u003d\u003e (forall m1, m2 in set {{p |-\u003e (obs.GetPointAvalibility)(p)} | obs in set obsSensors, p in set unknownPoints \u0026 ((obs.GetDirection)() \u003d GetPointDirection(p))} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))))","legal function application obligation:(forall p:Point \u0026 pre_(((file.writeval))[(int * int)]mk_((p.X), (p.Y))))","legal function application obligation:(forall i:int \u0026 pre_(((file.writeval))[int]i))","state invariant holds obligation:(forall startPoint:Point, p:Point \u0026 ((IsValidGridPoint(startPoint) and IsValidGridPoint(p)) \u003d\u003e (forall p in set (dom points) \u0026 IsValidGridPoint(p))))","legal map application obligation:(forall x:int, y:int \u0026 (IsValidGridPoint(mk_Point(x, y)) \u003d\u003e (mk_Point(x, y) in set (dom points))))","state invariant holds obligation:(forall mapping:map (Point) to (PointAvalibility) \u0026 ((forall p in set (dom mapping) \u0026 IsValidGridPoint(p)) \u003d\u003e ((forall p in set (dom points) \u0026 IsValidGridPoint(p)) \u003d\u003e (forall p in set (dom points) \u0026 IsValidGridPoint(p)))))","state invariant holds obligation:((((inputFileName \u003c\u003e []) and (\"TestRun.txt\" \u003c\u003e [])) and (0 \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0))))","state invariant holds obligation:(forall newFileName:seq of (char) \u0026 ((newFileName \u003c\u003e []) \u003d\u003e (((((inputFileName \u003c\u003e []) and (outputFileName \u003c\u003e [])) and (battery \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e ((((newFileName \u003c\u003e []) and (outputFileName \u003c\u003e [])) and (battery \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))))))","state invariant holds obligation:(forall newFileName:seq of (char) \u0026 ((newFileName \u003c\u003e []) \u003d\u003e (((((newFileName \u003c\u003e []) and (outputFileName \u003c\u003e [])) and (battery \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e ((((newFileName \u003c\u003e []) and (outputFileName \u003c\u003e [])) and (battery \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))))))","legal function application obligation:(forall newFileName:seq of (char) \u0026 ((newFileName \u003c\u003e []) \u003d\u003e pre_(((file.freadval))[seq of (inDataType)]inputFileName)))","state invariant holds obligation:(forall newFileName:seq of (char) \u0026 ((newFileName \u003c\u003e []) \u003d\u003e (((((newFileName \u003c\u003e []) and (outputFileName \u003c\u003e [])) and (battery \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e ((((newFileName \u003c\u003e []) and (outputFileName \u003c\u003e [])) and (battery \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))))))","type compatibility obligation:(forall newFileName:seq of (char) \u0026 ((newFileName \u003c\u003e []) \u003d\u003e is_(input, seq of (inDataType))))","state invariant holds obligation:(forall data:seq of (inDataType) \u0026 (((startIndex in set (inds data)) and ((destIndex in set (inds data)) and (batCapIndex in set (inds data)))) \u003d\u003e (((((inputFileName \u003c\u003e []) and (outputFileName \u003c\u003e [])) and (battery \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e ((((inputFileName \u003c\u003e []) and (outputFileName \u003c\u003e [])) and (battery \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))))))","legal sequence application obligation:(forall data:seq of (inDataType) \u0026 (((startIndex in set (inds data)) and ((destIndex in set (inds data)) and (batCapIndex in set (inds data)))) \u003d\u003e (startIndex in set (inds data))))","legal sequence application obligation:(forall data:seq of (inDataType) \u0026 (((startIndex in set (inds data)) and ((destIndex in set (inds data)) and (batCapIndex in set (inds data)))) \u003d\u003e (startIndex in set (inds data))))","state invariant holds obligation:(forall data:seq of (inDataType) \u0026 (((startIndex in set (inds data)) and ((destIndex in set (inds data)) and (batCapIndex in set (inds data)))) \u003d\u003e (((((inputFileName \u003c\u003e []) and (outputFileName \u003c\u003e [])) and (battery \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e ((((inputFileName \u003c\u003e []) and (outputFileName \u003c\u003e [])) and (battery \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))))))","legal sequence application obligation:(forall data:seq of (inDataType) \u0026 (((startIndex in set (inds data)) and ((destIndex in set (inds data)) and (batCapIndex in set (inds data)))) \u003d\u003e (destIndex in set (inds data))))","legal sequence application obligation:(forall data:seq of (inDataType) \u0026 (((startIndex in set (inds data)) and ((destIndex in set (inds data)) and (batCapIndex in set (inds data)))) \u003d\u003e (destIndex in set (inds data))))","state invariant holds obligation:(forall data:seq of (inDataType) \u0026 (((startIndex in set (inds data)) and ((destIndex in set (inds data)) and (batCapIndex in set (inds data)))) \u003d\u003e (((((inputFileName \u003c\u003e []) and (outputFileName \u003c\u003e [])) and (battery \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e ((((inputFileName \u003c\u003e []) and (outputFileName \u003c\u003e [])) and ((inData(batCapIndex).#1) \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))))))","legal sequence application obligation:(forall data:seq of (inDataType) \u0026 (((startIndex in set (inds data)) and ((destIndex in set (inds data)) and (batCapIndex in set (inds data)))) \u003d\u003e (batCapIndex in set (inds inData))))","state invariant holds obligation:(forall data:seq of (inDataType) \u0026 (((startIndex in set (inds data)) and ((destIndex in set (inds data)) and (batCapIndex in set (inds data)))) \u003d\u003e (((((inputFileName \u003c\u003e []) and (outputFileName \u003c\u003e [])) and ((inData(batCapIndex).#1) \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e ((((inputFileName \u003c\u003e []) and (outputFileName \u003c\u003e [])) and ((inData(batCapIndex).#1) \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))))))","type compatibility obligation:(forall data:seq of (inDataType) \u0026 (((startIndex in set (inds data)) and ((destIndex in set (inds data)) and (batCapIndex in set (inds data)))) \u003d\u003e (((len data) - 2) \u003e\u003d 0)))","comprehension map injectivity obligation:(forall data:seq of (inDataType) \u0026 (((startIndex in set (inds data)) and ((destIndex in set (inds data)) and (batCapIndex in set (inds data)))) \u003d\u003e (forall m1, m2 in set {{mk_Grid`Point((data(i).#1), (inData(i).#2)) |-\u003e \u003cOccupied\u003e} | i in set {4, ... ,(len data)}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))))","legal sequence application obligation:(forall data:seq of (inDataType) \u0026 (((startIndex in set (inds data)) and ((destIndex in set (inds data)) and (batCapIndex in set (inds data)))) \u003d\u003e (forall i in set {4, ... ,(len data)} \u0026 (i in set (inds data)))))","legal sequence application obligation:(forall data:seq of (inDataType) \u0026 (((startIndex in set (inds data)) and ((destIndex in set (inds data)) and (batCapIndex in set (inds data)))) \u003d\u003e (forall i in set {4, ... ,(len data)} \u0026 (i in set (inds inData)))))","legal function application obligation:(forall g:Grid, routes:seq of (Route), dest:Point, b:bool \u0026 (forall file1:IO, inputFileName2:seq of (char), outputFileName3:seq of (char), inData4:seq of (inDataType), dest5:Point, startingPoint6:Point, battery7:nat, counter8:nat, fields9:nat \u0026 (((((inputFileName2 \u003c\u003e []) and (outputFileName3 \u003c\u003e [])) and (battery7 \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e (forall file10:IO, inputFileName11:seq of (char), outputFileName12:seq of (char), inData13:seq of (inDataType), dest14:Point, startingPoint15:Point, battery16:nat, counter17:nat, fields18:nat \u0026 (((((inputFileName11 \u003c\u003e []) and (outputFileName12 \u003c\u003e [])) and (battery16 \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e pre_(((file.fwriteval))[(bool * Point)]outputFileName, mk_(b, dest), \u003cappend\u003e))))))","legal map application obligation:(forall g:Grid, routes:seq of (Route), dest:Point, b:bool \u0026 (forall file1:IO, inputFileName2:seq of (char), outputFileName3:seq of (char), inData4:seq of (inDataType), dest5:Point, startingPoint6:Point, battery7:nat, counter8:nat, fields9:nat \u0026 (((((inputFileName2 \u003c\u003e []) and (outputFileName3 \u003c\u003e [])) and (battery7 \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e (forall file10:IO, inputFileName11:seq of (char), outputFileName12:seq of (char), inData13:seq of (inDataType), dest14:Point, startingPoint15:Point, battery16:nat, counter17:nat, fields18:nat \u0026 (((((inputFileName11 \u003c\u003e []) and (outputFileName12 \u003c\u003e [])) and (battery16 \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e (forall file19:IO, inputFileName20:seq of (char), outputFileName21:seq of (char), inData22:seq of (inDataType), dest23:Point, startingPoint24:Point, battery25:nat, counter26:nat, fields27:nat \u0026 (((((inputFileName20 \u003c\u003e []) and (outputFileName21 \u003c\u003e [])) and (battery25 \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e (forall file28:IO, inputFileName29:seq of (char), outputFileName30:seq of (char), inData31:seq of (inDataType), dest32:Point, startingPoint33:Point, battery34:nat, counter35:nat, fields36:nat \u0026 (((((inputFileName29 \u003c\u003e []) and (outputFileName30 \u003c\u003e [])) and (battery34 \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e (x in set (dom (g.points))))))))))))","legal sequence application obligation:(forall g:Grid, routes:seq of (Route), dest:Point, b:bool \u0026 (forall file1:IO, inputFileName2:seq of (char), outputFileName3:seq of (char), inData4:seq of (inDataType), dest5:Point, startingPoint6:Point, battery7:nat, counter8:nat, fields9:nat \u0026 (((((inputFileName2 \u003c\u003e []) and (outputFileName3 \u003c\u003e [])) and (battery7 \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e (forall file10:IO, inputFileName11:seq of (char), outputFileName12:seq of (char), inData13:seq of (inDataType), dest14:Point, startingPoint15:Point, battery16:nat, counter17:nat, fields18:nat \u0026 (((((inputFileName11 \u003c\u003e []) and (outputFileName12 \u003c\u003e [])) and (battery16 \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e (forall file19:IO, inputFileName20:seq of (char), outputFileName21:seq of (char), inData22:seq of (inDataType), dest23:Point, startingPoint24:Point, battery25:nat, counter26:nat, fields27:nat \u0026 (((((inputFileName20 \u003c\u003e []) and (outputFileName21 \u003c\u003e [])) and (battery25 \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e (forall file28:IO, inputFileName29:seq of (char), outputFileName30:seq of (char), inData31:seq of (inDataType), dest32:Point, startingPoint33:Point, battery34:nat, counter35:nat, fields36:nat \u0026 (((((inputFileName29 \u003c\u003e []) and (outputFileName30 \u003c\u003e [])) and (battery34 \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e (forall file37:IO, inputFileName38:seq of (char), outputFileName39:seq of (char), inData40:seq of (inDataType), dest41:Point, startingPoint42:Point, battery43:nat, counter44:nat, fields45:nat \u0026 (((((inputFileName38 \u003c\u003e []) and (outputFileName39 \u003c\u003e [])) and (battery43 \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e (forall file46:IO, inputFileName47:seq of (char), outputFileName48:seq of (char), inData49:seq of (inDataType), dest50:Point, startingPoint51:Point, battery52:nat, counter53:nat, fields54:nat \u0026 (((((inputFileName47 \u003c\u003e []) and (outputFileName48 \u003c\u003e [])) and (battery52 \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e (forall file55:IO, inputFileName56:seq of (char), outputFileName57:seq of (char), inData58:seq of (inDataType), dest59:Point, startingPoint60:Point, battery61:nat, counter62:nat, fields63:nat \u0026 (((((inputFileName56 \u003c\u003e []) and (outputFileName57 \u003c\u003e [])) and (battery61 \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e (forall file64:IO, inputFileName65:seq of (char), outputFileName66:seq of (char), inData67:seq of (inDataType), dest68:Point, startingPoint69:Point, battery70:nat, counter71:nat, fields72:nat \u0026 (((((inputFileName65 \u003c\u003e []) and (outputFileName66 \u003c\u003e [])) and (battery70 \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e (x in set (inds routes)))))))))))))))))))","state invariant holds obligation:(forall g:Point, p:PointAvalibility \u0026 (((((inputFileName \u003c\u003e []) and (outputFileName \u003c\u003e [])) and (battery \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e ((((inputFileName \u003c\u003e []) and (outputFileName \u003c\u003e [])) and (battery \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0))))))","legal function application obligation:(forall g:Point, p:PointAvalibility \u0026 pre_(((file.fwriteval))[(Point * PointAvalibility)]outputFileName, mk_(g, p), \u003cappend\u003e))","state invariant holds obligation:(forall r:Route \u0026 (((((inputFileName \u003c\u003e []) and (outputFileName \u003c\u003e [])) and (battery \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e ((((inputFileName \u003c\u003e []) and (outputFileName \u003c\u003e [])) and (battery \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0))))))","legal function application obligation:(forall r:Route \u0026 pre_(((file.fwriteval))[Point]outputFileName, r(x), \u003cappend\u003e))","legal sequence application obligation:(forall r:Route \u0026 (x in set (inds r)))","state invariant holds obligation:(forall i:nat \u0026 (((((inputFileName \u003c\u003e []) and (outputFileName \u003c\u003e [])) and (battery \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e ((((inputFileName \u003c\u003e []) and (outputFileName \u003c\u003e [])) and (battery \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0))))))","legal function application obligation:(forall i:nat \u0026 pre_(((file.fwriteval))[nat]outputFileName, i, \u003cappend\u003e))","state invariant holds obligation:(forall line:seq of (char) \u0026 (((((inputFileName \u003c\u003e []) and (outputFileName \u003c\u003e [])) and (battery \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0)))) \u003d\u003e ((((inputFileName \u003c\u003e []) and (outputFileName \u003c\u003e [])) and (battery \u003e\u003d 0)) and ((startIndex \u003e 0) and ((destIndex \u003e 0) and (batCapIndex \u003e 0))))))","legal function application obligation:(forall line:seq of (char) \u0026 pre_(((file.fwriteval))[seq of (char)]outputFileName, line, \u003cappend\u003e))","operation call obligation:(forall text:seq of (char) \u0026 ((\"\" \u003d \"\") \u003c\u003d\u003e (\"\" \u003d nil)))","non-zero obligation:(forall a:real \u0026 ((a \u003c\u003e 0) \u003d\u003e (a \u003c\u003e 0)))"] \ No newline at end of file diff --git a/core/pog/src/test/resources/examples/SAFERSL.result b/core/pog/src/test/resources/examples/SAFERSL.result index 6163dc3d6b..f78c8a026d 100644 --- a/core/pog/src/test/resources/examples/SAFERSL.result +++ b/core/pog/src/test/resources/examples/SAFERSL.result @@ -1 +1 @@ -["operation establishes postcondition obligation:(forall mk_SwitchPositions(mode, aah):SwitchPositions, raw_grip:HandGripPosition, aah_cmd:RotCommand, oldstate:SAFER \u0026 (true \u003d\u003e (((card RESULT) \u003c\u003d 4) and ThrusterConsistency(RESULT))))","comprehension map injectivity obligation:(forall m1, m2 in set {{a |-\u003e \u003cZero\u003e} | a in set tran_axis_set} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","type compatibility obligation:inv_TranCommand({a |-\u003e \u003cZero\u003e | a in set tran_axis_set})","comprehension map injectivity obligation:(forall m1, m2 in set {{a |-\u003e \u003cZero\u003e} | a in set rot_axis_set} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","type compatibility obligation:inv_RotCommand({a |-\u003e \u003cZero\u003e | a in set rot_axis_set})","type invariant satisfiable obligation:(exists cmd:TranCommand \u0026 ((dom cmd) \u003d tran_axis_set))","type invariant satisfiable obligation:(exists cmd:RotCommand \u0026 ((dom cmd) \u003d rot_axis_set))","type invariant satisfiable obligation:(exists inp:Input \u0026 ((len inp) \u003d 9))","legal sequence application obligation:(forall tm:seq of (seq of (bool)) \u0026 (((len tm) \u003d 4) \u003d\u003e (forall i in set (inds tm) \u0026 (i in set (inds tm)))))","type invariant satisfiable obligation:(exists tm:ThrusterMatrix \u0026 (((len tm) \u003d 4) and (forall i in set (inds tm) \u0026 ((len tm(i)) \u003d 6))))","enumeration map injectivity obligation:(forall input:Input \u0026 let [mode, aah, horiz, trans, vert, twist, roll, pitch, yaw]:Input \u003d input in (forall m1, m2 in set {{\u003cRoll\u003e |-\u003e ConvertAxisCmd(roll)}, {\u003cPitch\u003e |-\u003e ConvertAxisCmd(pitch)}, {\u003cYaw\u003e |-\u003e ConvertAxisCmd(yaw)}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4))))))","type compatibility obligation:(forall input:Input \u0026 is_(let [mode, aah, horiz, trans, vert, twist, roll, pitch, yaw]:Input \u003d input in let swpos:HCM`SwitchPositions \u003d mk_HCM`SwitchPositions((if (mode \u003d 1)\nthen \u003cTran\u003e\nelse \u003cRot\u003e), (if (aah \u003d 0)\nthen \u003cUp\u003e\nelse \u003cDown\u003e)), hgpos:HCM`HandGripPosition \u003d mk_HCM`HandGripPosition(ConvertAxisCmd(vert), ConvertAxisCmd(horiz), ConvertAxisCmd(trans), ConvertAxisCmd(twist)), rcom:map ((\u003cPitch\u003e | \u003cRoll\u003e | \u003cYaw\u003e)) to (AxisCommand) \u003d {\u003cRoll\u003e |-\u003e ConvertAxisCmd(roll), \u003cPitch\u003e |-\u003e ConvertAxisCmd(pitch), \u003cYaw\u003e |-\u003e ConvertAxisCmd(yaw)} in mk_(swpos, hgpos, rcom), (SwitchPositions * HandGripPosition * RotCommand)))","type compatibility obligation:(forall ts:ThrusterSet \u0026 inv_ThrusterMatrix(let tson:set of ((nat * nat)) \u003d {GenerateThrusterLabel(t) | t in set ts} in [[(mk_(j, i) in set tson) | i in set {1, ... ,6}] | j in set {1, ... ,4}]))","cases exhaustive obligation:(forall tnm:ThrusterName \u0026 ((((((((((((((((((((((((tnm \u003d \u003cB1\u003e) or (tnm \u003d \u003cB2\u003e)) or (tnm \u003d \u003cB3\u003e)) or (tnm \u003d \u003cB4\u003e)) or (tnm \u003d \u003cF1\u003e)) or (tnm \u003d \u003cF2\u003e)) or (tnm \u003d \u003cF3\u003e)) or (tnm \u003d \u003cF4\u003e)) or (tnm \u003d \u003cL1R\u003e)) or (tnm \u003d \u003cL1F\u003e)) or (tnm \u003d \u003cR2R\u003e)) or (tnm \u003d \u003cR2F\u003e)) or (tnm \u003d \u003cL3R\u003e)) or (tnm \u003d \u003cL3F\u003e)) or (tnm \u003d \u003cR4R\u003e)) or (tnm \u003d \u003cR4F\u003e)) or (tnm \u003d \u003cD1R\u003e)) or (tnm \u003d \u003cD1F\u003e)) or (tnm \u003d \u003cD2R\u003e)) or (tnm \u003d \u003cD2F\u003e)) or (tnm \u003d \u003cU3R\u003e)) or (tnm \u003d \u003cU3F\u003e)) or (tnm \u003d \u003cU4R\u003e)) or (tnm \u003d \u003cU4F\u003e)))","enumeration map injectivity obligation:(forall m1, m2 in set {{\u003cRoll\u003e |-\u003e \u003cZero\u003e}, {\u003cPitch\u003e |-\u003e \u003cZero\u003e}, {\u003cYaw\u003e |-\u003e \u003cZero\u003e}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","legal map application obligation:(forall cmd:RotCommand \u0026 (forall a in set (dom cmd) \u0026 (a in set (dom cmd))))","legal map application obligation:(forall tran:TranCommand \u0026 (\u003cX\u003e in set (dom tran)))","legal map application obligation:(forall tran:TranCommand \u0026 ((tran(\u003cX\u003e) \u003c\u003e \u003cZero\u003e) \u003d\u003e (\u003cX\u003e in set (dom tran))))","legal map application obligation:(forall tran:TranCommand \u0026 ((not (tran(\u003cX\u003e) \u003c\u003e \u003cZero\u003e)) \u003d\u003e ((tran(\u003cY\u003e) \u003c\u003e \u003cZero\u003e) \u003d\u003e (\u003cY\u003e in set (dom tran)))))","legal map application obligation:(forall tran:TranCommand \u0026 ((not (tran(\u003cX\u003e) \u003c\u003e \u003cZero\u003e)) \u003d\u003e ((not (tran(\u003cY\u003e) \u003c\u003e \u003cZero\u003e)) \u003d\u003e ((tran(\u003cZ\u003e) \u003c\u003e \u003cZero\u003e) \u003d\u003e (\u003cZ\u003e in set (dom tran))))))","type compatibility obligation:(forall tran:TranCommand \u0026 inv_TranCommand((if (tran(\u003cX\u003e) \u003c\u003e \u003cZero\u003e)\nthen (AUX`null_tran_command ++ {\u003cX\u003e |-\u003e tran(\u003cX\u003e)})\nelseif (tran(\u003cY\u003e) \u003c\u003e \u003cZero\u003e)\nthen (AUX`null_tran_command ++ {\u003cY\u003e |-\u003e tran(\u003cY\u003e)})\nelseif (tran(\u003cZ\u003e) \u003c\u003e \u003cZero\u003e)\nthen (AUX`null_tran_command ++ {\u003cZ\u003e |-\u003e tran(\u003cZ\u003e)})\nelse AUX`null_tran_command)))","legal map application obligation:(forall hcm_rot:RotCommand, aah:RotCommand, ignore_hcm:set of (RotAxis) \u0026 (forall a in set AUX`rot_axis_set \u0026 (a in set (dom hcm_rot))))","comprehension map injectivity obligation:(forall hcm_rot:RotCommand, aah:RotCommand, ignore_hcm:set of (RotAxis) \u0026 let aah_axes:set of (RotAxis) \u003d (ignore_hcm union {a | a in set AUX`rot_axis_set \u0026 (hcm_rot(a) \u003d \u003cZero\u003e)}) in (forall m1, m2 in set {{a |-\u003e aah(a)} | a in set aah_axes} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4))))))","legal map application obligation:(forall hcm_rot:RotCommand, aah:RotCommand, ignore_hcm:set of (RotAxis) \u0026 let aah_axes:set of (RotAxis) \u003d (ignore_hcm union {a | a in set AUX`rot_axis_set \u0026 (hcm_rot(a) \u003d \u003cZero\u003e)}) in (forall a in set aah_axes \u0026 (a in set (dom aah))))","comprehension map injectivity obligation:(forall hcm_rot:RotCommand, aah:RotCommand, ignore_hcm:set of (RotAxis) \u0026 let aah_axes:set of (RotAxis) \u003d (ignore_hcm union {a | a in set AUX`rot_axis_set \u0026 (hcm_rot(a) \u003d \u003cZero\u003e)}) in (forall m1, m2 in set {{a |-\u003e hcm_rot(a)} | a in set (AUX`rot_axis_set \\ aah_axes)} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4))))))","legal map application obligation:(forall hcm_rot:RotCommand, aah:RotCommand, ignore_hcm:set of (RotAxis) \u0026 let aah_axes:set of (RotAxis) \u003d (ignore_hcm union {a | a in set AUX`rot_axis_set \u0026 (hcm_rot(a) \u003d \u003cZero\u003e)}) in (forall a in set (AUX`rot_axis_set \\ aah_axes) \u0026 (a in set (dom hcm_rot))))","map compatible obligation:(forall hcm_rot:RotCommand, aah:RotCommand, ignore_hcm:set of (RotAxis) \u0026 let aah_axes:set of (RotAxis) \u003d (ignore_hcm union {a | a in set AUX`rot_axis_set \u0026 (hcm_rot(a) \u003d \u003cZero\u003e)}) in (forall ldom1 in set (dom {a |-\u003e aah(a) | a in set aah_axes}), rdom2 in set (dom {a |-\u003e hcm_rot(a) | a in set (AUX`rot_axis_set \\ aah_axes)}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e ({a |-\u003e aah(a) | a in set aah_axes}(ldom1) \u003d {a |-\u003e hcm_rot(a) | a in set (AUX`rot_axis_set \\ aah_axes)}(rdom2)))))","type compatibility obligation:(forall hcm_rot:RotCommand, aah:RotCommand, ignore_hcm:set of (RotAxis) \u0026 inv_RotCommand(let aah_axes:set of (RotAxis) \u003d (ignore_hcm union {a | a in set AUX`rot_axis_set \u0026 (hcm_rot(a) \u003d \u003cZero\u003e)}) in ({a |-\u003e aah(a) | a in set aah_axes} munion {a |-\u003e hcm_rot(a) | a in set (AUX`rot_axis_set \\ aah_axes)})))","cases exhaustive obligation:(forall A:AxisCommand, B:AxisCommand, C:AxisCommand \u0026 (((((((((((((((((((((((((((mk_(A, B, C) \u003d mk_(\u003cNeg\u003e, \u003cNeg\u003e, \u003cNeg\u003e)) or (mk_(A, B, C) \u003d mk_(\u003cNeg\u003e, \u003cNeg\u003e, \u003cZero\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cNeg\u003e, \u003cNeg\u003e, \u003cPos\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cNeg\u003e, \u003cZero\u003e, \u003cNeg\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cNeg\u003e, \u003cZero\u003e, \u003cZero\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cNeg\u003e, \u003cZero\u003e, \u003cPos\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cNeg\u003e, \u003cPos\u003e, \u003cNeg\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cNeg\u003e, \u003cPos\u003e, \u003cZero\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cNeg\u003e, \u003cPos\u003e, \u003cPos\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cZero\u003e, \u003cNeg\u003e, \u003cNeg\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cZero\u003e, \u003cNeg\u003e, \u003cZero\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cZero\u003e, \u003cNeg\u003e, \u003cPos\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cZero\u003e, \u003cZero\u003e, \u003cNeg\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cZero\u003e, \u003cZero\u003e, \u003cZero\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cZero\u003e, \u003cZero\u003e, \u003cPos\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cZero\u003e, \u003cPos\u003e, \u003cNeg\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cZero\u003e, \u003cPos\u003e, \u003cZero\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cZero\u003e, \u003cPos\u003e, \u003cPos\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cPos\u003e, \u003cNeg\u003e, \u003cNeg\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cPos\u003e, \u003cNeg\u003e, \u003cZero\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cPos\u003e, \u003cNeg\u003e, \u003cPos\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cPos\u003e, \u003cZero\u003e, \u003cNeg\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cPos\u003e, \u003cZero\u003e, \u003cZero\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cPos\u003e, \u003cZero\u003e, \u003cPos\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cPos\u003e, \u003cPos\u003e, \u003cNeg\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cPos\u003e, \u003cPos\u003e, \u003cZero\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cPos\u003e, \u003cPos\u003e, \u003cPos\u003e))))","cases exhaustive obligation:(forall A:AxisCommand, B:AxisCommand, C:AxisCommand \u0026 (((((((((((((((((((((((((((mk_(A, B, C) \u003d mk_(\u003cNeg\u003e, \u003cNeg\u003e, \u003cNeg\u003e)) or (mk_(A, B, C) \u003d mk_(\u003cNeg\u003e, \u003cNeg\u003e, \u003cZero\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cNeg\u003e, \u003cNeg\u003e, \u003cPos\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cNeg\u003e, \u003cZero\u003e, \u003cNeg\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cNeg\u003e, \u003cZero\u003e, \u003cZero\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cNeg\u003e, \u003cZero\u003e, \u003cPos\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cNeg\u003e, \u003cPos\u003e, \u003cNeg\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cNeg\u003e, \u003cPos\u003e, \u003cZero\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cNeg\u003e, \u003cPos\u003e, \u003cPos\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cZero\u003e, \u003cNeg\u003e, \u003cNeg\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cZero\u003e, \u003cNeg\u003e, \u003cZero\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cZero\u003e, \u003cNeg\u003e, \u003cPos\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cZero\u003e, \u003cZero\u003e, \u003cNeg\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cZero\u003e, \u003cZero\u003e, \u003cZero\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cZero\u003e, \u003cZero\u003e, \u003cPos\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cZero\u003e, \u003cPos\u003e, \u003cNeg\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cZero\u003e, \u003cPos\u003e, \u003cZero\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cZero\u003e, \u003cPos\u003e, \u003cPos\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cPos\u003e, \u003cNeg\u003e, \u003cNeg\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cPos\u003e, \u003cNeg\u003e, \u003cZero\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cPos\u003e, \u003cNeg\u003e, \u003cPos\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cPos\u003e, \u003cZero\u003e, \u003cNeg\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cPos\u003e, \u003cZero\u003e, \u003cZero\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cPos\u003e, \u003cZero\u003e, \u003cPos\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cPos\u003e, \u003cPos\u003e, \u003cNeg\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cPos\u003e, \u003cPos\u003e, \u003cZero\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cPos\u003e, \u003cPos\u003e, \u003cPos\u003e))))","legal map application obligation:(forall hcm:SixDofCommand, aah:RotCommand, active_axes:set of (RotAxis), ignore_hcm:set of (RotAxis) \u0026 (\u003cX\u003e in set (dom tran)))","legal map application obligation:(forall hcm:SixDofCommand, aah:RotCommand, active_axes:set of (RotAxis), ignore_hcm:set of (RotAxis) \u0026 (\u003cPitch\u003e in set (dom rot)))","legal map application obligation:(forall hcm:SixDofCommand, aah:RotCommand, active_axes:set of (RotAxis), ignore_hcm:set of (RotAxis) \u0026 (\u003cYaw\u003e in set (dom rot)))","legal map application obligation:(forall hcm:SixDofCommand, aah:RotCommand, active_axes:set of (RotAxis), ignore_hcm:set of (RotAxis) \u0026 (\u003cY\u003e in set (dom tran)))","legal map application obligation:(forall hcm:SixDofCommand, aah:RotCommand, active_axes:set of (RotAxis), ignore_hcm:set of (RotAxis) \u0026 (\u003cZ\u003e in set (dom tran)))","legal map application obligation:(forall hcm:SixDofCommand, aah:RotCommand, active_axes:set of (RotAxis), ignore_hcm:set of (RotAxis) \u0026 (\u003cRoll\u003e in set (dom rot)))","legal map application obligation:(forall hcm:SixDofCommand, aah:RotCommand, active_axes:set of (RotAxis), ignore_hcm:set of (RotAxis) \u0026 (\u003cRoll\u003e in set (dom rot)))","legal map application obligation:(forall hcm:SixDofCommand, aah:RotCommand, active_axes:set of (RotAxis), ignore_hcm:set of (RotAxis) \u0026 (\u003cPitch\u003e in set (dom rot)))","legal map application obligation:(forall hcm:SixDofCommand, aah:RotCommand, active_axes:set of (RotAxis), ignore_hcm:set of (RotAxis) \u0026 ((rot(\u003cPitch\u003e) \u003d \u003cZero\u003e) \u003d\u003e (\u003cYaw\u003e in set (dom rot))))","enumeration map injectivity obligation:(forall a, b, c in set AUX`axis_command_set \u0026 (forall m1, m2 in set {{\u003cRoll\u003e |-\u003e a}, {\u003cPitch\u003e |-\u003e b}, {\u003cYaw\u003e |-\u003e c}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4))))))","type compatibility obligation:is_({{\u003cRoll\u003e |-\u003e a, \u003cPitch\u003e |-\u003e b, \u003cYaw\u003e |-\u003e c} | a, b, c in set AUX`axis_command_set}, set of (RotCommand))","comprehension map injectivity obligation:(forall m1, m2 in set {{mk_(switch, grip, aah_law) |-\u003e SAFER`ControlCycle(switch, grip, aah_law)} | switch in set switch_positions, grip in set grip_positions, aah_law in set all_rot_commands} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","comprehension map injectivity obligation:(forall m1, m2 in set {{mk_(switch, grip, aah_law) |-\u003e SAFER`ControlCycle(switch, grip, aah_law)} | switch in set switch_positions, grip in set all_grip_positions, aah_law in set all_rot_commands} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","let be st existence obligation:(forall ts:ThrusterSet \u0026 ((not (ts \u003d {})) \u003d\u003e (exists t in set ts \u0026 true)))","cases exhaustive obligation:(forall tnm:ThrusterName \u0026 ((((((((((((((((((((((((tnm \u003d \u003cB1\u003e) or (tnm \u003d \u003cB2\u003e)) or (tnm \u003d \u003cB3\u003e)) or (tnm \u003d \u003cB4\u003e)) or (tnm \u003d \u003cF1\u003e)) or (tnm \u003d \u003cF2\u003e)) or (tnm \u003d \u003cF3\u003e)) or (tnm \u003d \u003cF4\u003e)) or (tnm \u003d \u003cL1R\u003e)) or (tnm \u003d \u003cL1F\u003e)) or (tnm \u003d \u003cR2R\u003e)) or (tnm \u003d \u003cR2F\u003e)) or (tnm \u003d \u003cL3R\u003e)) or (tnm \u003d \u003cL3F\u003e)) or (tnm \u003d \u003cR4R\u003e)) or (tnm \u003d \u003cR4F\u003e)) or (tnm \u003d \u003cD1R\u003e)) or (tnm \u003d \u003cD1F\u003e)) or (tnm \u003d \u003cD2R\u003e)) or (tnm \u003d \u003cD2F\u003e)) or (tnm \u003d \u003cU3R\u003e)) or (tnm \u003d \u003cU3F\u003e)) or (tnm \u003d \u003cU4R\u003e)) or (tnm \u003d \u003cU4F\u003e)))","enumeration map injectivity obligation:(forall m1, m2 in set {{\u003cRoll\u003e |-\u003e ConvertAxisCmd(roll)}, {\u003cPitch\u003e |-\u003e ConvertAxisCmd(pitch)}, {\u003cYaw\u003e |-\u003e ConvertAxisCmd(yaw)}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","while loop termination obligation:NotYetImplemented","enumeration map injectivity obligation:(forall mk_HandGripPosition(vert, horiz, trans, twist):HandGripPosition, mode:ControlModeSwitch \u0026 (forall m1, m2 in set {{\u003cX\u003e |-\u003e horiz}, {\u003cY\u003e |-\u003e (if (mode \u003d \u003cTran\u003e)\nthen trans\nelse \u003cZero\u003e)}, {\u003cZ\u003e |-\u003e (if (mode \u003d \u003cTran\u003e)\nthen vert\nelse \u003cZero\u003e)}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4))))))","enumeration map injectivity obligation:(forall mk_HandGripPosition(vert, horiz, trans, twist):HandGripPosition, mode:ControlModeSwitch \u0026 (forall m1, m2 in set {{\u003cRoll\u003e |-\u003e (if (mode \u003d \u003cRot\u003e)\nthen vert\nelse \u003cZero\u003e)}, {\u003cPitch\u003e |-\u003e twist}, {\u003cYaw\u003e |-\u003e (if (mode \u003d \u003cRot\u003e)\nthen trans\nelse \u003cZero\u003e)}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4))))))","type compatibility obligation:(forall mk_HandGripPosition(vert, horiz, trans, twist):HandGripPosition, mode:ControlModeSwitch \u0026 let tran:map ((\u003cX\u003e | \u003cY\u003e | \u003cZ\u003e)) to ((\u003cZero\u003e | AxisCommand)) \u003d {\u003cX\u003e |-\u003e horiz, \u003cY\u003e |-\u003e (if (mode \u003d \u003cTran\u003e)\nthen trans\nelse \u003cZero\u003e), \u003cZ\u003e |-\u003e (if (mode \u003d \u003cTran\u003e)\nthen vert\nelse \u003cZero\u003e)}, rot:map ((\u003cPitch\u003e | \u003cRoll\u003e | \u003cYaw\u003e)) to ((\u003cZero\u003e | AxisCommand)) \u003d {\u003cRoll\u003e |-\u003e (if (mode \u003d \u003cRot\u003e)\nthen vert\nelse \u003cZero\u003e), \u003cPitch\u003e |-\u003e twist, \u003cYaw\u003e |-\u003e (if (mode \u003d \u003cRot\u003e)\nthen trans\nelse \u003cZero\u003e)} in inv_TranCommand(tran))","type compatibility obligation:(forall mk_HandGripPosition(vert, horiz, trans, twist):HandGripPosition, mode:ControlModeSwitch \u0026 let tran:map ((\u003cX\u003e | \u003cY\u003e | \u003cZ\u003e)) to ((\u003cZero\u003e | AxisCommand)) \u003d {\u003cX\u003e |-\u003e horiz, \u003cY\u003e |-\u003e (if (mode \u003d \u003cTran\u003e)\nthen trans\nelse \u003cZero\u003e), \u003cZ\u003e |-\u003e (if (mode \u003d \u003cTran\u003e)\nthen vert\nelse \u003cZero\u003e)}, rot:map ((\u003cPitch\u003e | \u003cRoll\u003e | \u003cYaw\u003e)) to ((\u003cZero\u003e | AxisCommand)) \u003d {\u003cRoll\u003e |-\u003e (if (mode \u003d \u003cRot\u003e)\nthen vert\nelse \u003cZero\u003e), \u003cPitch\u003e |-\u003e twist, \u003cYaw\u003e |-\u003e (if (mode \u003d \u003cRot\u003e)\nthen trans\nelse \u003cZero\u003e)} in inv_RotCommand(rot))","legal map application obligation:(forall button_pos:ControlButton, hcm_cmd:SixDofCommand, clock:nat, oldstate:AAH \u0026 (forall a in set AUX`rot_axis_set \u0026 ((not starting) \u003d\u003e ((engage \u003c\u003e \u003cAAH_off\u003e) \u003d\u003e ((a in set active_axes) \u003d\u003e (a in set (dom (hcm_cmd.rot))))))))","legal map application obligation:(forall button_pos:ControlButton, hcm_cmd:SixDofCommand, clock:nat, oldstate:AAH \u0026 (forall a in set AUX`rot_axis_set \u0026 (starting \u003d\u003e (a in set (dom (hcm_cmd.rot))))))","cases exhaustive obligation:(forall estate:EngageState, button:ControlButton, active:set of (RotAxis), clock:nat, timeout:nat \u0026 ((((((((((((mk_(estate, button) \u003d mk_(\u003cAAH_off\u003e, \u003cUp\u003e)) or (mk_(estate, button) \u003d mk_(\u003cAAH_off\u003e, \u003cDown\u003e))) or (mk_(estate, button) \u003d mk_(\u003cAAH_started\u003e, \u003cUp\u003e))) or (mk_(estate, button) \u003d mk_(\u003cAAH_started\u003e, \u003cDown\u003e))) or (mk_(estate, button) \u003d mk_(\u003cAAH_on\u003e, \u003cUp\u003e))) or (mk_(estate, button) \u003d mk_(\u003cAAH_on\u003e, \u003cDown\u003e))) or (mk_(estate, button) \u003d mk_(\u003cpressed_once\u003e, \u003cUp\u003e))) or (mk_(estate, button) \u003d mk_(\u003cpressed_once\u003e, \u003cDown\u003e))) or (mk_(estate, button) \u003d mk_(\u003cAAH_closing\u003e, \u003cUp\u003e))) or (mk_(estate, button) \u003d mk_(\u003cAAH_closing\u003e, \u003cDown\u003e))) or (mk_(estate, button) \u003d mk_(\u003cpressed_twice\u003e, \u003cUp\u003e))) or (mk_(estate, button) \u003d mk_(\u003cpressed_twice\u003e, \u003cDown\u003e))))"] \ No newline at end of file +["operation establishes postcondition obligation:(forall mk_SwitchPositions(mode, aah):SwitchPositions, raw_grip:HandGripPosition, aah_cmd:RotCommand, oldstate:SAFER \u0026 (true \u003d\u003e (((card RESULT) \u003c\u003d 4) and ThrusterConsistency(RESULT))))","comprehension map injectivity obligation:(forall m1, m2 in set {{a |-\u003e \u003cZero\u003e} | a in set tran_axis_set} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","type compatibility obligation:inv_TranCommand({a |-\u003e \u003cZero\u003e | a in set tran_axis_set})","comprehension map injectivity obligation:(forall m1, m2 in set {{a |-\u003e \u003cZero\u003e} | a in set rot_axis_set} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","type compatibility obligation:inv_RotCommand({a |-\u003e \u003cZero\u003e | a in set rot_axis_set})","type invariant satisfiable obligation:(exists cmd:TranCommand \u0026 ((dom cmd) \u003d tran_axis_set))","type invariant satisfiable obligation:(exists cmd:RotCommand \u0026 ((dom cmd) \u003d rot_axis_set))","type invariant satisfiable obligation:(exists inp:Input \u0026 ((len inp) \u003d 9))","legal sequence application obligation:(forall tm:seq of (seq of (bool)) \u0026 (((len tm) \u003d 4) \u003d\u003e (forall i in set (inds tm) \u0026 (i in set (inds tm)))))","type invariant satisfiable obligation:(exists tm:ThrusterMatrix \u0026 (((len tm) \u003d 4) and (forall i in set (inds tm) \u0026 ((len tm(i)) \u003d 6))))","enumeration map injectivity obligation:(forall input:Input \u0026 let [mode, aah, horiz, trans, vert, twist, roll, pitch, yaw]:Input \u003d input in (forall m1, m2 in set {{\u003cRoll\u003e |-\u003e ConvertAxisCmd(roll)}, {\u003cPitch\u003e |-\u003e ConvertAxisCmd(pitch)}, {\u003cYaw\u003e |-\u003e ConvertAxisCmd(yaw)}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4))))))","type compatibility obligation:(forall input:Input \u0026 is_(let [mode, aah, horiz, trans, vert, twist, roll, pitch, yaw]:Input \u003d input in let swpos:HCM`SwitchPositions \u003d mk_HCM`SwitchPositions((if (mode \u003d 1)\nthen \u003cTran\u003e\nelse \u003cRot\u003e), (if (aah \u003d 0)\nthen \u003cUp\u003e\nelse \u003cDown\u003e)), hgpos:HCM`HandGripPosition \u003d mk_HCM`HandGripPosition(ConvertAxisCmd(vert), ConvertAxisCmd(horiz), ConvertAxisCmd(trans), ConvertAxisCmd(twist)), rcom:map ((\u003cPitch\u003e | \u003cRoll\u003e | \u003cYaw\u003e)) to (AxisCommand) \u003d {\u003cRoll\u003e |-\u003e ConvertAxisCmd(roll), \u003cPitch\u003e |-\u003e ConvertAxisCmd(pitch), \u003cYaw\u003e |-\u003e ConvertAxisCmd(yaw)} in mk_(swpos, hgpos, rcom), (SwitchPositions * HandGripPosition * RotCommand)))","type compatibility obligation:(forall ts:ThrusterSet \u0026 inv_ThrusterMatrix(let tson:set of ((nat * nat)) \u003d {GenerateThrusterLabel(t) | t in set ts} in [[(mk_(j, i) in set tson) | i in set {1, ... ,6}] | j in set {1, ... ,4}]))","cases exhaustive obligation:(forall tnm:ThrusterName \u0026 ((((((((((((((((((((((((tnm \u003d \u003cB1\u003e) or (tnm \u003d \u003cB2\u003e)) or (tnm \u003d \u003cB3\u003e)) or (tnm \u003d \u003cB4\u003e)) or (tnm \u003d \u003cF1\u003e)) or (tnm \u003d \u003cF2\u003e)) or (tnm \u003d \u003cF3\u003e)) or (tnm \u003d \u003cF4\u003e)) or (tnm \u003d \u003cL1R\u003e)) or (tnm \u003d \u003cL1F\u003e)) or (tnm \u003d \u003cR2R\u003e)) or (tnm \u003d \u003cR2F\u003e)) or (tnm \u003d \u003cL3R\u003e)) or (tnm \u003d \u003cL3F\u003e)) or (tnm \u003d \u003cR4R\u003e)) or (tnm \u003d \u003cR4F\u003e)) or (tnm \u003d \u003cD1R\u003e)) or (tnm \u003d \u003cD1F\u003e)) or (tnm \u003d \u003cD2R\u003e)) or (tnm \u003d \u003cD2F\u003e)) or (tnm \u003d \u003cU3R\u003e)) or (tnm \u003d \u003cU3F\u003e)) or (tnm \u003d \u003cU4R\u003e)) or (tnm \u003d \u003cU4F\u003e)))","enumeration map injectivity obligation:(forall m1, m2 in set {{\u003cRoll\u003e |-\u003e \u003cZero\u003e}, {\u003cPitch\u003e |-\u003e \u003cZero\u003e}, {\u003cYaw\u003e |-\u003e \u003cZero\u003e}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","legal map application obligation:(forall cmd:RotCommand \u0026 (forall a in set (dom cmd) \u0026 (a in set (dom cmd))))","legal map application obligation:(forall tran:TranCommand \u0026 (\u003cX\u003e in set (dom tran)))","legal map application obligation:(forall tran:TranCommand \u0026 ((tran(\u003cX\u003e) \u003c\u003e \u003cZero\u003e) \u003d\u003e (\u003cX\u003e in set (dom tran))))","legal map application obligation:(forall tran:TranCommand \u0026 ((not (tran(\u003cX\u003e) \u003c\u003e \u003cZero\u003e)) \u003d\u003e ((tran(\u003cY\u003e) \u003c\u003e \u003cZero\u003e) \u003d\u003e (\u003cY\u003e in set (dom tran)))))","legal map application obligation:(forall tran:TranCommand \u0026 ((not (tran(\u003cX\u003e) \u003c\u003e \u003cZero\u003e)) \u003d\u003e ((not (tran(\u003cY\u003e) \u003c\u003e \u003cZero\u003e)) \u003d\u003e ((tran(\u003cZ\u003e) \u003c\u003e \u003cZero\u003e) \u003d\u003e (\u003cZ\u003e in set (dom tran))))))","type compatibility obligation:(forall tran:TranCommand \u0026 inv_TranCommand((if (tran(\u003cX\u003e) \u003c\u003e \u003cZero\u003e)\nthen (AUX`null_tran_command ++ {\u003cX\u003e |-\u003e tran(\u003cX\u003e)})\nelseif (tran(\u003cY\u003e) \u003c\u003e \u003cZero\u003e)\nthen (AUX`null_tran_command ++ {\u003cY\u003e |-\u003e tran(\u003cY\u003e)})\nelseif (tran(\u003cZ\u003e) \u003c\u003e \u003cZero\u003e)\nthen (AUX`null_tran_command ++ {\u003cZ\u003e |-\u003e tran(\u003cZ\u003e)})\nelse AUX`null_tran_command)))","legal map application obligation:(forall hcm_rot:RotCommand, aah:RotCommand, ignore_hcm:set of (RotAxis) \u0026 (forall a in set AUX`rot_axis_set \u0026 (a in set (dom hcm_rot))))","comprehension map injectivity obligation:(forall hcm_rot:RotCommand, aah:RotCommand, ignore_hcm:set of (RotAxis) \u0026 let aah_axes:set of (RotAxis) \u003d (ignore_hcm union {a | a in set AUX`rot_axis_set \u0026 (hcm_rot(a) \u003d \u003cZero\u003e)}) in (forall m1, m2 in set {{a |-\u003e aah(a)} | a in set aah_axes} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4))))))","legal map application obligation:(forall hcm_rot:RotCommand, aah:RotCommand, ignore_hcm:set of (RotAxis) \u0026 let aah_axes:set of (RotAxis) \u003d (ignore_hcm union {a | a in set AUX`rot_axis_set \u0026 (hcm_rot(a) \u003d \u003cZero\u003e)}) in (forall a in set aah_axes \u0026 (a in set (dom aah))))","comprehension map injectivity obligation:(forall hcm_rot:RotCommand, aah:RotCommand, ignore_hcm:set of (RotAxis) \u0026 let aah_axes:set of (RotAxis) \u003d (ignore_hcm union {a | a in set AUX`rot_axis_set \u0026 (hcm_rot(a) \u003d \u003cZero\u003e)}) in (forall m1, m2 in set {{a |-\u003e hcm_rot(a)} | a in set (AUX`rot_axis_set \\ aah_axes)} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4))))))","legal map application obligation:(forall hcm_rot:RotCommand, aah:RotCommand, ignore_hcm:set of (RotAxis) \u0026 let aah_axes:set of (RotAxis) \u003d (ignore_hcm union {a | a in set AUX`rot_axis_set \u0026 (hcm_rot(a) \u003d \u003cZero\u003e)}) in (forall a in set (AUX`rot_axis_set \\ aah_axes) \u0026 (a in set (dom hcm_rot))))","map compatible obligation:(forall hcm_rot:RotCommand, aah:RotCommand, ignore_hcm:set of (RotAxis) \u0026 let aah_axes:set of (RotAxis) \u003d (ignore_hcm union {a | a in set AUX`rot_axis_set \u0026 (hcm_rot(a) \u003d \u003cZero\u003e)}) in (forall ldom1 in set (dom {a |-\u003e aah(a) | a in set aah_axes}), rdom2 in set (dom {a |-\u003e hcm_rot(a) | a in set (AUX`rot_axis_set \\ aah_axes)}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e ({a |-\u003e aah(a) | a in set aah_axes}(ldom1) \u003d {a |-\u003e hcm_rot(a) | a in set (AUX`rot_axis_set \\ aah_axes)}(rdom2)))))","type compatibility obligation:(forall hcm_rot:RotCommand, aah:RotCommand, ignore_hcm:set of (RotAxis) \u0026 inv_RotCommand(let aah_axes:set of (RotAxis) \u003d (ignore_hcm union {a | a in set AUX`rot_axis_set \u0026 (hcm_rot(a) \u003d \u003cZero\u003e)}) in ({a |-\u003e aah(a) | a in set aah_axes} munion {a |-\u003e hcm_rot(a) | a in set (AUX`rot_axis_set \\ aah_axes)})))","cases exhaustive obligation:(forall A:AxisCommand, B:AxisCommand, C:AxisCommand \u0026 (((((((((((((((((((((((((((mk_(A, B, C) \u003d mk_(\u003cNeg\u003e, \u003cNeg\u003e, \u003cNeg\u003e)) or (mk_(A, B, C) \u003d mk_(\u003cNeg\u003e, \u003cNeg\u003e, \u003cZero\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cNeg\u003e, \u003cNeg\u003e, \u003cPos\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cNeg\u003e, \u003cZero\u003e, \u003cNeg\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cNeg\u003e, \u003cZero\u003e, \u003cZero\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cNeg\u003e, \u003cZero\u003e, \u003cPos\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cNeg\u003e, \u003cPos\u003e, \u003cNeg\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cNeg\u003e, \u003cPos\u003e, \u003cZero\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cNeg\u003e, \u003cPos\u003e, \u003cPos\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cZero\u003e, \u003cNeg\u003e, \u003cNeg\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cZero\u003e, \u003cNeg\u003e, \u003cZero\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cZero\u003e, \u003cNeg\u003e, \u003cPos\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cZero\u003e, \u003cZero\u003e, \u003cNeg\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cZero\u003e, \u003cZero\u003e, \u003cZero\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cZero\u003e, \u003cZero\u003e, \u003cPos\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cZero\u003e, \u003cPos\u003e, \u003cNeg\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cZero\u003e, \u003cPos\u003e, \u003cZero\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cZero\u003e, \u003cPos\u003e, \u003cPos\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cPos\u003e, \u003cNeg\u003e, \u003cNeg\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cPos\u003e, \u003cNeg\u003e, \u003cZero\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cPos\u003e, \u003cNeg\u003e, \u003cPos\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cPos\u003e, \u003cZero\u003e, \u003cNeg\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cPos\u003e, \u003cZero\u003e, \u003cZero\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cPos\u003e, \u003cZero\u003e, \u003cPos\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cPos\u003e, \u003cPos\u003e, \u003cNeg\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cPos\u003e, \u003cPos\u003e, \u003cZero\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cPos\u003e, \u003cPos\u003e, \u003cPos\u003e))))","cases exhaustive obligation:(forall A:AxisCommand, B:AxisCommand, C:AxisCommand \u0026 (((((((((((((((((((((((((((mk_(A, B, C) \u003d mk_(\u003cNeg\u003e, \u003cNeg\u003e, \u003cNeg\u003e)) or (mk_(A, B, C) \u003d mk_(\u003cNeg\u003e, \u003cNeg\u003e, \u003cZero\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cNeg\u003e, \u003cNeg\u003e, \u003cPos\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cNeg\u003e, \u003cZero\u003e, \u003cNeg\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cNeg\u003e, \u003cZero\u003e, \u003cZero\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cNeg\u003e, \u003cZero\u003e, \u003cPos\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cNeg\u003e, \u003cPos\u003e, \u003cNeg\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cNeg\u003e, \u003cPos\u003e, \u003cZero\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cNeg\u003e, \u003cPos\u003e, \u003cPos\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cZero\u003e, \u003cNeg\u003e, \u003cNeg\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cZero\u003e, \u003cNeg\u003e, \u003cZero\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cZero\u003e, \u003cNeg\u003e, \u003cPos\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cZero\u003e, \u003cZero\u003e, \u003cNeg\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cZero\u003e, \u003cZero\u003e, \u003cZero\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cZero\u003e, \u003cZero\u003e, \u003cPos\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cZero\u003e, \u003cPos\u003e, \u003cNeg\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cZero\u003e, \u003cPos\u003e, \u003cZero\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cZero\u003e, \u003cPos\u003e, \u003cPos\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cPos\u003e, \u003cNeg\u003e, \u003cNeg\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cPos\u003e, \u003cNeg\u003e, \u003cZero\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cPos\u003e, \u003cNeg\u003e, \u003cPos\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cPos\u003e, \u003cZero\u003e, \u003cNeg\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cPos\u003e, \u003cZero\u003e, \u003cZero\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cPos\u003e, \u003cZero\u003e, \u003cPos\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cPos\u003e, \u003cPos\u003e, \u003cNeg\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cPos\u003e, \u003cPos\u003e, \u003cZero\u003e))) or (mk_(A, B, C) \u003d mk_(\u003cPos\u003e, \u003cPos\u003e, \u003cPos\u003e))))","legal map application obligation:(forall hcm:SixDofCommand, aah:RotCommand, active_axes:set of (RotAxis), ignore_hcm:set of (RotAxis) \u0026 (\u003cX\u003e in set (dom tran)))","legal map application obligation:(forall hcm:SixDofCommand, aah:RotCommand, active_axes:set of (RotAxis), ignore_hcm:set of (RotAxis) \u0026 (\u003cPitch\u003e in set (dom rot)))","legal map application obligation:(forall hcm:SixDofCommand, aah:RotCommand, active_axes:set of (RotAxis), ignore_hcm:set of (RotAxis) \u0026 (\u003cYaw\u003e in set (dom rot)))","legal map application obligation:(forall hcm:SixDofCommand, aah:RotCommand, active_axes:set of (RotAxis), ignore_hcm:set of (RotAxis) \u0026 (\u003cY\u003e in set (dom tran)))","legal map application obligation:(forall hcm:SixDofCommand, aah:RotCommand, active_axes:set of (RotAxis), ignore_hcm:set of (RotAxis) \u0026 (\u003cZ\u003e in set (dom tran)))","legal map application obligation:(forall hcm:SixDofCommand, aah:RotCommand, active_axes:set of (RotAxis), ignore_hcm:set of (RotAxis) \u0026 (\u003cRoll\u003e in set (dom rot)))","legal map application obligation:(forall hcm:SixDofCommand, aah:RotCommand, active_axes:set of (RotAxis), ignore_hcm:set of (RotAxis) \u0026 (\u003cRoll\u003e in set (dom rot)))","legal map application obligation:(forall hcm:SixDofCommand, aah:RotCommand, active_axes:set of (RotAxis), ignore_hcm:set of (RotAxis) \u0026 (\u003cPitch\u003e in set (dom rot)))","legal map application obligation:(forall hcm:SixDofCommand, aah:RotCommand, active_axes:set of (RotAxis), ignore_hcm:set of (RotAxis) \u0026 ((rot(\u003cPitch\u003e) \u003d \u003cZero\u003e) \u003d\u003e (\u003cYaw\u003e in set (dom rot))))","enumeration map injectivity obligation:(forall a, b, c in set AUX`axis_command_set \u0026 (forall m1, m2 in set {{\u003cRoll\u003e |-\u003e a}, {\u003cPitch\u003e |-\u003e b}, {\u003cYaw\u003e |-\u003e c}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4))))))","type compatibility obligation:is_({{\u003cRoll\u003e |-\u003e a, \u003cPitch\u003e |-\u003e b, \u003cYaw\u003e |-\u003e c} | a, b, c in set AUX`axis_command_set}, set of (RotCommand))","comprehension map injectivity obligation:(forall m1, m2 in set {{mk_(switch, grip, aah_law) |-\u003e SAFER`ControlCycle(switch, grip, aah_law)} | switch in set switch_positions, grip in set grip_positions, aah_law in set all_rot_commands} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","comprehension map injectivity obligation:(forall m1, m2 in set {{mk_(switch, grip, aah_law) |-\u003e SAFER`ControlCycle(switch, grip, aah_law)} | switch in set switch_positions, grip in set all_grip_positions, aah_law in set all_rot_commands} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","let be st existence obligation:(forall ts:ThrusterSet \u0026 ((not (ts \u003d {})) \u003d\u003e (exists t in set ts \u0026 true)))","cases exhaustive obligation:(forall tnm:ThrusterName \u0026 ((((((((((((((((((((((((tnm \u003d \u003cB1\u003e) or (tnm \u003d \u003cB2\u003e)) or (tnm \u003d \u003cB3\u003e)) or (tnm \u003d \u003cB4\u003e)) or (tnm \u003d \u003cF1\u003e)) or (tnm \u003d \u003cF2\u003e)) or (tnm \u003d \u003cF3\u003e)) or (tnm \u003d \u003cF4\u003e)) or (tnm \u003d \u003cL1R\u003e)) or (tnm \u003d \u003cL1F\u003e)) or (tnm \u003d \u003cR2R\u003e)) or (tnm \u003d \u003cR2F\u003e)) or (tnm \u003d \u003cL3R\u003e)) or (tnm \u003d \u003cL3F\u003e)) or (tnm \u003d \u003cR4R\u003e)) or (tnm \u003d \u003cR4F\u003e)) or (tnm \u003d \u003cD1R\u003e)) or (tnm \u003d \u003cD1F\u003e)) or (tnm \u003d \u003cD2R\u003e)) or (tnm \u003d \u003cD2F\u003e)) or (tnm \u003d \u003cU3R\u003e)) or (tnm \u003d \u003cU3F\u003e)) or (tnm \u003d \u003cU4R\u003e)) or (tnm \u003d \u003cU4F\u003e)))","enumeration map injectivity obligation:(forall m1, m2 in set {{\u003cRoll\u003e |-\u003e ConvertAxisCmd(roll)}, {\u003cPitch\u003e |-\u003e ConvertAxisCmd(pitch)}, {\u003cYaw\u003e |-\u003e ConvertAxisCmd(yaw)}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","while loop termination obligation:...","enumeration map injectivity obligation:(forall mk_HandGripPosition(vert, horiz, trans, twist):HandGripPosition, mode:ControlModeSwitch \u0026 (forall m1, m2 in set {{\u003cX\u003e |-\u003e horiz}, {\u003cY\u003e |-\u003e (if (mode \u003d \u003cTran\u003e)\nthen trans\nelse \u003cZero\u003e)}, {\u003cZ\u003e |-\u003e (if (mode \u003d \u003cTran\u003e)\nthen vert\nelse \u003cZero\u003e)}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4))))))","enumeration map injectivity obligation:(forall mk_HandGripPosition(vert, horiz, trans, twist):HandGripPosition, mode:ControlModeSwitch \u0026 (forall m1, m2 in set {{\u003cRoll\u003e |-\u003e (if (mode \u003d \u003cRot\u003e)\nthen vert\nelse \u003cZero\u003e)}, {\u003cPitch\u003e |-\u003e twist}, {\u003cYaw\u003e |-\u003e (if (mode \u003d \u003cRot\u003e)\nthen trans\nelse \u003cZero\u003e)}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4))))))","type compatibility obligation:(forall mk_HandGripPosition(vert, horiz, trans, twist):HandGripPosition, mode:ControlModeSwitch \u0026 let tran:map ((\u003cX\u003e | \u003cY\u003e | \u003cZ\u003e)) to ((\u003cZero\u003e | AxisCommand)) \u003d {\u003cX\u003e |-\u003e horiz, \u003cY\u003e |-\u003e (if (mode \u003d \u003cTran\u003e)\nthen trans\nelse \u003cZero\u003e), \u003cZ\u003e |-\u003e (if (mode \u003d \u003cTran\u003e)\nthen vert\nelse \u003cZero\u003e)}, rot:map ((\u003cPitch\u003e | \u003cRoll\u003e | \u003cYaw\u003e)) to ((\u003cZero\u003e | AxisCommand)) \u003d {\u003cRoll\u003e |-\u003e (if (mode \u003d \u003cRot\u003e)\nthen vert\nelse \u003cZero\u003e), \u003cPitch\u003e |-\u003e twist, \u003cYaw\u003e |-\u003e (if (mode \u003d \u003cRot\u003e)\nthen trans\nelse \u003cZero\u003e)} in inv_TranCommand(tran))","type compatibility obligation:(forall mk_HandGripPosition(vert, horiz, trans, twist):HandGripPosition, mode:ControlModeSwitch \u0026 let tran:map ((\u003cX\u003e | \u003cY\u003e | \u003cZ\u003e)) to ((\u003cZero\u003e | AxisCommand)) \u003d {\u003cX\u003e |-\u003e horiz, \u003cY\u003e |-\u003e (if (mode \u003d \u003cTran\u003e)\nthen trans\nelse \u003cZero\u003e), \u003cZ\u003e |-\u003e (if (mode \u003d \u003cTran\u003e)\nthen vert\nelse \u003cZero\u003e)}, rot:map ((\u003cPitch\u003e | \u003cRoll\u003e | \u003cYaw\u003e)) to ((\u003cZero\u003e | AxisCommand)) \u003d {\u003cRoll\u003e |-\u003e (if (mode \u003d \u003cRot\u003e)\nthen vert\nelse \u003cZero\u003e), \u003cPitch\u003e |-\u003e twist, \u003cYaw\u003e |-\u003e (if (mode \u003d \u003cRot\u003e)\nthen trans\nelse \u003cZero\u003e)} in inv_RotCommand(rot))","legal map application obligation:(forall button_pos:ControlButton, hcm_cmd:SixDofCommand, clock:nat, oldstate:AAH \u0026 (forall a in set AUX`rot_axis_set \u0026 ((not starting) \u003d\u003e ((engage \u003c\u003e \u003cAAH_off\u003e) \u003d\u003e ((a in set active_axes) \u003d\u003e (a in set (dom (hcm_cmd.rot))))))))","legal map application obligation:(forall button_pos:ControlButton, hcm_cmd:SixDofCommand, clock:nat, oldstate:AAH \u0026 (forall a in set AUX`rot_axis_set \u0026 (starting \u003d\u003e (a in set (dom (hcm_cmd.rot))))))","cases exhaustive obligation:(forall estate:EngageState, button:ControlButton, active:set of (RotAxis), clock:nat, timeout:nat \u0026 ((((((((((((mk_(estate, button) \u003d mk_(\u003cAAH_off\u003e, \u003cUp\u003e)) or (mk_(estate, button) \u003d mk_(\u003cAAH_off\u003e, \u003cDown\u003e))) or (mk_(estate, button) \u003d mk_(\u003cAAH_started\u003e, \u003cUp\u003e))) or (mk_(estate, button) \u003d mk_(\u003cAAH_started\u003e, \u003cDown\u003e))) or (mk_(estate, button) \u003d mk_(\u003cAAH_on\u003e, \u003cUp\u003e))) or (mk_(estate, button) \u003d mk_(\u003cAAH_on\u003e, \u003cDown\u003e))) or (mk_(estate, button) \u003d mk_(\u003cpressed_once\u003e, \u003cUp\u003e))) or (mk_(estate, button) \u003d mk_(\u003cpressed_once\u003e, \u003cDown\u003e))) or (mk_(estate, button) \u003d mk_(\u003cAAH_closing\u003e, \u003cUp\u003e))) or (mk_(estate, button) \u003d mk_(\u003cAAH_closing\u003e, \u003cDown\u003e))) or (mk_(estate, button) \u003d mk_(\u003cpressed_twice\u003e, \u003cUp\u003e))) or (mk_(estate, button) \u003d mk_(\u003cpressed_twice\u003e, \u003cDown\u003e))))"] \ No newline at end of file diff --git a/core/pog/src/test/resources/examples/SSlibE2PP.result b/core/pog/src/test/resources/examples/SSlibE2PP.result index 39dd5d9a21..d125142d3e 100644 --- a/core/pog/src/test/resources/examples/SSlibE2PP.result +++ b/core/pog/src/test/resources/examples/SSlibE2PP.result @@ -1 +1 @@ -["legal map application obligation:(forall aMap:map (@T1) to (@T2), aKey:@T1 \u0026 ((aKey in set (dom aMap)) \u003d\u003e (aKey in set (dom aMap))))","legal sequence application obligation:(forall t:seq of (TestCase) \u0026 (forall i in set (inds t) \u0026 (i in set (inds t))))","legal sequence application obligation:(forall t:seq of (TestCase) \u0026 let m:seq1 of (char) \u003d \"Result-of-testcases.\", r:seq of (bool) \u003d [isOK(t(i)) | i in set (inds t)] in (forall i in set (inds r) \u0026 (i in set (inds r))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:(forall p:(@T -\u003e bool), f:(@T -\u003e @T), x:@T \u0026 pre_(px))","legal function application obligation:(forall p:(@T -\u003e bool), f:(@T -\u003e @T), x:@T \u0026 ((not p(x)) \u003d\u003e pre_((Funtil)[@T](p)(f)f(x))))","legal function application obligation:(forall p:(@T -\u003e bool), f:(@T -\u003e @T), x:@T \u0026 ((not p(x)) \u003d\u003e pre_((Funtil)[@T](p)f)))","legal function application obligation:(forall p:(@T -\u003e bool), f:(@T -\u003e @T), x:@T \u0026 ((not p(x)) \u003d\u003e pre_(fx)))","legal function application obligation:(forall p:(@T -\u003e bool), f:(@T -\u003e @T), x:@T \u0026 pre_(px))","legal function application obligation:(forall p:(@T -\u003e bool), f:(@T -\u003e @T), x:@T \u0026 (p(x) \u003d\u003e pre_((Fwhile)[@T](p)(f)f(x))))","legal function application obligation:(forall p:(@T -\u003e bool), f:(@T -\u003e @T), x:@T \u0026 (p(x) \u003d\u003e pre_((Fwhile)[@T](p)f)))","legal function application obligation:(forall p:(@T -\u003e bool), f:(@T -\u003e @T), x:@T \u0026 (p(x) \u003d\u003e pre_(fx)))","legal function application obligation:(forall fs:seq of ((@T -\u003e @T)), p:@T \u0026 (exists [xf] ^ xfs:seq of ((@T -\u003e @T)) \u0026 ((([xf] ^ xfs) \u003d fs) \u003d\u003e let [xf] ^ xfs \u003d fs in pre_((Seq)[@T](xfs)xf(p)))))","legal function application obligation:(forall fs:seq of ((@T -\u003e @T)), p:@T \u0026 (exists [xf] ^ xfs:seq of ((@T -\u003e @T)) \u0026 ((([xf] ^ xfs) \u003d fs) \u003d\u003e let [xf] ^ xfs \u003d fs in pre_(xfp))))","cases exhaustive obligation:(forall fs:seq of ((@T -\u003e @T)), p:@T \u0026 ((exists [xf] ^ xfs:seq of ((@T -\u003e @T)) \u0026 (fs \u003d ([xf] ^ xfs))) or (fs \u003d [])))","legal function application obligation:(forall fname:seq of (char) \u0026 pre_(((io.freadval))[@T]fname))","legal function application obligation:(forall s:seq of (@T) \u0026 ((is_(s, seq of (int)) or (is_(s, seq of (nat)) or (is_(s, seq of (nat1)) or (is_(s, seq of (real)) or is_(s, seq of (rat)))))) \u003d\u003e pre_((Foldl)[@T, @T]((Plus)[@T])(0)s)))","legal function application obligation:(forall s:seq of (@T) \u0026 ((is_(s, seq of (int)) or (is_(s, seq of (nat)) or (is_(s, seq of (nat1)) or (is_(s, seq of (real)) or is_(s, seq of (rat)))))) \u003d\u003e pre_((Foldl)[@T, @T]((Plus)[@T])0)))","legal function application obligation:(forall s:seq of (@T) \u0026 ((is_(s, seq of (int)) or (is_(s, seq of (nat)) or (is_(s, seq of (nat1)) or (is_(s, seq of (real)) or is_(s, seq of (rat)))))) \u003d\u003e pre_((Foldl)[@T, @T]((Product)[@T])(1)s)))","legal function application obligation:(forall s:seq of (@T) \u0026 ((is_(s, seq of (int)) or (is_(s, seq of (nat)) or (is_(s, seq of (nat1)) or (is_(s, seq of (real)) or is_(s, seq of (rat)))))) \u003d\u003e pre_((Foldl)[@T, @T]((Product)[@T])1)))","function establishes postcondition obligation:(forall s:seq of (@T) \u0026 post_Average(s, (if (s \u003d [])\nthen nil\nelse (AverageAux)[@T](0)(0)(s))))","legal function application obligation:(forall s:seq of (@T) \u0026 let RESULT \u003d (if (s \u003d [])\nthen nil\nelse (AverageAux)[@T](0)(0)(s)) in ((not (s \u003d [])) \u003d\u003e pre_Sum(s)))","non-zero obligation:(forall s:seq of (@T) \u0026 let RESULT \u003d (if (s \u003d [])\nthen nil\nelse (AverageAux)[@T](0)(0)(s)) in ((not (s \u003d [])) \u003d\u003e let sum:@T \u003d (Sum)[@T](s) in (is_(sum, real) \u003d\u003e ((len s) \u003c\u003e 0))))","legal function application obligation:(forall s:seq of (@T) \u0026 ((not (s \u003d [])) \u003d\u003e pre_((AverageAux)[@T](0)(0)s)))","legal function application obligation:(forall s:seq of (@T) \u0026 ((not (s \u003d [])) \u003d\u003e pre_((AverageAux)[@T](0)0)))","legal function application obligation:(forall total:@T, numOfElem:@T, s:seq of (@T) \u0026 ((is_(s, seq of (real)) and (is_(total, real) and is_(numOfElem, real))) \u003d\u003e (exists [x] ^ xs:seq of (real) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in pre_((AverageAux)[@T]((total + x))((numOfElem + 1))xs)))))","legal function application obligation:(forall total:@T, numOfElem:@T, s:seq of (@T) \u0026 ((is_(s, seq of (real)) and (is_(total, real) and is_(numOfElem, real))) \u003d\u003e (exists [x] ^ xs:seq of (real) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in pre_((AverageAux)[@T]((total + x))(numOfElem + 1))))))","non-zero obligation:(forall total:@T, numOfElem:@T, s:seq of (@T) \u0026 ((is_(s, seq of (real)) and (is_(total, real) and is_(numOfElem, real))) \u003d\u003e ((not (exists [x] ^ xs:seq of (real) \u0026 (([x] ^ xs) \u003d s))) \u003d\u003e (([] \u003d s) \u003d\u003e (numOfElem \u003c\u003e 0)))))","cases exhaustive obligation:(forall total:@T, numOfElem:@T, s:seq of (@T) \u0026 ((is_(s, seq of (real)) and (is_(total, real) and is_(numOfElem, real))) \u003d\u003e ((exists [x] ^ xs:seq of (real) \u0026 (s \u003d ([x] ^ xs))) or (s \u003d []))))","legal function application obligation:(forall f:(@T * @T -\u003e bool), s:seq of (@T) \u0026 (forall i, j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e pre_(fs(i), s(j)))))","legal sequence application obligation:(forall f:(@T * @T -\u003e bool), s:seq of (@T) \u0026 (forall i, j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e (i in set (inds s)))))","legal sequence application obligation:(forall f:(@T * @T -\u003e bool), s:seq of (@T) \u0026 (forall i, j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e (j in set (inds s)))))","legal sequence application obligation:(forall f:(@T * @T -\u003e bool), s:seq of (@T) \u0026 (forall i, j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e ((not f(s(i), s(j))) \u003d\u003e (i in set (inds s))))))","legal sequence application obligation:(forall f:(@T * @T -\u003e bool), s:seq of (@T) \u0026 (forall i, j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e ((not f(s(i), s(j))) \u003d\u003e (j in set (inds s))))))","legal function application obligation:(forall f:(@T * @T -\u003e bool), s:seq of (@T) \u0026 (forall i, j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e pre_(fs(j), s(i)))))","legal sequence application obligation:(forall f:(@T * @T -\u003e bool), s:seq of (@T) \u0026 (forall i, j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e (j in set (inds s)))))","legal sequence application obligation:(forall f:(@T * @T -\u003e bool), s:seq of (@T) \u0026 (forall i, j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e (i in set (inds s)))))","legal sequence application obligation:(forall f:(@T * @T -\u003e bool), s:seq of (@T) \u0026 (forall i, j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e ((not f(s(j), s(i))) \u003d\u003e (i in set (inds s))))))","legal sequence application obligation:(forall f:(@T * @T -\u003e bool), s:seq of (@T) \u0026 (forall i, j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e ((not f(s(j), s(i))) \u003d\u003e (j in set (inds s))))))","legal function application obligation:(forall s:seq of (@T) \u0026 pre_((IsAscendingInTotalOrder)[@T]((lambda [x:@T, y:@T] \u0026 (if (is_(x, real) and is_(y, real))\nthen (x \u003c y)\nelse (undefined))))s))","legal function application obligation:(forall s:seq of (@T) \u0026 pre_((IsDescendingInTotalOrder)[@T]((lambda [x:@T, y:@T] \u0026 (if (is_(x, real) and is_(y, real))\nthen (x \u003c y)\nelse (undefined))))s))","legal function application obligation:(forall f:(@T * @T -\u003e bool), s:seq of (@T) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in pre_((Sort)[@T](f)[xs(i) | i in set (inds xs) \u0026 f(xs(i), x)])))))","legal sequence application obligation:(forall f:(@T * @T -\u003e bool), s:seq of (@T) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in (forall i in set (inds xs) \u0026 (f(xs(i), x) \u003d\u003e (i in set (inds xs))))))))","legal function application obligation:(forall f:(@T * @T -\u003e bool), s:seq of (@T) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in (forall i in set (inds xs) \u0026 pre_(fxs(i), x))))))","legal sequence application obligation:(forall f:(@T * @T -\u003e bool), s:seq of (@T) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in (forall i in set (inds xs) \u0026 (i in set (inds xs)))))))","legal function application obligation:(forall f:(@T * @T -\u003e bool), s:seq of (@T) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in pre_((Sort)[@T](f)[xs(i) | i in set (inds xs) \u0026 (not f(xs(i), x))])))))","legal sequence application obligation:(forall f:(@T * @T -\u003e bool), s:seq of (@T) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in (forall i in set (inds xs) \u0026 ((not f(xs(i), x)) \u003d\u003e (i in set (inds xs))))))))","legal function application obligation:(forall f:(@T * @T -\u003e bool), s:seq of (@T) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in (forall i in set (inds xs) \u0026 pre_(fxs(i), x))))))","legal sequence application obligation:(forall f:(@T * @T -\u003e bool), s:seq of (@T) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in (forall i in set (inds xs) \u0026 (i in set (inds xs)))))))","cases exhaustive obligation:(forall f:(@T * @T -\u003e bool), s:seq of (@T) \u0026 ((s \u003d []) or (exists [x] ^ xs:seq of (@T) \u0026 (s \u003d ([x] ^ xs)))))","function establishes postcondition obligation:(forall s:seq of (@T) \u0026 post_AscendingSort(s, (Sort)[@T]((lambda [x:@T, y:@T] \u0026 (if (is_(x, real) and is_(y, real))\nthen (x \u003c y)\nelse (undefined))))(s)))","legal function application obligation:(forall s:seq of (@T) \u0026 pre_((Sort)[@T]((lambda [x:@T, y:@T] \u0026 (if (is_(x, real) and is_(y, real))\nthen (x \u003c y)\nelse (undefined))))s))","function establishes postcondition obligation:(forall s:seq of (@T) \u0026 post_DescendingSort(s, (Sort)[@T]((lambda [x:@T, y:@T] \u0026 (if (is_(x, real) and is_(y, real))\nthen (x \u003e y)\nelse (undefined))))(s)))","legal function application obligation:(forall s:seq of (@T) \u0026 pre_((Sort)[@T]((lambda [x:@T, y:@T] \u0026 (if (is_(x, real) and is_(y, real))\nthen (x \u003e y)\nelse (undefined))))s))","legal function application obligation:(forall f:seq of ((@T * @T -\u003e bool)), s1:seq of (@T), s2:seq of (@T) \u0026 ((not (mk_([], []) \u003d mk_(s1, s2))) \u003d\u003e ((not (exists mk_([], -):(seq of (@T) * seq of (@T)) \u0026 (mk_([], any1) \u003d mk_(s1, s2)))) \u003d\u003e ((not (exists mk_(-, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(any1, []) \u003d mk_(s1, s2)))) \u003d\u003e (exists mk_([x1] ^ xs1, [x2] ^ xs2):(seq of (@T) * seq of (@T)) \u0026 ((mk_(([x1] ^ xs1), ([x2] ^ xs2)) \u003d mk_(s1, s2)) \u003d\u003e let mk_([x1] ^ xs1, [x2] ^ xs2) \u003d mk_(s1, s2) in pre_((hd f)x1, x2)))))))","non-empty sequence obligation:(forall f:seq of ((@T * @T -\u003e bool)), s1:seq of (@T), s2:seq of (@T) \u0026 ((not (mk_([], []) \u003d mk_(s1, s2))) \u003d\u003e ((not (exists mk_([], -):(seq of (@T) * seq of (@T)) \u0026 (mk_([], any1) \u003d mk_(s1, s2)))) \u003d\u003e ((not (exists mk_(-, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(any1, []) \u003d mk_(s1, s2)))) \u003d\u003e (exists mk_([x1] ^ xs1, [x2] ^ xs2):(seq of (@T) * seq of (@T)) \u0026 ((mk_(([x1] ^ xs1), ([x2] ^ xs2)) \u003d mk_(s1, s2)) \u003d\u003e let mk_([x1] ^ xs1, [x2] ^ xs2) \u003d mk_(s1, s2) in (f \u003c\u003e [])))))))","legal function application obligation:(forall f:seq of ((@T * @T -\u003e bool)), s1:seq of (@T), s2:seq of (@T) \u0026 ((not (mk_([], []) \u003d mk_(s1, s2))) \u003d\u003e ((not (exists mk_([], -):(seq of (@T) * seq of (@T)) \u0026 (mk_([], any1) \u003d mk_(s1, s2)))) \u003d\u003e ((not (exists mk_(-, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(any1, []) \u003d mk_(s1, s2)))) \u003d\u003e (exists mk_([x1] ^ xs1, [x2] ^ xs2):(seq of (@T) * seq of (@T)) \u0026 ((mk_(([x1] ^ xs1), ([x2] ^ xs2)) \u003d mk_(s1, s2)) \u003d\u003e let mk_([x1] ^ xs1, [x2] ^ xs2) \u003d mk_(s1, s2) in ((not (hd f)(x1, x2)) \u003d\u003e ((not (hd f)(x2, x1)) \u003d\u003e pre_((IsOrdered)[@T]((tl f))(xs1)xs2)))))))))","legal function application obligation:(forall f:seq of ((@T * @T -\u003e bool)), s1:seq of (@T), s2:seq of (@T) \u0026 ((not (mk_([], []) \u003d mk_(s1, s2))) \u003d\u003e ((not (exists mk_([], -):(seq of (@T) * seq of (@T)) \u0026 (mk_([], any1) \u003d mk_(s1, s2)))) \u003d\u003e ((not (exists mk_(-, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(any1, []) \u003d mk_(s1, s2)))) \u003d\u003e (exists mk_([x1] ^ xs1, [x2] ^ xs2):(seq of (@T) * seq of (@T)) \u0026 ((mk_(([x1] ^ xs1), ([x2] ^ xs2)) \u003d mk_(s1, s2)) \u003d\u003e let mk_([x1] ^ xs1, [x2] ^ xs2) \u003d mk_(s1, s2) in ((not (hd f)(x1, x2)) \u003d\u003e ((not (hd f)(x2, x1)) \u003d\u003e pre_((IsOrdered)[@T]((tl f))xs1)))))))))","non-empty sequence obligation:(forall f:seq of ((@T * @T -\u003e bool)), s1:seq of (@T), s2:seq of (@T) \u0026 ((not (mk_([], []) \u003d mk_(s1, s2))) \u003d\u003e ((not (exists mk_([], -):(seq of (@T) * seq of (@T)) \u0026 (mk_([], any1) \u003d mk_(s1, s2)))) \u003d\u003e ((not (exists mk_(-, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(any1, []) \u003d mk_(s1, s2)))) \u003d\u003e (exists mk_([x1] ^ xs1, [x2] ^ xs2):(seq of (@T) * seq of (@T)) \u0026 ((mk_(([x1] ^ xs1), ([x2] ^ xs2)) \u003d mk_(s1, s2)) \u003d\u003e let mk_([x1] ^ xs1, [x2] ^ xs2) \u003d mk_(s1, s2) in ((not (hd f)(x1, x2)) \u003d\u003e ((not (hd f)(x2, x1)) \u003d\u003e (f \u003c\u003e [])))))))))","cases exhaustive obligation:(forall f:seq of ((@T * @T -\u003e bool)), s1:seq of (@T), s2:seq of (@T) \u0026 ((((mk_(s1, s2) \u003d mk_([], [])) or (exists mk_([], -):(seq of (@T) * seq of (@T)) \u0026 (mk_(s1, s2) \u003d mk_([], any1)))) or (exists mk_(-, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(s1, s2) \u003d mk_(any1, [])))) or (exists mk_([x1] ^ xs1, [x2] ^ xs2):(seq of (@T) * seq of (@T)) \u0026 (mk_(s1, s2) \u003d mk_(([x1] ^ xs1), ([x2] ^ xs2))))))","legal function application obligation:(forall f:(@T * @T -\u003e bool), s1:seq of (@T), s2:seq of (@T) \u0026 ((not (exists mk_([], y):(seq of (@T) * seq of (@T)) \u0026 (mk_([], y) \u003d mk_(s1, s2)))) \u003d\u003e ((not (exists mk_(x, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(x, []) \u003d mk_(s1, s2)))) \u003d\u003e (exists mk_([x1] ^ xs1, [x2] ^ xs2):(seq of (@T) * seq of (@T)) \u0026 ((mk_(([x1] ^ xs1), ([x2] ^ xs2)) \u003d mk_(s1, s2)) \u003d\u003e let mk_([x1] ^ xs1, [x2] ^ xs2) \u003d mk_(s1, s2) in pre_(fx1, x2))))))","legal function application obligation:(forall f:(@T * @T -\u003e bool), s1:seq of (@T), s2:seq of (@T) \u0026 ((not (exists mk_([], y):(seq of (@T) * seq of (@T)) \u0026 (mk_([], y) \u003d mk_(s1, s2)))) \u003d\u003e ((not (exists mk_(x, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(x, []) \u003d mk_(s1, s2)))) \u003d\u003e (exists mk_([x1] ^ xs1, [x2] ^ xs2):(seq of (@T) * seq of (@T)) \u0026 ((mk_(([x1] ^ xs1), ([x2] ^ xs2)) \u003d mk_(s1, s2)) \u003d\u003e let mk_([x1] ^ xs1, [x2] ^ xs2) \u003d mk_(s1, s2) in (f(x1, x2) \u003d\u003e pre_((FSequence`Merge)[@T](f)(xs1)s2)))))))","legal function application obligation:(forall f:(@T * @T -\u003e bool), s1:seq of (@T), s2:seq of (@T) \u0026 ((not (exists mk_([], y):(seq of (@T) * seq of (@T)) \u0026 (mk_([], y) \u003d mk_(s1, s2)))) \u003d\u003e ((not (exists mk_(x, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(x, []) \u003d mk_(s1, s2)))) \u003d\u003e (exists mk_([x1] ^ xs1, [x2] ^ xs2):(seq of (@T) * seq of (@T)) \u0026 ((mk_(([x1] ^ xs1), ([x2] ^ xs2)) \u003d mk_(s1, s2)) \u003d\u003e let mk_([x1] ^ xs1, [x2] ^ xs2) \u003d mk_(s1, s2) in (f(x1, x2) \u003d\u003e pre_((FSequence`Merge)[@T](f)xs1)))))))","legal function application obligation:(forall f:(@T * @T -\u003e bool), s1:seq of (@T), s2:seq of (@T) \u0026 ((not (exists mk_([], y):(seq of (@T) * seq of (@T)) \u0026 (mk_([], y) \u003d mk_(s1, s2)))) \u003d\u003e ((not (exists mk_(x, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(x, []) \u003d mk_(s1, s2)))) \u003d\u003e (exists mk_([x1] ^ xs1, [x2] ^ xs2):(seq of (@T) * seq of (@T)) \u0026 ((mk_(([x1] ^ xs1), ([x2] ^ xs2)) \u003d mk_(s1, s2)) \u003d\u003e let mk_([x1] ^ xs1, [x2] ^ xs2) \u003d mk_(s1, s2) in ((not f(x1, x2)) \u003d\u003e pre_((FSequence`Merge)[@T](f)(s1)xs2)))))))","legal function application obligation:(forall f:(@T * @T -\u003e bool), s1:seq of (@T), s2:seq of (@T) \u0026 ((not (exists mk_([], y):(seq of (@T) * seq of (@T)) \u0026 (mk_([], y) \u003d mk_(s1, s2)))) \u003d\u003e ((not (exists mk_(x, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(x, []) \u003d mk_(s1, s2)))) \u003d\u003e (exists mk_([x1] ^ xs1, [x2] ^ xs2):(seq of (@T) * seq of (@T)) \u0026 ((mk_(([x1] ^ xs1), ([x2] ^ xs2)) \u003d mk_(s1, s2)) \u003d\u003e let mk_([x1] ^ xs1, [x2] ^ xs2) \u003d mk_(s1, s2) in ((not f(x1, x2)) \u003d\u003e pre_((FSequence`Merge)[@T](f)s1)))))))","cases exhaustive obligation:(forall f:(@T * @T -\u003e bool), s1:seq of (@T), s2:seq of (@T) \u0026 (((exists mk_([], y):(seq of (@T) * seq of (@T)) \u0026 (mk_(s1, s2) \u003d mk_([], y))) or (exists mk_(x, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(s1, s2) \u003d mk_(x, [])))) or (exists mk_([x1] ^ xs1, [x2] ^ xs2):(seq of (@T) * seq of (@T)) \u0026 (mk_(s1, s2) \u003d mk_(([x1] ^ xs1), ([x2] ^ xs2))))))","legal function application obligation:(forall i:nat1, e:@T, s:seq of (@T) \u0026 ((not (exists mk_(1, s1):(nat1 * seq of (@T)) \u0026 (mk_(1, s1) \u003d mk_(i, s)))) \u003d\u003e ((not (exists mk_(-, []):(nat1 * seq of (@T)) \u0026 (mk_(any1, []) \u003d mk_(i, s)))) \u003d\u003e (exists mk_(i1, [x] ^ xs):(nat1 * seq of (@T)) \u0026 ((mk_(i1, ([x] ^ xs)) \u003d mk_(i, s)) \u003d\u003e let mk_(i1, [x] ^ xs) \u003d mk_(i, s) in pre_((InsertAt)[@T]((i1 - 1))(e)xs))))))","legal function application obligation:(forall i:nat1, e:@T, s:seq of (@T) \u0026 ((not (exists mk_(1, s1):(nat1 * seq of (@T)) \u0026 (mk_(1, s1) \u003d mk_(i, s)))) \u003d\u003e ((not (exists mk_(-, []):(nat1 * seq of (@T)) \u0026 (mk_(any1, []) \u003d mk_(i, s)))) \u003d\u003e (exists mk_(i1, [x] ^ xs):(nat1 * seq of (@T)) \u0026 ((mk_(i1, ([x] ^ xs)) \u003d mk_(i, s)) \u003d\u003e let mk_(i1, [x] ^ xs) \u003d mk_(i, s) in pre_((InsertAt)[@T]((i1 - 1))e))))))","type compatibility obligation:(forall i:nat1, e:@T, s:seq of (@T) \u0026 ((not (exists mk_(1, s1):(nat1 * seq of (@T)) \u0026 (mk_(1, s1) \u003d mk_(i, s)))) \u003d\u003e ((not (exists mk_(-, []):(nat1 * seq of (@T)) \u0026 (mk_(any1, []) \u003d mk_(i, s)))) \u003d\u003e (exists mk_(i1, [x] ^ xs):(nat1 * seq of (@T)) \u0026 ((mk_(i1, ([x] ^ xs)) \u003d mk_(i, s)) \u003d\u003e let mk_(i1, [x] ^ xs) \u003d mk_(i, s) in ((i1 - 1) \u003e 0))))))","cases exhaustive obligation:(forall i:nat1, e:@T, s:seq of (@T) \u0026 (((exists mk_(1, s1):(nat1 * seq of (@T)) \u0026 (mk_(i, s) \u003d mk_(1, s1))) or (exists mk_(-, []):(nat1 * seq of (@T)) \u0026 (mk_(i, s) \u003d mk_(any1, [])))) or (exists mk_(i1, [x] ^ xs):(nat1 * seq of (@T)) \u0026 (mk_(i, s) \u003d mk_(i1, ([x] ^ xs))))))","legal function application obligation:(forall i:nat1, s:seq of (@T) \u0026 ((not (exists mk_(1, [-] ^ xs):(nat1 * seq of (@T)) \u0026 (mk_(1, ([any1] ^ xs)) \u003d mk_(i, s)))) \u003d\u003e (exists mk_(i1, [x] ^ xs):(nat1 * seq of (@T)) \u0026 ((mk_(i1, ([x] ^ xs)) \u003d mk_(i, s)) \u003d\u003e let mk_(i1, [x] ^ xs) \u003d mk_(i, s) in pre_((RemoveAt)[@T]((i1 - 1))xs)))))","type compatibility obligation:(forall i:nat1, s:seq of (@T) \u0026 ((not (exists mk_(1, [-] ^ xs):(nat1 * seq of (@T)) \u0026 (mk_(1, ([any1] ^ xs)) \u003d mk_(i, s)))) \u003d\u003e (exists mk_(i1, [x] ^ xs):(nat1 * seq of (@T)) \u0026 ((mk_(i1, ([x] ^ xs)) \u003d mk_(i, s)) \u003d\u003e let mk_(i1, [x] ^ xs) \u003d mk_(i, s) in ((i1 - 1) \u003e 0)))))","cases exhaustive obligation:(forall i:nat1, s:seq of (@T) \u0026 (((exists mk_(1, [-] ^ xs):(nat1 * seq of (@T)) \u0026 (mk_(i, s) \u003d mk_(1, ([any1] ^ xs)))) or (exists mk_(i1, [x] ^ xs):(nat1 * seq of (@T)) \u0026 (mk_(i, s) \u003d mk_(i1, ([x] ^ xs))))) or (exists mk_(-, []):(nat1 * seq of (@T)) \u0026 (mk_(i, s) \u003d mk_(any1, [])))))","function establishes postcondition obligation:(forall s:seq of (@T) \u0026 post_RemoveDup(s, (cases s :\n[x] ^ xs -\u003e ([x] ^ (RemoveDup)[@T]((Filter)[@T]((lambda [e:@T] \u0026 (e \u003c\u003e x)))(xs))),\n[] -\u003e []\n end)))","legal function application obligation:(forall s:seq of (@T) \u0026 (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in pre_((Filter)[@T]((lambda [e:@T] \u0026 (e \u003c\u003e x)))xs))))","cases exhaustive obligation:(forall s:seq of (@T) \u0026 ((exists [x] ^ xs:seq of (@T) \u0026 (s \u003d ([x] ^ xs))) or (s \u003d [])))","legal function application obligation:(forall e:@T, s:seq of (@T) \u0026 (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in ((not (e \u003d x)) \u003d\u003e pre_((RemoveMember)[@T](e)xs)))))","cases exhaustive obligation:(forall e:@T, s:seq of (@T) \u0026 ((exists [x] ^ xs:seq of (@T) \u0026 (s \u003d ([x] ^ xs))) or (s \u003d [])))","legal function application obligation:(forall es:seq of (@T), s:seq of (@T) \u0026 ((not ([] \u003d es)) \u003d\u003e (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d es) \u003d\u003e let [x] ^ xs \u003d es in pre_((RemoveMembers)[@T](xs)(RemoveMember)[@T](x)(s))))))","legal function application obligation:(forall es:seq of (@T), s:seq of (@T) \u0026 ((not ([] \u003d es)) \u003d\u003e (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d es) \u003d\u003e let [x] ^ xs \u003d es in pre_((RemoveMember)[@T](x)s)))))","cases exhaustive obligation:(forall es:seq of (@T), s:seq of (@T) \u0026 ((es \u003d []) or (exists [x] ^ xs:seq of (@T) \u0026 (es \u003d ([x] ^ xs)))))","legal function application obligation:(forall i:nat1, e:@T, s:seq of (@T) \u0026 ((not (exists mk_(-, []):(nat1 * seq of (@T)) \u0026 (mk_(any1, []) \u003d mk_(i, s)))) \u003d\u003e ((not (exists mk_(1, [-] ^ xs):(nat1 * seq of (@T)) \u0026 (mk_(1, ([any1] ^ xs)) \u003d mk_(i, s)))) \u003d\u003e (exists mk_(i1, [x] ^ xs):(nat1 * seq of (@T)) \u0026 ((mk_(i1, ([x] ^ xs)) \u003d mk_(i, s)) \u003d\u003e let mk_(i1, [x] ^ xs) \u003d mk_(i, s) in pre_((UpdateAt)[@T]((i1 - 1))(e)xs))))))","legal function application obligation:(forall i:nat1, e:@T, s:seq of (@T) \u0026 ((not (exists mk_(-, []):(nat1 * seq of (@T)) \u0026 (mk_(any1, []) \u003d mk_(i, s)))) \u003d\u003e ((not (exists mk_(1, [-] ^ xs):(nat1 * seq of (@T)) \u0026 (mk_(1, ([any1] ^ xs)) \u003d mk_(i, s)))) \u003d\u003e (exists mk_(i1, [x] ^ xs):(nat1 * seq of (@T)) \u0026 ((mk_(i1, ([x] ^ xs)) \u003d mk_(i, s)) \u003d\u003e let mk_(i1, [x] ^ xs) \u003d mk_(i, s) in pre_((UpdateAt)[@T]((i1 - 1))e))))))","type compatibility obligation:(forall i:nat1, e:@T, s:seq of (@T) \u0026 ((not (exists mk_(-, []):(nat1 * seq of (@T)) \u0026 (mk_(any1, []) \u003d mk_(i, s)))) \u003d\u003e ((not (exists mk_(1, [-] ^ xs):(nat1 * seq of (@T)) \u0026 (mk_(1, ([any1] ^ xs)) \u003d mk_(i, s)))) \u003d\u003e (exists mk_(i1, [x] ^ xs):(nat1 * seq of (@T)) \u0026 ((mk_(i1, ([x] ^ xs)) \u003d mk_(i, s)) \u003d\u003e let mk_(i1, [x] ^ xs) \u003d mk_(i, s) in ((i1 - 1) \u003e 0))))))","cases exhaustive obligation:(forall i:nat1, e:@T, s:seq of (@T) \u0026 (((exists mk_(-, []):(nat1 * seq of (@T)) \u0026 (mk_(i, s) \u003d mk_(any1, []))) or (exists mk_(1, [-] ^ xs):(nat1 * seq of (@T)) \u0026 (mk_(i, s) \u003d mk_(1, ([any1] ^ xs))))) or (exists mk_(i1, [x] ^ xs):(nat1 * seq of (@T)) \u0026 (mk_(i, s) \u003d mk_(i1, ([x] ^ xs))))))","legal function application obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in pre_(fx))))","legal function application obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in (f(x) \u003d\u003e pre_((TakeWhile)[@T](f)xs)))))","cases exhaustive obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 ((exists [x] ^ xs:seq of (@T) \u0026 (s \u003d ([x] ^ xs))) or (s \u003d [])))","legal function application obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in pre_(fx))))","legal function application obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in (f(x) \u003d\u003e pre_((DropWhile)[@T](f)xs)))))","cases exhaustive obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 ((exists [x] ^ xs:seq of (@T) \u0026 (s \u003d ([x] ^ xs))) or (s \u003d [])))","legal function application obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in pre_(fx))))","legal function application obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in (f(x) \u003d\u003e pre_((Span)[@T](f)xs)))))","cases exhaustive obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 ((exists [x] ^ xs:seq of (@T) \u0026 (s \u003d ([x] ^ xs))) or (s \u003d [])))","legal sequence application obligation:(forall s:seq of (@T) \u0026 ((len s) in set (inds s)))","legal function application obligation:(forall f:(@T1 -\u003e @T2), s:seq of (@T1) \u0026 (forall i in set (inds s) \u0026 pre_(fs(i))))","legal sequence application obligation:(forall f:(@T1 -\u003e @T2), s:seq of (@T1) \u0026 (forall i in set (inds s) \u0026 (i in set (inds s))))","legal sequence application obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 (forall i in set (inds s) \u0026 (f(s(i)) \u003d\u003e (i in set (inds s)))))","legal function application obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 (forall i in set (inds s) \u0026 pre_(fs(i))))","legal sequence application obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 (forall i in set (inds s) \u0026 (i in set (inds s))))","legal function application obligation:(forall f:(@T1 -\u003e (@T2 -\u003e @T1)), args:@T1, s:seq of (@T2) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [x] ^ xs:seq of (@T2) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in pre_((Foldl)[@T1, @T2](f)(f(args)(x))xs)))))","legal function application obligation:(forall f:(@T1 -\u003e (@T2 -\u003e @T1)), args:@T1, s:seq of (@T2) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [x] ^ xs:seq of (@T2) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in pre_((Foldl)[@T1, @T2](f)f(args)(x))))))","legal function application obligation:(forall f:(@T1 -\u003e (@T2 -\u003e @T1)), args:@T1, s:seq of (@T2) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [x] ^ xs:seq of (@T2) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in pre_(f(args)x)))))","legal function application obligation:(forall f:(@T1 -\u003e (@T2 -\u003e @T1)), args:@T1, s:seq of (@T2) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [x] ^ xs:seq of (@T2) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in pre_(fargs)))))","cases exhaustive obligation:(forall f:(@T1 -\u003e (@T2 -\u003e @T1)), args:@T1, s:seq of (@T2) \u0026 ((s \u003d []) or (exists [x] ^ xs:seq of (@T2) \u0026 (s \u003d ([x] ^ xs)))))","legal function application obligation:(forall f:(@T1 -\u003e (@T2 -\u003e @T2)), args:@T2, s:seq of (@T1) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [x] ^ xs:seq of (@T1) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in pre_(f(x)(Foldr)[@T1, @T2](f)(args)(xs))))))","legal function application obligation:(forall f:(@T1 -\u003e (@T2 -\u003e @T2)), args:@T2, s:seq of (@T1) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [x] ^ xs:seq of (@T1) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in pre_(fx)))))","legal function application obligation:(forall f:(@T1 -\u003e (@T2 -\u003e @T2)), args:@T2, s:seq of (@T1) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [x] ^ xs:seq of (@T1) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in pre_((Foldr)[@T1, @T2](f)(args)xs)))))","legal function application obligation:(forall f:(@T1 -\u003e (@T2 -\u003e @T2)), args:@T2, s:seq of (@T1) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [x] ^ xs:seq of (@T1) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in pre_((Foldr)[@T1, @T2](f)args)))))","cases exhaustive obligation:(forall f:(@T1 -\u003e (@T2 -\u003e @T2)), args:@T2, s:seq of (@T1) \u0026 ((s \u003d []) or (exists [x] ^ xs:seq of (@T1) \u0026 (s \u003d ([x] ^ xs)))))","legal function application obligation:(forall e:@T, s:seq of (@T) \u0026 (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in ((not (e \u003d x)) \u003d\u003e pre_((IsMember)[@T](e)xs)))))","cases exhaustive obligation:(forall e:@T, s:seq of (@T) \u0026 ((exists [x] ^ xs:seq of (@T) \u0026 (s \u003d ([x] ^ xs))) or (s \u003d [])))","legal function application obligation:(forall es:seq of (@T), s:seq of (@T) \u0026 (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d es) \u003d\u003e let [x] ^ xs \u003d es in pre_((IsMember)[@T](x)s))))","legal function application obligation:(forall es:seq of (@T), s:seq of (@T) \u0026 (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d es) \u003d\u003e let [x] ^ xs \u003d es in ((not (IsMember)[@T](x)(s)) \u003d\u003e pre_((IsAnyMember)[@T](xs)s)))))","cases exhaustive obligation:(forall es:seq of (@T), s:seq of (@T) \u0026 ((exists [x] ^ xs:seq of (@T) \u0026 (es \u003d ([x] ^ xs))) or (es \u003d [])))","function establishes postcondition obligation:(forall s:seq of (@T) \u0026 post_IsDup(s, (not ((card (elems s)) \u003d (len s)))))","legal sequence application obligation:(forall s:seq of (@T) \u0026 let RESULT \u003d (not ((card (elems s)) \u003d (len s))) in ((not (s \u003d [])) \u003d\u003e (forall i, j in set (inds s) \u0026 (i in set (inds s)))))","legal sequence application obligation:(forall s:seq of (@T) \u0026 let RESULT \u003d (not ((card (elems s)) \u003d (len s))) in ((not (s \u003d [])) \u003d\u003e (forall i, j in set (inds s) \u0026 (j in set (inds s)))))","legal function application obligation:(forall e:@T, s:seq of (@T) \u0026 let i:nat \u003d 0 in pre_((IndexAux)[@T](e)(s)i))","legal function application obligation:(forall e:@T, s:seq of (@T) \u0026 let i:nat \u003d 0 in pre_((IndexAux)[@T](e)s))","legal function application obligation:(forall e:@T, s:seq of (@T), i:int \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in ((not (x \u003d e)) \u003d\u003e pre_((IndexAux)[@T](e)(xs)(i + 1)))))))","legal function application obligation:(forall e:@T, s:seq of (@T), i:int \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in ((not (x \u003d e)) \u003d\u003e pre_((IndexAux)[@T](e)xs))))))","cases exhaustive obligation:(forall e:@T, s:seq of (@T), i:int \u0026 ((s \u003d []) or (exists [x] ^ xs:seq of (@T) \u0026 (s \u003d ([x] ^ xs)))))","legal sequence application obligation:(forall e:@T, s:seq of (@T) \u0026 (forall i in set (inds s) \u0026 (i in set (inds s))))","function establishes postcondition obligation:(forall s:seq of ([@T]) \u0026 post_Compact(s, [s(i) | i in set (inds s) \u0026 (s(i) \u003c\u003e nil)]))","legal sequence application obligation:(forall s:seq of ([@T]) \u0026 let RESULT \u003d [s(i) | i in set (inds s) \u0026 (s(i) \u003c\u003e nil)] in (forall i in set (inds RESULT) \u0026 (i in set (inds RESULT))))","legal sequence application obligation:(forall s:seq of ([@T]) \u0026 (forall i in set (inds s) \u0026 ((s(i) \u003c\u003e nil) \u003d\u003e (i in set (inds s)))))","legal sequence application obligation:(forall s:seq of ([@T]) \u0026 (forall i in set (inds s) \u0026 (i in set (inds s))))","legal sequence application obligation:(forall s:seq of (@T) \u0026 (forall i in set (inds s) \u0026 ((((len s) + 1) - i) in set (inds s))))","function establishes postcondition obligation:(forall s:seq of (@T) \u0026 post_Permutations(s, (cases s :\n[] -\u003e {s},\n[-] -\u003e {s}\nothers (dunion {{([s(i)] ^ j) | j in set (Permutations)[@T]((RemoveAt)[@T](i)(s))} | i in set (inds s)})\n end)))","legal sequence application obligation:(forall s:seq of (@T) \u0026 ((not ([] \u003d s)) \u003d\u003e ((not (exists [-]:seq of (@T) \u0026 ([any1] \u003d s))) \u003d\u003e (forall i in set (inds s) \u0026 (forall j in set (Permutations)[@T]((RemoveAt)[@T](i)(s)) \u0026 (i in set (inds s)))))))","legal function application obligation:(forall s:seq of (@T) \u0026 ((not ([] \u003d s)) \u003d\u003e ((not (exists [-]:seq of (@T) \u0026 ([any1] \u003d s))) \u003d\u003e (forall i in set (inds s) \u0026 pre_((RemoveAt)[@T](i)s)))))","legal function application obligation:(forall s:seq of (@T), t:seq of (@T) \u0026 pre_((RemoveMembers)[@T](s)t))","legal function application obligation:(forall s:seq of (@T), t:seq of (@T) \u0026 (((RemoveMembers)[@T](s)(t) \u003d []) \u003d\u003e pre_((RemoveMembers)[@T](t)s)))","cases exhaustive obligation:(forall s:seq of ((@T1 * @T2)) \u0026 ((s \u003d []) or (exists [mk_(x, y)] ^ xs:seq of ((@T1 * @T2)) \u0026 (s \u003d ([mk_(x, y)] ^ xs)))))","legal function application obligation:(forall s1:seq of (@T1), s2:seq of (@T2) \u0026 pre_((Zip2)[@T1, @T2](s1)s2))","legal function application obligation:(forall s1:seq of (@T1), s2:seq of (@T2) \u0026 (exists mk_([x1] ^ xs1, [x2] ^ xs2):(seq of (@T1) * seq of (@T2)) \u0026 ((mk_(([x1] ^ xs1), ([x2] ^ xs2)) \u003d mk_(s1, s2)) \u003d\u003e let mk_([x1] ^ xs1, [x2] ^ xs2) \u003d mk_(s1, s2) in pre_((Zip2)[@T1, @T2](xs1)xs2))))","cases exhaustive obligation:(forall s1:seq of (@T1), s2:seq of (@T2) \u0026 ((exists mk_([x1] ^ xs1, [x2] ^ xs2):(seq of (@T1) * seq of (@T2)) \u0026 (mk_(s1, s2) \u003d mk_(([x1] ^ xs1), ([x2] ^ xs2)))) or (exists mk_(-, -):(seq of (@T1) * seq of (@T2)) \u0026 (mk_(s1, s2) \u003d mk_(any1, any1)))))","type compatibility obligation:is_(tests(), seq of (TestCase))","legal function application obligation:(forall t:TestCase \u0026 ((t.TestACase)() \u003d\u003e pre_((new TestLogger().Succeeded)t)))","legal function application obligation:(forall t:TestCase \u0026 ((not (t.TestACase)()) \u003d\u003e pre_((new TestLogger().Failed)t)))","legal sequence application obligation:(forall i in set (inds TestcaseSeq) \u0026 (i in set (inds TestcaseSeq)))","legal sequence application obligation:(forall i in set (inds aResult) \u0026 (i in set (inds aResult)))","legal function application obligation:pre_((new TestLogger().succeededInAllTestcases)Message)","legal function application obligation:pre_((new TestLogger().notSucceededInAllTestcases)Message)","legal function application obligation:pre_((calendar().getNumberOfDayOfTheWeek)self)","legal function application obligation:pre_((calendar().getNameOfDayOfTheWeek)self)","legal function application obligation:(forall date:Date, nameOfDayOfTheWeek:NameOfDayOfTheWeek \u0026 pre_((calendar().getNumberOfTheDayOfWeek)self, date, nameOfDayOfTheWeek))","legal function application obligation:(forall date:Date \u0026 pre_((calendar().getTheNumberOfDayOff)self, date))","legal function application obligation:(forall date:Date \u0026 pre_((calendar().getTheNumberOfDayOffExceptStartDate)self, date))","legal function application obligation:pre_((calendar().Year)self)","legal function application obligation:pre_((calendar().Month)self)","legal function application obligation:pre_((calendar().day)self)","legal function application obligation:pre_((calendar().getFutureWeekday)self)","legal function application obligation:pre_((calendar().getPastWeekday)self)","legal function application obligation:(forall addNumOfDays:int \u0026 pre_((calendar().addWeekday)self, addNumOfDays))","legal function application obligation:(forall subtractNumOfDays:int \u0026 pre_((calendar().subtractWeekday)self, subtractNumOfDays))","legal function application obligation:pre_((calendar().isSunday)self)","legal function application obligation:pre_((calendar().isSaturday)self)","legal function application obligation:pre_((calendar().isWeekday)self)","legal function application obligation:pre_((calendar().isNotDayOff)self)","legal function application obligation:pre_((calendar().isDayOff)self)","legal function application obligation:pre_((calendar().isSundayOrDayoff)self)","legal function application obligation:pre_((calendar().daysFromNewYear)self)","legal function application obligation:pre_((self.Year))","legal function application obligation:pre_((self.Month))","legal function application obligation:pre_((self.day))","legal function application obligation:(forall i:int \u0026 let str:(int -\u003e seq1 of (char)) \u003d Integer`asString in ((i \u003e\u003d 10) \u003d\u003e pre_(stri)))","legal function application obligation:(forall i:int \u0026 let str:(int -\u003e seq1 of (char)) \u003d Integer`asString in ((not (i \u003e\u003d 10)) \u003d\u003e pre_(stri)))","legal function application obligation:pre_((self.Year))","legal function application obligation:pre_((self.Month))","legal function application obligation:pre_((self.day))","legal function application obligation:pre_(asStringy)","legal function application obligation:pre_((self.Year))","legal function application obligation:pre_((self.Month))","legal function application obligation:pre_((self.day))","legal function application obligation:pre_(asStringy)","legal function application obligation:pre_((new FHashtableT().run))","legal sequence application obligation:(forall i in set (inds ResultOfTest) \u0026 (i in set (inds ResultOfTest)))","legal function application obligation:pre_((new TestLogger().succeededInAllTestcases)Message)","legal function application obligation:pre_((new TestLogger().notSucceededInAllTestcases)Message)","legal function application obligation:pre_((c.isDigit)\u00270\u0027)","legal function application obligation:(((c.isDigit)(\u00270\u0027) \u003d true) \u003d\u003e pre_((c.isDigit)\u00271\u0027))","legal function application obligation:(((c.isDigit)(\u00270\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00271\u0027) \u003d true) \u003d\u003e pre_((c.isDigit)\u00272\u0027)))","legal function application obligation:(((c.isDigit)(\u00270\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00271\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00272\u0027) \u003d true) \u003d\u003e pre_((c.isDigit)\u00273\u0027))))","legal function application obligation:(((c.isDigit)(\u00270\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00271\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00272\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00273\u0027) \u003d true) \u003d\u003e pre_((c.isDigit)\u00274\u0027)))))","legal function application obligation:(((c.isDigit)(\u00270\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00271\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00272\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00273\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00274\u0027) \u003d true) \u003d\u003e pre_((c.isDigit)\u00275\u0027))))))","legal function application obligation:(((c.isDigit)(\u00270\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00271\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00272\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00273\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00274\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00275\u0027) \u003d true) \u003d\u003e pre_((c.isDigit)\u00276\u0027)))))))","legal function application obligation:(((c.isDigit)(\u00270\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00271\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00272\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00273\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00274\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00275\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00276\u0027) \u003d true) \u003d\u003e pre_((c.isDigit)\u00277\u0027))))))))","legal function application obligation:(((c.isDigit)(\u00270\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00271\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00272\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00273\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00274\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00275\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00276\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00277\u0027) \u003d true) \u003d\u003e pre_((c.isDigit)\u00278\u0027)))))))))","legal function application obligation:(((c.isDigit)(\u00270\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00271\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00272\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00273\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00274\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00275\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00276\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00277\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00278\u0027) \u003d true) \u003d\u003e pre_((c.isDigit)\u00279\u0027))))))))))","legal function application obligation:(((c.isDigit)(\u00270\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00271\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00272\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00273\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00274\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00275\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00276\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00277\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00278\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00279\u0027) \u003d true) \u003d\u003e pre_((c.isDigit)\u0027a\u0027)))))))))))","legal function application obligation:(((c.isDigit)(\u00270\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00271\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00272\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00273\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00274\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00275\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00276\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00277\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00278\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00279\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u0027a\u0027) \u003d false) \u003d\u003e pre_((c.asDigit)\u00270\u0027))))))))))))","legal function application obligation:(((c.isDigit)(\u00270\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00271\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00272\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00273\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00274\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00275\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00276\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00277\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00278\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00279\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u0027a\u0027) \u003d false) \u003d\u003e (((c.asDigit)(\u00270\u0027) \u003d 0) \u003d\u003e pre_((c.asDigit)\u00271\u0027)))))))))))))","legal function application obligation:(((c.isDigit)(\u00270\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00271\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00272\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00273\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00274\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00275\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00276\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00277\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00278\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00279\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u0027a\u0027) \u003d false) \u003d\u003e (((c.asDigit)(\u00270\u0027) \u003d 0) \u003d\u003e (((c.asDigit)(\u00271\u0027) \u003d 1) \u003d\u003e pre_((c.asDigit)\u00272\u0027))))))))))))))","legal function application obligation:(((c.isDigit)(\u00270\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00271\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00272\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00273\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00274\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00275\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00276\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00277\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00278\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00279\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u0027a\u0027) \u003d false) \u003d\u003e (((c.asDigit)(\u00270\u0027) \u003d 0) \u003d\u003e (((c.asDigit)(\u00271\u0027) \u003d 1) \u003d\u003e (((c.asDigit)(\u00272\u0027) \u003d 2) \u003d\u003e pre_((c.asDigit)\u00273\u0027)))))))))))))))","legal function application obligation:(((c.isDigit)(\u00270\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00271\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00272\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00273\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00274\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00275\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00276\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00277\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00278\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00279\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u0027a\u0027) \u003d false) \u003d\u003e (((c.asDigit)(\u00270\u0027) \u003d 0) \u003d\u003e (((c.asDigit)(\u00271\u0027) \u003d 1) \u003d\u003e (((c.asDigit)(\u00272\u0027) \u003d 2) \u003d\u003e (((c.asDigit)(\u00273\u0027) \u003d 3) \u003d\u003e pre_((c.asDigit)\u00274\u0027))))))))))))))))","legal function application obligation:(((c.isDigit)(\u00270\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00271\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00272\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00273\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00274\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00275\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00276\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00277\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00278\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00279\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u0027a\u0027) \u003d false) \u003d\u003e (((c.asDigit)(\u00270\u0027) \u003d 0) \u003d\u003e (((c.asDigit)(\u00271\u0027) \u003d 1) \u003d\u003e (((c.asDigit)(\u00272\u0027) \u003d 2) \u003d\u003e (((c.asDigit)(\u00273\u0027) \u003d 3) \u003d\u003e (((c.asDigit)(\u00274\u0027) \u003d 4) \u003d\u003e pre_((c.asDigit)\u00275\u0027)))))))))))))))))","legal function application obligation:(((c.isDigit)(\u00270\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00271\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00272\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00273\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00274\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00275\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00276\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00277\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00278\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00279\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u0027a\u0027) \u003d false) \u003d\u003e (((c.asDigit)(\u00270\u0027) \u003d 0) \u003d\u003e (((c.asDigit)(\u00271\u0027) \u003d 1) \u003d\u003e (((c.asDigit)(\u00272\u0027) \u003d 2) \u003d\u003e (((c.asDigit)(\u00273\u0027) \u003d 3) \u003d\u003e (((c.asDigit)(\u00274\u0027) \u003d 4) \u003d\u003e (((c.asDigit)(\u00275\u0027) \u003d 5) \u003d\u003e pre_((c.asDigit)\u00276\u0027))))))))))))))))))","legal function application obligation:(((c.isDigit)(\u00270\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00271\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00272\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00273\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00274\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00275\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00276\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00277\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00278\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00279\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u0027a\u0027) \u003d false) \u003d\u003e (((c.asDigit)(\u00270\u0027) \u003d 0) \u003d\u003e (((c.asDigit)(\u00271\u0027) \u003d 1) \u003d\u003e (((c.asDigit)(\u00272\u0027) \u003d 2) \u003d\u003e (((c.asDigit)(\u00273\u0027) \u003d 3) \u003d\u003e (((c.asDigit)(\u00274\u0027) \u003d 4) \u003d\u003e (((c.asDigit)(\u00275\u0027) \u003d 5) \u003d\u003e (((c.asDigit)(\u00276\u0027) \u003d 6) \u003d\u003e pre_((c.asDigit)\u00277\u0027)))))))))))))))))))","legal function application obligation:(((c.isDigit)(\u00270\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00271\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00272\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00273\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00274\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00275\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00276\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00277\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00278\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00279\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u0027a\u0027) \u003d false) \u003d\u003e (((c.asDigit)(\u00270\u0027) \u003d 0) \u003d\u003e (((c.asDigit)(\u00271\u0027) \u003d 1) \u003d\u003e (((c.asDigit)(\u00272\u0027) \u003d 2) \u003d\u003e (((c.asDigit)(\u00273\u0027) \u003d 3) \u003d\u003e (((c.asDigit)(\u00274\u0027) \u003d 4) \u003d\u003e (((c.asDigit)(\u00275\u0027) \u003d 5) \u003d\u003e (((c.asDigit)(\u00276\u0027) \u003d 6) \u003d\u003e (((c.asDigit)(\u00277\u0027) \u003d 7) \u003d\u003e pre_((c.asDigit)\u00278\u0027))))))))))))))))))))","legal function application obligation:(((c.isDigit)(\u00270\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00271\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00272\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00273\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00274\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00275\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00276\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00277\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00278\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00279\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u0027a\u0027) \u003d false) \u003d\u003e (((c.asDigit)(\u00270\u0027) \u003d 0) \u003d\u003e (((c.asDigit)(\u00271\u0027) \u003d 1) \u003d\u003e (((c.asDigit)(\u00272\u0027) \u003d 2) \u003d\u003e (((c.asDigit)(\u00273\u0027) \u003d 3) \u003d\u003e (((c.asDigit)(\u00274\u0027) \u003d 4) \u003d\u003e (((c.asDigit)(\u00275\u0027) \u003d 5) \u003d\u003e (((c.asDigit)(\u00276\u0027) \u003d 6) \u003d\u003e (((c.asDigit)(\u00277\u0027) \u003d 7) \u003d\u003e (((c.asDigit)(\u00278\u0027) \u003d 8) \u003d\u003e pre_((c.asDigit)\u00279\u0027)))))))))))))))))))))","legal function application obligation:(((c.isDigit)(\u00270\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00271\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00272\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00273\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00274\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00275\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00276\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00277\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00278\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00279\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u0027a\u0027) \u003d false) \u003d\u003e (((c.asDigit)(\u00270\u0027) \u003d 0) \u003d\u003e (((c.asDigit)(\u00271\u0027) \u003d 1) \u003d\u003e (((c.asDigit)(\u00272\u0027) \u003d 2) \u003d\u003e (((c.asDigit)(\u00273\u0027) \u003d 3) \u003d\u003e (((c.asDigit)(\u00274\u0027) \u003d 4) \u003d\u003e (((c.asDigit)(\u00275\u0027) \u003d 5) \u003d\u003e (((c.asDigit)(\u00276\u0027) \u003d 6) \u003d\u003e (((c.asDigit)(\u00277\u0027) \u003d 7) \u003d\u003e (((c.asDigit)(\u00278\u0027) \u003d 8) \u003d\u003e (((c.asDigit)(\u00279\u0027) \u003d 9) \u003d\u003e pre_((c.asDigit)\u0027a\u0027))))))))))))))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((c.asDictOrder)\u00270\u0027)","legal function application obligation:(((c.asDictOrder)(\u00270\u0027) \u003d 1) \u003d\u003e pre_((c.asDictOrder)\u00279\u0027))","legal function application obligation:(((c.asDictOrder)(\u00270\u0027) \u003d 1) \u003d\u003e (((c.asDictOrder)(\u00279\u0027) \u003d 10) \u003d\u003e pre_((c.asDictOrder)\u0027a\u0027)))","legal function application obligation:(((c.asDictOrder)(\u00270\u0027) \u003d 1) \u003d\u003e (((c.asDictOrder)(\u00279\u0027) \u003d 10) \u003d\u003e (((c.asDictOrder)(\u0027a\u0027) \u003d 11) \u003d\u003e pre_((c.asDictOrder)\u0027A\u0027))))","legal function application obligation:(((c.asDictOrder)(\u00270\u0027) \u003d 1) \u003d\u003e (((c.asDictOrder)(\u00279\u0027) \u003d 10) \u003d\u003e (((c.asDictOrder)(\u0027a\u0027) \u003d 11) \u003d\u003e (((c.asDictOrder)(\u0027A\u0027) \u003d 12) \u003d\u003e pre_((c.asDictOrder)\u0027z\u0027)))))","legal function application obligation:(((c.asDictOrder)(\u00270\u0027) \u003d 1) \u003d\u003e (((c.asDictOrder)(\u00279\u0027) \u003d 10) \u003d\u003e (((c.asDictOrder)(\u0027a\u0027) \u003d 11) \u003d\u003e (((c.asDictOrder)(\u0027A\u0027) \u003d 12) \u003d\u003e (((c.asDictOrder)(\u0027z\u0027) \u003d 61) \u003d\u003e pre_((c.asDictOrder)\u0027Z\u0027))))))","legal function application obligation:(((c.asDictOrder)(\u00270\u0027) \u003d 1) \u003d\u003e (((c.asDictOrder)(\u00279\u0027) \u003d 10) \u003d\u003e (((c.asDictOrder)(\u0027a\u0027) \u003d 11) \u003d\u003e (((c.asDictOrder)(\u0027A\u0027) \u003d 12) \u003d\u003e (((c.asDictOrder)(\u0027z\u0027) \u003d 61) \u003d\u003e (((c.asDictOrder)(\u0027Z\u0027) \u003d 62) \u003d\u003e pre_((c.asDictOrder)\u0027\n\u0027)))))))","legal function application obligation:(((c.asDictOrder)(\u00270\u0027) \u003d 1) \u003d\u003e (((c.asDictOrder)(\u00279\u0027) \u003d 10) \u003d\u003e (((c.asDictOrder)(\u0027a\u0027) \u003d 11) \u003d\u003e (((c.asDictOrder)(\u0027A\u0027) \u003d 12) \u003d\u003e (((c.asDictOrder)(\u0027z\u0027) \u003d 61) \u003d\u003e (((c.asDictOrder)(\u0027Z\u0027) \u003d 62) \u003d\u003e (((c.asDictOrder)(\u0027\n\u0027) \u003d 999999) \u003d\u003e pre_((c.asDictOrder)\u0027\t\u0027))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((s.LT)\"123\", \"123\")","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e pre_(LT(\"123\")\"123\"))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e pre_(LT\"123\"))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e pre_((s.GT)\"123\", \"123\")))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e pre_(GT(\"123\")\"123\"))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e pre_(GT\"123\"))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e pre_((s.LT)\"\", \"\")))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e pre_((s.GT)\"\", \"\"))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e pre_((s.LT)\"\", \"123\")))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e pre_((s.GT)\"\", \"123\"))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e pre_((s.LT)\"123\", \"\")))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e pre_((s.GT)\"123\", \"\"))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e pre_((s.LT)\"123\", \"1234\")))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e pre_((s.GT)\"123\", \"1234\"))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e pre_((s.LT)\"1234\", \"123\")))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e pre_((s.GT)\"1234\", \"123\"))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e pre_((s.LT)\"123\", \"223\")))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e pre_((s.GT)\"123\", \"223\"))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e pre_((s.LE)\"123\", \"123\")))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e pre_(LE(\"123\")\"123\"))))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e pre_(LE\"123\"))))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e (LE(\"123\")(\"123\") \u003d\u003e pre_((s.GE)\"123\", \"123\")))))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e (LE(\"123\")(\"123\") \u003d\u003e ((s.GE)(\"123\", \"123\") \u003d\u003e pre_((s.LE)\"123\", \"1234\"))))))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e (LE(\"123\")(\"123\") \u003d\u003e ((s.GE)(\"123\", \"123\") \u003d\u003e ((s.LE)(\"123\", \"1234\") \u003d\u003e pre_(LE(\"123\")\"1234\")))))))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e (LE(\"123\")(\"123\") \u003d\u003e ((s.GE)(\"123\", \"123\") \u003d\u003e ((s.LE)(\"123\", \"1234\") \u003d\u003e pre_(LE\"123\")))))))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e (LE(\"123\")(\"123\") \u003d\u003e ((s.GE)(\"123\", \"123\") \u003d\u003e ((s.LE)(\"123\", \"1234\") \u003d\u003e (LE(\"123\")(\"1234\") \u003d\u003e pre_((s.GE)\"123\", \"1234\"))))))))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e (LE(\"123\")(\"123\") \u003d\u003e ((s.GE)(\"123\", \"123\") \u003d\u003e ((s.LE)(\"123\", \"1234\") \u003d\u003e (LE(\"123\")(\"1234\") \u003d\u003e (((s.GE)(\"123\", \"1234\") \u003d false) \u003d\u003e pre_(GE(\"123\")\"1234\")))))))))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e (LE(\"123\")(\"123\") \u003d\u003e ((s.GE)(\"123\", \"123\") \u003d\u003e ((s.LE)(\"123\", \"1234\") \u003d\u003e (LE(\"123\")(\"1234\") \u003d\u003e (((s.GE)(\"123\", \"1234\") \u003d false) \u003d\u003e pre_(GE\"123\")))))))))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e (LE(\"123\")(\"123\") \u003d\u003e ((s.GE)(\"123\", \"123\") \u003d\u003e ((s.LE)(\"123\", \"1234\") \u003d\u003e (LE(\"123\")(\"1234\") \u003d\u003e (((s.GE)(\"123\", \"1234\") \u003d false) \u003d\u003e ((GE(\"123\")(\"1234\") \u003d false) \u003d\u003e pre_((s.LE)\"1234\", \"123\"))))))))))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e (LE(\"123\")(\"123\") \u003d\u003e ((s.GE)(\"123\", \"123\") \u003d\u003e ((s.LE)(\"123\", \"1234\") \u003d\u003e (LE(\"123\")(\"1234\") \u003d\u003e (((s.GE)(\"123\", \"1234\") \u003d false) \u003d\u003e ((GE(\"123\")(\"1234\") \u003d false) \u003d\u003e (((s.LE)(\"1234\", \"123\") \u003d false) \u003d\u003e pre_(LE(\"1234\")\"123\")))))))))))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e (LE(\"123\")(\"123\") \u003d\u003e ((s.GE)(\"123\", \"123\") \u003d\u003e ((s.LE)(\"123\", \"1234\") \u003d\u003e (LE(\"123\")(\"1234\") \u003d\u003e (((s.GE)(\"123\", \"1234\") \u003d false) \u003d\u003e ((GE(\"123\")(\"1234\") \u003d false) \u003d\u003e (((s.LE)(\"1234\", \"123\") \u003d false) \u003d\u003e pre_(LE\"1234\")))))))))))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e (LE(\"123\")(\"123\") \u003d\u003e ((s.GE)(\"123\", \"123\") \u003d\u003e ((s.LE)(\"123\", \"1234\") \u003d\u003e (LE(\"123\")(\"1234\") \u003d\u003e (((s.GE)(\"123\", \"1234\") \u003d false) \u003d\u003e ((GE(\"123\")(\"1234\") \u003d false) \u003d\u003e (((s.LE)(\"1234\", \"123\") \u003d false) \u003d\u003e ((not LE(\"1234\")(\"123\")) \u003d\u003e pre_((s.GE)\"1234\", \"123\"))))))))))))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e (LE(\"123\")(\"123\") \u003d\u003e ((s.GE)(\"123\", \"123\") \u003d\u003e ((s.LE)(\"123\", \"1234\") \u003d\u003e (LE(\"123\")(\"1234\") \u003d\u003e (((s.GE)(\"123\", \"1234\") \u003d false) \u003d\u003e ((GE(\"123\")(\"1234\") \u003d false) \u003d\u003e (((s.LE)(\"1234\", \"123\") \u003d false) \u003d\u003e ((not LE(\"1234\")(\"123\")) \u003d\u003e ((s.GE)(\"1234\", \"123\") \u003d\u003e pre_((s.LE)\"\", \"\")))))))))))))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e (LE(\"123\")(\"123\") \u003d\u003e ((s.GE)(\"123\", \"123\") \u003d\u003e ((s.LE)(\"123\", \"1234\") \u003d\u003e (LE(\"123\")(\"1234\") \u003d\u003e (((s.GE)(\"123\", \"1234\") \u003d false) \u003d\u003e ((GE(\"123\")(\"1234\") \u003d false) \u003d\u003e (((s.LE)(\"1234\", \"123\") \u003d false) \u003d\u003e ((not LE(\"1234\")(\"123\")) \u003d\u003e ((s.GE)(\"1234\", \"123\") \u003d\u003e ((s.LE)(\"\", \"\") \u003d\u003e pre_(LE(\"\")\"\"))))))))))))))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e (LE(\"123\")(\"123\") \u003d\u003e ((s.GE)(\"123\", \"123\") \u003d\u003e ((s.LE)(\"123\", \"1234\") \u003d\u003e (LE(\"123\")(\"1234\") \u003d\u003e (((s.GE)(\"123\", \"1234\") \u003d false) \u003d\u003e ((GE(\"123\")(\"1234\") \u003d false) \u003d\u003e (((s.LE)(\"1234\", \"123\") \u003d false) \u003d\u003e ((not LE(\"1234\")(\"123\")) \u003d\u003e ((s.GE)(\"1234\", \"123\") \u003d\u003e ((s.LE)(\"\", \"\") \u003d\u003e pre_(LE\"\"))))))))))))))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e (LE(\"123\")(\"123\") \u003d\u003e ((s.GE)(\"123\", \"123\") \u003d\u003e ((s.LE)(\"123\", \"1234\") \u003d\u003e (LE(\"123\")(\"1234\") \u003d\u003e (((s.GE)(\"123\", \"1234\") \u003d false) \u003d\u003e ((GE(\"123\")(\"1234\") \u003d false) \u003d\u003e (((s.LE)(\"1234\", \"123\") \u003d false) \u003d\u003e ((not LE(\"1234\")(\"123\")) \u003d\u003e ((s.GE)(\"1234\", \"123\") \u003d\u003e ((s.LE)(\"\", \"\") \u003d\u003e (LE(\"\")(\"\") \u003d\u003e pre_((Sequence`fmap)[seq of (char), bool](LT(\"123\"))[\"123\", \"1234\", \"\", \"223\"])))))))))))))))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e (LE(\"123\")(\"123\") \u003d\u003e ((s.GE)(\"123\", \"123\") \u003d\u003e ((s.LE)(\"123\", \"1234\") \u003d\u003e (LE(\"123\")(\"1234\") \u003d\u003e (((s.GE)(\"123\", \"1234\") \u003d false) \u003d\u003e ((GE(\"123\")(\"1234\") \u003d false) \u003d\u003e (((s.LE)(\"1234\", \"123\") \u003d false) \u003d\u003e ((not LE(\"1234\")(\"123\")) \u003d\u003e ((s.GE)(\"1234\", \"123\") \u003d\u003e ((s.LE)(\"\", \"\") \u003d\u003e (LE(\"\")(\"\") \u003d\u003e pre_(LT\"123\")))))))))))))))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e (LE(\"123\")(\"123\") \u003d\u003e ((s.GE)(\"123\", \"123\") \u003d\u003e ((s.LE)(\"123\", \"1234\") \u003d\u003e (LE(\"123\")(\"1234\") \u003d\u003e (((s.GE)(\"123\", \"1234\") \u003d false) \u003d\u003e ((GE(\"123\")(\"1234\") \u003d false) \u003d\u003e (((s.LE)(\"1234\", \"123\") \u003d false) \u003d\u003e ((not LE(\"1234\")(\"123\")) \u003d\u003e ((s.GE)(\"1234\", \"123\") \u003d\u003e ((s.LE)(\"\", \"\") \u003d\u003e (LE(\"\")(\"\") \u003d\u003e (((Sequence`fmap)[seq of (char), bool](LT(\"123\"))([\"123\", \"1234\", \"\", \"223\"]) \u003d [false, true, false, true]) \u003d\u003e pre_((Sequence`fmap)[seq of (char), bool](LE(\"123\"))[\"1234\", \"\"]))))))))))))))))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e (LE(\"123\")(\"123\") \u003d\u003e ((s.GE)(\"123\", \"123\") \u003d\u003e ((s.LE)(\"123\", \"1234\") \u003d\u003e (LE(\"123\")(\"1234\") \u003d\u003e (((s.GE)(\"123\", \"1234\") \u003d false) \u003d\u003e ((GE(\"123\")(\"1234\") \u003d false) \u003d\u003e (((s.LE)(\"1234\", \"123\") \u003d false) \u003d\u003e ((not LE(\"1234\")(\"123\")) \u003d\u003e ((s.GE)(\"1234\", \"123\") \u003d\u003e ((s.LE)(\"\", \"\") \u003d\u003e (LE(\"\")(\"\") \u003d\u003e (((Sequence`fmap)[seq of (char), bool](LT(\"123\"))([\"123\", \"1234\", \"\", \"223\"]) \u003d [false, true, false, true]) \u003d\u003e pre_(LE\"123\"))))))))))))))))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e (LE(\"123\")(\"123\") \u003d\u003e ((s.GE)(\"123\", \"123\") \u003d\u003e ((s.LE)(\"123\", \"1234\") \u003d\u003e (LE(\"123\")(\"1234\") \u003d\u003e (((s.GE)(\"123\", \"1234\") \u003d false) \u003d\u003e ((GE(\"123\")(\"1234\") \u003d false) \u003d\u003e (((s.LE)(\"1234\", \"123\") \u003d false) \u003d\u003e ((not LE(\"1234\")(\"123\")) \u003d\u003e ((s.GE)(\"1234\", \"123\") \u003d\u003e ((s.LE)(\"\", \"\") \u003d\u003e (LE(\"\")(\"\") \u003d\u003e (((Sequence`fmap)[seq of (char), bool](LT(\"123\"))([\"123\", \"1234\", \"\", \"223\"]) \u003d [false, true, false, true]) \u003d\u003e (((Sequence`fmap)[seq of (char), bool](LE(\"123\"))([\"1234\", \"\"]) \u003d [true, false]) \u003d\u003e pre_((Sequence`fmap)[seq of (char), bool](GT(\"123\"))[\"123\", \"\", \"23\"])))))))))))))))))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e (LE(\"123\")(\"123\") \u003d\u003e ((s.GE)(\"123\", \"123\") \u003d\u003e ((s.LE)(\"123\", \"1234\") \u003d\u003e (LE(\"123\")(\"1234\") \u003d\u003e (((s.GE)(\"123\", \"1234\") \u003d false) \u003d\u003e ((GE(\"123\")(\"1234\") \u003d false) \u003d\u003e (((s.LE)(\"1234\", \"123\") \u003d false) \u003d\u003e ((not LE(\"1234\")(\"123\")) \u003d\u003e ((s.GE)(\"1234\", \"123\") \u003d\u003e ((s.LE)(\"\", \"\") \u003d\u003e (LE(\"\")(\"\") \u003d\u003e (((Sequence`fmap)[seq of (char), bool](LT(\"123\"))([\"123\", \"1234\", \"\", \"223\"]) \u003d [false, true, false, true]) \u003d\u003e (((Sequence`fmap)[seq of (char), bool](LE(\"123\"))([\"1234\", \"\"]) \u003d [true, false]) \u003d\u003e pre_(GT\"123\")))))))))))))))))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e (LE(\"123\")(\"123\") \u003d\u003e ((s.GE)(\"123\", \"123\") \u003d\u003e ((s.LE)(\"123\", \"1234\") \u003d\u003e (LE(\"123\")(\"1234\") \u003d\u003e (((s.GE)(\"123\", \"1234\") \u003d false) \u003d\u003e ((GE(\"123\")(\"1234\") \u003d false) \u003d\u003e (((s.LE)(\"1234\", \"123\") \u003d false) \u003d\u003e ((not LE(\"1234\")(\"123\")) \u003d\u003e ((s.GE)(\"1234\", \"123\") \u003d\u003e ((s.LE)(\"\", \"\") \u003d\u003e (LE(\"\")(\"\") \u003d\u003e (((Sequence`fmap)[seq of (char), bool](LT(\"123\"))([\"123\", \"1234\", \"\", \"223\"]) \u003d [false, true, false, true]) \u003d\u003e (((Sequence`fmap)[seq of (char), bool](LE(\"123\"))([\"1234\", \"\"]) \u003d [true, false]) \u003d\u003e (((Sequence`fmap)[seq of (char), bool](GT(\"123\"))([\"123\", \"\", \"23\"]) \u003d [false, true, false]) \u003d\u003e pre_((Sequence`fmap)[seq of (char), bool](GE(\"123\"))[\"1234\", \"\"]))))))))))))))))))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e (LE(\"123\")(\"123\") \u003d\u003e ((s.GE)(\"123\", \"123\") \u003d\u003e ((s.LE)(\"123\", \"1234\") \u003d\u003e (LE(\"123\")(\"1234\") \u003d\u003e (((s.GE)(\"123\", \"1234\") \u003d false) \u003d\u003e ((GE(\"123\")(\"1234\") \u003d false) \u003d\u003e (((s.LE)(\"1234\", \"123\") \u003d false) \u003d\u003e ((not LE(\"1234\")(\"123\")) \u003d\u003e ((s.GE)(\"1234\", \"123\") \u003d\u003e ((s.LE)(\"\", \"\") \u003d\u003e (LE(\"\")(\"\") \u003d\u003e (((Sequence`fmap)[seq of (char), bool](LT(\"123\"))([\"123\", \"1234\", \"\", \"223\"]) \u003d [false, true, false, true]) \u003d\u003e (((Sequence`fmap)[seq of (char), bool](LE(\"123\"))([\"1234\", \"\"]) \u003d [true, false]) \u003d\u003e (((Sequence`fmap)[seq of (char), bool](GT(\"123\"))([\"123\", \"\", \"23\"]) \u003d [false, true, false]) \u003d\u003e pre_(GE\"123\"))))))))))))))))))))))))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:((s1234 \u003d \"1234\") \u003d\u003e pre_((s.isSpaces)\"\"))","legal function application obligation:((s1234 \u003d \"1234\") \u003d\u003e (((s.isSpaces)(\"\") \u003d true) \u003d\u003e pre_((s.isSpaces)\" \")))","legal function application obligation:((s1234 \u003d \"1234\") \u003d\u003e (((s.isSpaces)(\"\") \u003d true) \u003d\u003e (((s.isSpaces)(\" \") \u003d true) \u003d\u003e pre_((s.isSpaces)\" \t \"))))","legal function application obligation:((s1234 \u003d \"1234\") \u003d\u003e (((s.isSpaces)(\"\") \u003d true) \u003d\u003e (((s.isSpaces)(\" \") \u003d true) \u003d\u003e (((s.isSpaces)(\" \t \") \u003d true) \u003d\u003e pre_((s.isSpaces)[])))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(LT\u0027a\u0027, \u0027a\u0027)","legal function application obligation:((LT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e pre_(Character`LT2(\u0027a\u0027)\u0027a\u0027))","legal function application obligation:((LT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`LT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e pre_(GT\u0027a\u0027, \u0027a\u0027)))","legal function application obligation:((LT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`LT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e ((GT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e pre_(Character`GT2(\u0027a\u0027)\u0027a\u0027))))","legal function application obligation:((LT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`LT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e ((GT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`GT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e pre_(LT\u00271\u0027, \u00272\u0027)))))","legal function application obligation:((LT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`LT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e ((GT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`GT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e (LT(\u00271\u0027, \u00272\u0027) \u003d\u003e pre_(Character`LT2(\u00271\u0027)\u00272\u0027))))))","legal function application obligation:((LT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`LT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e ((GT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`GT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e (LT(\u00271\u0027, \u00272\u0027) \u003d\u003e (Character`LT2(\u00271\u0027)(\u00272\u0027) \u003d\u003e pre_(GT\u00271\u0027, \u00270\u0027)))))))","legal function application obligation:((LT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`LT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e ((GT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`GT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e (LT(\u00271\u0027, \u00272\u0027) \u003d\u003e (Character`LT2(\u00271\u0027)(\u00272\u0027) \u003d\u003e (GT(\u00271\u0027, \u00270\u0027) \u003d\u003e pre_(Character`GT2(\u00271\u0027)\u00270\u0027))))))))","legal function application obligation:((LT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`LT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e ((GT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`GT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e (LT(\u00271\u0027, \u00272\u0027) \u003d\u003e (Character`LT2(\u00271\u0027)(\u00272\u0027) \u003d\u003e (GT(\u00271\u0027, \u00270\u0027) \u003d\u003e (Character`GT2(\u00271\u0027)(\u00270\u0027) \u003d\u003e pre_(LT\u00279\u0027, \u0027a\u0027)))))))))","legal function application obligation:((LT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`LT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e ((GT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`GT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e (LT(\u00271\u0027, \u00272\u0027) \u003d\u003e (Character`LT2(\u00271\u0027)(\u00272\u0027) \u003d\u003e (GT(\u00271\u0027, \u00270\u0027) \u003d\u003e (Character`GT2(\u00271\u0027)(\u00270\u0027) \u003d\u003e (LT(\u00279\u0027, \u0027a\u0027) \u003d\u003e pre_(Character`LT2(\u00279\u0027)\u0027a\u0027))))))))))","legal function application obligation:((LT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`LT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e ((GT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`GT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e (LT(\u00271\u0027, \u00272\u0027) \u003d\u003e (Character`LT2(\u00271\u0027)(\u00272\u0027) \u003d\u003e (GT(\u00271\u0027, \u00270\u0027) \u003d\u003e (Character`GT2(\u00271\u0027)(\u00270\u0027) \u003d\u003e (LT(\u00279\u0027, \u0027a\u0027) \u003d\u003e (Character`LT2(\u00279\u0027)(\u0027a\u0027) \u003d\u003e pre_(GT\u0027\n\u0027, \u00270\u0027)))))))))))","legal function application obligation:((LT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`LT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e ((GT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`GT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e (LT(\u00271\u0027, \u00272\u0027) \u003d\u003e (Character`LT2(\u00271\u0027)(\u00272\u0027) \u003d\u003e (GT(\u00271\u0027, \u00270\u0027) \u003d\u003e (Character`GT2(\u00271\u0027)(\u00270\u0027) \u003d\u003e (LT(\u00279\u0027, \u0027a\u0027) \u003d\u003e (Character`LT2(\u00279\u0027)(\u0027a\u0027) \u003d\u003e (GT(\u0027\n\u0027, \u00270\u0027) \u003d\u003e pre_(Character`GT2(\u0027\n\u0027)\u00270\u0027))))))))))))","legal function application obligation:((LT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`LT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e ((GT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`GT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e (LT(\u00271\u0027, \u00272\u0027) \u003d\u003e (Character`LT2(\u00271\u0027)(\u00272\u0027) \u003d\u003e (GT(\u00271\u0027, \u00270\u0027) \u003d\u003e (Character`GT2(\u00271\u0027)(\u00270\u0027) \u003d\u003e (LT(\u00279\u0027, \u0027a\u0027) \u003d\u003e (Character`LT2(\u00279\u0027)(\u0027a\u0027) \u003d\u003e (GT(\u0027\n\u0027, \u00270\u0027) \u003d\u003e (Character`GT2(\u0027\n\u0027)(\u00270\u0027) \u003d\u003e pre_(LE\u0027a\u0027, \u00270\u0027)))))))))))))","legal function application obligation:((LT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`LT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e ((GT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`GT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e (LT(\u00271\u0027, \u00272\u0027) \u003d\u003e (Character`LT2(\u00271\u0027)(\u00272\u0027) \u003d\u003e (GT(\u00271\u0027, \u00270\u0027) \u003d\u003e (Character`GT2(\u00271\u0027)(\u00270\u0027) \u003d\u003e (LT(\u00279\u0027, \u0027a\u0027) \u003d\u003e (Character`LT2(\u00279\u0027)(\u0027a\u0027) \u003d\u003e (GT(\u0027\n\u0027, \u00270\u0027) \u003d\u003e (Character`GT2(\u0027\n\u0027)(\u00270\u0027) \u003d\u003e ((LE(\u0027a\u0027, \u00270\u0027) \u003d false) \u003d\u003e pre_(Character`LE2(\u0027a\u0027)\u00270\u0027))))))))))))))","legal function application obligation:((LT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`LT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e ((GT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`GT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e (LT(\u00271\u0027, \u00272\u0027) \u003d\u003e (Character`LT2(\u00271\u0027)(\u00272\u0027) \u003d\u003e (GT(\u00271\u0027, \u00270\u0027) \u003d\u003e (Character`GT2(\u00271\u0027)(\u00270\u0027) \u003d\u003e (LT(\u00279\u0027, \u0027a\u0027) \u003d\u003e (Character`LT2(\u00279\u0027)(\u0027a\u0027) \u003d\u003e (GT(\u0027\n\u0027, \u00270\u0027) \u003d\u003e (Character`GT2(\u0027\n\u0027)(\u00270\u0027) \u003d\u003e ((LE(\u0027a\u0027, \u00270\u0027) \u003d false) \u003d\u003e ((Character`LE2(\u0027a\u0027)(\u00270\u0027) \u003d false) \u003d\u003e pre_(GE\u0027a\u0027, \u00270\u0027)))))))))))))))","legal function application obligation:((LT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`LT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e ((GT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`GT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e (LT(\u00271\u0027, \u00272\u0027) \u003d\u003e (Character`LT2(\u00271\u0027)(\u00272\u0027) \u003d\u003e (GT(\u00271\u0027, \u00270\u0027) \u003d\u003e (Character`GT2(\u00271\u0027)(\u00270\u0027) \u003d\u003e (LT(\u00279\u0027, \u0027a\u0027) \u003d\u003e (Character`LT2(\u00279\u0027)(\u0027a\u0027) \u003d\u003e (GT(\u0027\n\u0027, \u00270\u0027) \u003d\u003e (Character`GT2(\u0027\n\u0027)(\u00270\u0027) \u003d\u003e ((LE(\u0027a\u0027, \u00270\u0027) \u003d false) \u003d\u003e ((Character`LE2(\u0027a\u0027)(\u00270\u0027) \u003d false) \u003d\u003e (GE(\u0027a\u0027, \u00270\u0027) \u003d\u003e pre_(Character`GE2(\u0027a\u0027)\u00270\u0027))))))))))))))))","legal function application obligation:((LT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`LT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e ((GT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`GT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e (LT(\u00271\u0027, \u00272\u0027) \u003d\u003e (Character`LT2(\u00271\u0027)(\u00272\u0027) \u003d\u003e (GT(\u00271\u0027, \u00270\u0027) \u003d\u003e (Character`GT2(\u00271\u0027)(\u00270\u0027) \u003d\u003e (LT(\u00279\u0027, \u0027a\u0027) \u003d\u003e (Character`LT2(\u00279\u0027)(\u0027a\u0027) \u003d\u003e (GT(\u0027\n\u0027, \u00270\u0027) \u003d\u003e (Character`GT2(\u0027\n\u0027)(\u00270\u0027) \u003d\u003e ((LE(\u0027a\u0027, \u00270\u0027) \u003d false) \u003d\u003e ((Character`LE2(\u0027a\u0027)(\u00270\u0027) \u003d false) \u003d\u003e (GE(\u0027a\u0027, \u00270\u0027) \u003d\u003e (Character`GE2(\u0027a\u0027)(\u00270\u0027) \u003d\u003e pre_((Sequence`fmap)[char, bool](Character`LT2(\u00275\u0027))\"456\")))))))))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((s.subStr)\"Shin Sahara\", 6, 6)","legal function application obligation:(((s.subStr)(\"Shin Sahara\", 6, 6) \u003d \"Sahara\") \u003d\u003e pre_((s.subStr)\"Shin Sahara\", 6, 8))","legal function application obligation:(((s.subStr)(\"Shin Sahara\", 6, 6) \u003d \"Sahara\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 6, 8) \u003d \"Sahara\") \u003d\u003e pre_((s.subStr)\"Shin Sahara\", 6, 3)))","legal function application obligation:(((s.subStr)(\"Shin Sahara\", 6, 6) \u003d \"Sahara\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 6, 8) \u003d \"Sahara\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 6, 3) \u003d \"Sah\") \u003d\u003e pre_((s.subStr)\"Shin Sahara\", 1, 0))))","legal function application obligation:(((s.subStr)(\"Shin Sahara\", 6, 6) \u003d \"Sahara\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 6, 8) \u003d \"Sahara\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 6, 3) \u003d \"Sah\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 1, 0) \u003d \"\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 3, \u0027*\u0027) \u003d \"sah\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 6, \u0027*\u0027) \u003d \"sahara\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 10, \u0027*\u0027) \u003d \"sahara****\") \u003d\u003e (((s.subStrFill)(\"sahara\", 3, 4, \u0027*\u0027) \u003d \"hara\") \u003d\u003e (((s.subStrFill)(\"sahara\", 3, 10, \u0027*\u0027) \u003d \"hara******\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 0, \u0027*\u0027) \u003d \"\") \u003d\u003e (((s.subStrFill)(\"\", 1, 6, \u0027*\u0027) \u003d \"******\") \u003d\u003e pre_(String`SubStr(6)(6)\"Shin Sahara\"))))))))))))","legal function application obligation:(((s.subStr)(\"Shin Sahara\", 6, 6) \u003d \"Sahara\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 6, 8) \u003d \"Sahara\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 6, 3) \u003d \"Sah\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 1, 0) \u003d \"\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 3, \u0027*\u0027) \u003d \"sah\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 6, \u0027*\u0027) \u003d \"sahara\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 10, \u0027*\u0027) \u003d \"sahara****\") \u003d\u003e (((s.subStrFill)(\"sahara\", 3, 4, \u0027*\u0027) \u003d \"hara\") \u003d\u003e (((s.subStrFill)(\"sahara\", 3, 10, \u0027*\u0027) \u003d \"hara******\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 0, \u0027*\u0027) \u003d \"\") \u003d\u003e (((s.subStrFill)(\"\", 1, 6, \u0027*\u0027) \u003d \"******\") \u003d\u003e pre_(String`SubStr(6)6))))))))))))","legal function application obligation:(((s.subStr)(\"Shin Sahara\", 6, 6) \u003d \"Sahara\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 6, 8) \u003d \"Sahara\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 6, 3) \u003d \"Sah\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 1, 0) \u003d \"\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 3, \u0027*\u0027) \u003d \"sah\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 6, \u0027*\u0027) \u003d \"sahara\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 10, \u0027*\u0027) \u003d \"sahara****\") \u003d\u003e (((s.subStrFill)(\"sahara\", 3, 4, \u0027*\u0027) \u003d \"hara\") \u003d\u003e (((s.subStrFill)(\"sahara\", 3, 10, \u0027*\u0027) \u003d \"hara******\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 0, \u0027*\u0027) \u003d \"\") \u003d\u003e (((s.subStrFill)(\"\", 1, 6, \u0027*\u0027) \u003d \"******\") \u003d\u003e ((String`SubStr(6)(6)(\"Shin Sahara\") \u003d \"Sahara\") \u003d\u003e pre_(substr(6)(8)\"Shin Sahara\")))))))))))))","legal function application obligation:(((s.subStr)(\"Shin Sahara\", 6, 6) \u003d \"Sahara\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 6, 8) \u003d \"Sahara\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 6, 3) \u003d \"Sah\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 1, 0) \u003d \"\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 3, \u0027*\u0027) \u003d \"sah\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 6, \u0027*\u0027) \u003d \"sahara\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 10, \u0027*\u0027) \u003d \"sahara****\") \u003d\u003e (((s.subStrFill)(\"sahara\", 3, 4, \u0027*\u0027) \u003d \"hara\") \u003d\u003e (((s.subStrFill)(\"sahara\", 3, 10, \u0027*\u0027) \u003d \"hara******\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 0, \u0027*\u0027) \u003d \"\") \u003d\u003e (((s.subStrFill)(\"\", 1, 6, \u0027*\u0027) \u003d \"******\") \u003d\u003e ((String`SubStr(6)(6)(\"Shin Sahara\") \u003d \"Sahara\") \u003d\u003e pre_(substr(6)8)))))))))))))","legal function application obligation:(((s.subStr)(\"Shin Sahara\", 6, 6) \u003d \"Sahara\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 6, 8) \u003d \"Sahara\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 6, 3) \u003d \"Sah\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 1, 0) \u003d \"\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 3, \u0027*\u0027) \u003d \"sah\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 6, \u0027*\u0027) \u003d \"sahara\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 10, \u0027*\u0027) \u003d \"sahara****\") \u003d\u003e (((s.subStrFill)(\"sahara\", 3, 4, \u0027*\u0027) \u003d \"hara\") \u003d\u003e (((s.subStrFill)(\"sahara\", 3, 10, \u0027*\u0027) \u003d \"hara******\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 0, \u0027*\u0027) \u003d \"\") \u003d\u003e (((s.subStrFill)(\"\", 1, 6, \u0027*\u0027) \u003d \"******\") \u003d\u003e ((String`SubStr(6)(6)(\"Shin Sahara\") \u003d \"Sahara\") \u003d\u003e pre_(substr6)))))))))))))","legal function application obligation:(((s.subStr)(\"Shin Sahara\", 6, 6) \u003d \"Sahara\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 6, 8) \u003d \"Sahara\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 6, 3) \u003d \"Sah\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 1, 0) \u003d \"\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 3, \u0027*\u0027) \u003d \"sah\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 6, \u0027*\u0027) \u003d \"sahara\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 10, \u0027*\u0027) \u003d \"sahara****\") \u003d\u003e (((s.subStrFill)(\"sahara\", 3, 4, \u0027*\u0027) \u003d \"hara\") \u003d\u003e (((s.subStrFill)(\"sahara\", 3, 10, \u0027*\u0027) \u003d \"hara******\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 0, \u0027*\u0027) \u003d \"\") \u003d\u003e (((s.subStrFill)(\"\", 1, 6, \u0027*\u0027) \u003d \"******\") \u003d\u003e ((String`SubStr(6)(6)(\"Shin Sahara\") \u003d \"Sahara\") \u003d\u003e ((substr(6)(8)(\"Shin Sahara\") \u003d \"Sahara\") \u003d\u003e pre_((Sequence`fmap)[seq of (char), seq of (char)](substr(6)(8))[\"1234567890\", \"12345671\"]))))))))))))))","legal function application obligation:(((s.subStr)(\"Shin Sahara\", 6, 6) \u003d \"Sahara\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 6, 8) \u003d \"Sahara\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 6, 3) \u003d \"Sah\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 1, 0) \u003d \"\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 3, \u0027*\u0027) \u003d \"sah\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 6, \u0027*\u0027) \u003d \"sahara\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 10, \u0027*\u0027) \u003d \"sahara****\") \u003d\u003e (((s.subStrFill)(\"sahara\", 3, 4, \u0027*\u0027) \u003d \"hara\") \u003d\u003e (((s.subStrFill)(\"sahara\", 3, 10, \u0027*\u0027) \u003d \"hara******\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 0, \u0027*\u0027) \u003d \"\") \u003d\u003e (((s.subStrFill)(\"\", 1, 6, \u0027*\u0027) \u003d \"******\") \u003d\u003e ((String`SubStr(6)(6)(\"Shin Sahara\") \u003d \"Sahara\") \u003d\u003e ((substr(6)(8)(\"Shin Sahara\") \u003d \"Sahara\") \u003d\u003e pre_(substr(6)8))))))))))))))","legal function application obligation:(((s.subStr)(\"Shin Sahara\", 6, 6) \u003d \"Sahara\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 6, 8) \u003d \"Sahara\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 6, 3) \u003d \"Sah\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 1, 0) \u003d \"\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 3, \u0027*\u0027) \u003d \"sah\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 6, \u0027*\u0027) \u003d \"sahara\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 10, \u0027*\u0027) \u003d \"sahara****\") \u003d\u003e (((s.subStrFill)(\"sahara\", 3, 4, \u0027*\u0027) \u003d \"hara\") \u003d\u003e (((s.subStrFill)(\"sahara\", 3, 10, \u0027*\u0027) \u003d \"hara******\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 0, \u0027*\u0027) \u003d \"\") \u003d\u003e (((s.subStrFill)(\"\", 1, 6, \u0027*\u0027) \u003d \"******\") \u003d\u003e ((String`SubStr(6)(6)(\"Shin Sahara\") \u003d \"Sahara\") \u003d\u003e ((substr(6)(8)(\"Shin Sahara\") \u003d \"Sahara\") \u003d\u003e pre_(substr6))))))))))))))","type compatibility obligation:is_(RESULT, ())","type compatibility obligation:is_(RESULT, ())","legal function application obligation:((String`index(\"1234567890\", \u00271\u0027) \u003d 1) \u003d\u003e ((String`index(\"1234567890\", \u00270\u0027) \u003d 10) \u003d\u003e ((String`index(\"1234567890\", \u0027a\u0027) \u003d 0) \u003d\u003e ((String`indexAll(\"1234567890\", \u00271\u0027) \u003d {1}) \u003d\u003e ((String`indexAll(\"1234567890\", \u00270\u0027) \u003d {10}) \u003d\u003e ((String`indexAll(\"1234567890\", \u0027a\u0027) \u003d {}) \u003d\u003e ((String`indexAll(\"1231567190\", \u00271\u0027) \u003d {1, 4, 8}) \u003d\u003e ((String`indexAll(\"1231567191\", \u00271\u0027) \u003d {1, 4, 8, 10}) \u003d\u003e pre_(String`Index(\u00271\u0027)\"1234567890\")))))))))","legal function application obligation:((String`index(\"1234567890\", \u00271\u0027) \u003d 1) \u003d\u003e ((String`index(\"1234567890\", \u00270\u0027) \u003d 10) \u003d\u003e ((String`index(\"1234567890\", \u0027a\u0027) \u003d 0) \u003d\u003e ((String`indexAll(\"1234567890\", \u00271\u0027) \u003d {1}) \u003d\u003e ((String`indexAll(\"1234567890\", \u00270\u0027) \u003d {10}) \u003d\u003e ((String`indexAll(\"1234567890\", \u0027a\u0027) \u003d {}) \u003d\u003e ((String`indexAll(\"1231567190\", \u00271\u0027) \u003d {1, 4, 8}) \u003d\u003e ((String`indexAll(\"1231567191\", \u00271\u0027) \u003d {1, 4, 8, 10}) \u003d\u003e ((String`Index(\u00271\u0027)(\"1234567890\") \u003d 1) \u003d\u003e pre_(String`Index(\u00270\u0027)\"1234567890\"))))))))))","legal function application obligation:((String`index(\"1234567890\", \u00271\u0027) \u003d 1) \u003d\u003e ((String`index(\"1234567890\", \u00270\u0027) \u003d 10) \u003d\u003e ((String`index(\"1234567890\", \u0027a\u0027) \u003d 0) \u003d\u003e ((String`indexAll(\"1234567890\", \u00271\u0027) \u003d {1}) \u003d\u003e ((String`indexAll(\"1234567890\", \u00270\u0027) \u003d {10}) \u003d\u003e ((String`indexAll(\"1234567890\", \u0027a\u0027) \u003d {}) \u003d\u003e ((String`indexAll(\"1231567190\", \u00271\u0027) \u003d {1, 4, 8}) \u003d\u003e ((String`indexAll(\"1231567191\", \u00271\u0027) \u003d {1, 4, 8, 10}) \u003d\u003e ((String`Index(\u00271\u0027)(\"1234567890\") \u003d 1) \u003d\u003e ((String`Index(\u00270\u0027)(\"1234567890\") \u003d 10) \u003d\u003e pre_(String`Index(\u0027a\u0027)\"1234567890\")))))))))))","legal function application obligation:((String`index(\"1234567890\", \u00271\u0027) \u003d 1) \u003d\u003e ((String`index(\"1234567890\", \u00270\u0027) \u003d 10) \u003d\u003e ((String`index(\"1234567890\", \u0027a\u0027) \u003d 0) \u003d\u003e ((String`indexAll(\"1234567890\", \u00271\u0027) \u003d {1}) \u003d\u003e ((String`indexAll(\"1234567890\", \u00270\u0027) \u003d {10}) \u003d\u003e ((String`indexAll(\"1234567890\", \u0027a\u0027) \u003d {}) \u003d\u003e ((String`indexAll(\"1231567190\", \u00271\u0027) \u003d {1, 4, 8}) \u003d\u003e ((String`indexAll(\"1231567191\", \u00271\u0027) \u003d {1, 4, 8, 10}) \u003d\u003e ((String`Index(\u00271\u0027)(\"1234567890\") \u003d 1) \u003d\u003e ((String`Index(\u00270\u0027)(\"1234567890\") \u003d 10) \u003d\u003e ((String`Index(\u0027a\u0027)(\"1234567890\") \u003d 0) \u003d\u003e pre_(String`IndexAll2(\u00271\u0027)\"1234567890\"))))))))))))","legal function application obligation:((String`index(\"1234567890\", \u00271\u0027) \u003d 1) \u003d\u003e ((String`index(\"1234567890\", \u00270\u0027) \u003d 10) \u003d\u003e ((String`index(\"1234567890\", \u0027a\u0027) \u003d 0) \u003d\u003e ((String`indexAll(\"1234567890\", \u00271\u0027) \u003d {1}) \u003d\u003e ((String`indexAll(\"1234567890\", \u00270\u0027) \u003d {10}) \u003d\u003e ((String`indexAll(\"1234567890\", \u0027a\u0027) \u003d {}) \u003d\u003e ((String`indexAll(\"1231567190\", \u00271\u0027) \u003d {1, 4, 8}) \u003d\u003e ((String`indexAll(\"1231567191\", \u00271\u0027) \u003d {1, 4, 8, 10}) \u003d\u003e ((String`Index(\u00271\u0027)(\"1234567890\") \u003d 1) \u003d\u003e ((String`Index(\u00270\u0027)(\"1234567890\") \u003d 10) \u003d\u003e ((String`Index(\u0027a\u0027)(\"1234567890\") \u003d 0) \u003d\u003e ((String`IndexAll2(\u00271\u0027)(\"1234567890\") \u003d {1}) \u003d\u003e pre_(String`IndexAll2(\u00270\u0027)\"1234567890\")))))))))))))","legal function application obligation:((String`index(\"1234567890\", \u00271\u0027) \u003d 1) \u003d\u003e ((String`index(\"1234567890\", \u00270\u0027) \u003d 10) \u003d\u003e ((String`index(\"1234567890\", \u0027a\u0027) \u003d 0) \u003d\u003e ((String`indexAll(\"1234567890\", \u00271\u0027) \u003d {1}) \u003d\u003e ((String`indexAll(\"1234567890\", \u00270\u0027) \u003d {10}) \u003d\u003e ((String`indexAll(\"1234567890\", \u0027a\u0027) \u003d {}) \u003d\u003e ((String`indexAll(\"1231567190\", \u00271\u0027) \u003d {1, 4, 8}) \u003d\u003e ((String`indexAll(\"1231567191\", \u00271\u0027) \u003d {1, 4, 8, 10}) \u003d\u003e ((String`Index(\u00271\u0027)(\"1234567890\") \u003d 1) \u003d\u003e ((String`Index(\u00270\u0027)(\"1234567890\") \u003d 10) \u003d\u003e ((String`Index(\u0027a\u0027)(\"1234567890\") \u003d 0) \u003d\u003e ((String`IndexAll2(\u00271\u0027)(\"1234567890\") \u003d {1}) \u003d\u003e ((String`IndexAll2(\u00270\u0027)(\"1234567890\") \u003d {10}) \u003d\u003e pre_(String`IndexAll2(\u0027a\u0027)\"1234567890\"))))))))))))))","legal function application obligation:((String`index(\"1234567890\", \u00271\u0027) \u003d 1) \u003d\u003e ((String`index(\"1234567890\", \u00270\u0027) \u003d 10) \u003d\u003e ((String`index(\"1234567890\", \u0027a\u0027) \u003d 0) \u003d\u003e ((String`indexAll(\"1234567890\", \u00271\u0027) \u003d {1}) \u003d\u003e ((String`indexAll(\"1234567890\", \u00270\u0027) \u003d {10}) \u003d\u003e ((String`indexAll(\"1234567890\", \u0027a\u0027) \u003d {}) \u003d\u003e ((String`indexAll(\"1231567190\", \u00271\u0027) \u003d {1, 4, 8}) \u003d\u003e ((String`indexAll(\"1231567191\", \u00271\u0027) \u003d {1, 4, 8, 10}) \u003d\u003e ((String`Index(\u00271\u0027)(\"1234567890\") \u003d 1) \u003d\u003e ((String`Index(\u00270\u0027)(\"1234567890\") \u003d 10) \u003d\u003e ((String`Index(\u0027a\u0027)(\"1234567890\") \u003d 0) \u003d\u003e ((String`IndexAll2(\u00271\u0027)(\"1234567890\") \u003d {1}) \u003d\u003e ((String`IndexAll2(\u00270\u0027)(\"1234567890\") \u003d {10}) \u003d\u003e ((String`IndexAll2(\u0027a\u0027)(\"1234567890\") \u003d {}) \u003d\u003e pre_(String`IndexAll2(\u00271\u0027)\"1231567190\")))))))))))))))","legal function application obligation:((String`index(\"1234567890\", \u00271\u0027) \u003d 1) \u003d\u003e ((String`index(\"1234567890\", \u00270\u0027) \u003d 10) \u003d\u003e ((String`index(\"1234567890\", \u0027a\u0027) \u003d 0) \u003d\u003e ((String`indexAll(\"1234567890\", \u00271\u0027) \u003d {1}) \u003d\u003e ((String`indexAll(\"1234567890\", \u00270\u0027) \u003d {10}) \u003d\u003e ((String`indexAll(\"1234567890\", \u0027a\u0027) \u003d {}) \u003d\u003e ((String`indexAll(\"1231567190\", \u00271\u0027) \u003d {1, 4, 8}) \u003d\u003e ((String`indexAll(\"1231567191\", \u00271\u0027) \u003d {1, 4, 8, 10}) \u003d\u003e ((String`Index(\u00271\u0027)(\"1234567890\") \u003d 1) \u003d\u003e ((String`Index(\u00270\u0027)(\"1234567890\") \u003d 10) \u003d\u003e ((String`Index(\u0027a\u0027)(\"1234567890\") \u003d 0) \u003d\u003e ((String`IndexAll2(\u00271\u0027)(\"1234567890\") \u003d {1}) \u003d\u003e ((String`IndexAll2(\u00270\u0027)(\"1234567890\") \u003d {10}) \u003d\u003e ((String`IndexAll2(\u0027a\u0027)(\"1234567890\") \u003d {}) \u003d\u003e ((String`IndexAll2(\u00271\u0027)(\"1231567190\") \u003d {1, 4, 8}) \u003d\u003e pre_(String`IndexAll2(\u00271\u0027)\"1231567191\"))))))))))))))))","legal function application obligation:((String`index(\"1234567890\", \u00271\u0027) \u003d 1) \u003d\u003e ((String`index(\"1234567890\", \u00270\u0027) \u003d 10) \u003d\u003e ((String`index(\"1234567890\", \u0027a\u0027) \u003d 0) \u003d\u003e ((String`indexAll(\"1234567890\", \u00271\u0027) \u003d {1}) \u003d\u003e ((String`indexAll(\"1234567890\", \u00270\u0027) \u003d {10}) \u003d\u003e ((String`indexAll(\"1234567890\", \u0027a\u0027) \u003d {}) \u003d\u003e ((String`indexAll(\"1231567190\", \u00271\u0027) \u003d {1, 4, 8}) \u003d\u003e ((String`indexAll(\"1231567191\", \u00271\u0027) \u003d {1, 4, 8, 10}) \u003d\u003e ((String`Index(\u00271\u0027)(\"1234567890\") \u003d 1) \u003d\u003e ((String`Index(\u00270\u0027)(\"1234567890\") \u003d 10) \u003d\u003e ((String`Index(\u0027a\u0027)(\"1234567890\") \u003d 0) \u003d\u003e ((String`IndexAll2(\u00271\u0027)(\"1234567890\") \u003d {1}) \u003d\u003e ((String`IndexAll2(\u00270\u0027)(\"1234567890\") \u003d {10}) \u003d\u003e ((String`IndexAll2(\u0027a\u0027)(\"1234567890\") \u003d {}) \u003d\u003e ((String`IndexAll2(\u00271\u0027)(\"1231567190\") \u003d {1, 4, 8}) \u003d\u003e ((String`IndexAll2(\u00271\u0027)(\"1231567191\") \u003d {1, 4, 8, 10}) \u003d\u003e pre_((Sequence`fmap)[seq of (char), int](String`Index(\u00271\u0027))[\"1234567890\", \"2345671\"])))))))))))))))))","legal function application obligation:((String`index(\"1234567890\", \u00271\u0027) \u003d 1) \u003d\u003e ((String`index(\"1234567890\", \u00270\u0027) \u003d 10) \u003d\u003e ((String`index(\"1234567890\", \u0027a\u0027) \u003d 0) \u003d\u003e ((String`indexAll(\"1234567890\", \u00271\u0027) \u003d {1}) \u003d\u003e ((String`indexAll(\"1234567890\", \u00270\u0027) \u003d {10}) \u003d\u003e ((String`indexAll(\"1234567890\", \u0027a\u0027) \u003d {}) \u003d\u003e ((String`indexAll(\"1231567190\", \u00271\u0027) \u003d {1, 4, 8}) \u003d\u003e ((String`indexAll(\"1231567191\", \u00271\u0027) \u003d {1, 4, 8, 10}) \u003d\u003e ((String`Index(\u00271\u0027)(\"1234567890\") \u003d 1) \u003d\u003e ((String`Index(\u00270\u0027)(\"1234567890\") \u003d 10) \u003d\u003e ((String`Index(\u0027a\u0027)(\"1234567890\") \u003d 0) \u003d\u003e ((String`IndexAll2(\u00271\u0027)(\"1234567890\") \u003d {1}) \u003d\u003e ((String`IndexAll2(\u00270\u0027)(\"1234567890\") \u003d {10}) \u003d\u003e ((String`IndexAll2(\u0027a\u0027)(\"1234567890\") \u003d {}) \u003d\u003e ((String`IndexAll2(\u00271\u0027)(\"1231567190\") \u003d {1, 4, 8}) \u003d\u003e ((String`IndexAll2(\u00271\u0027)(\"1231567191\") \u003d {1, 4, 8, 10}) \u003d\u003e (((Sequence`fmap)[seq of (char), int](String`Index(\u00271\u0027))([\"1234567890\", \"2345671\"]) \u003d [1, 7]) \u003d\u003e pre_((Sequence`fmap)[seq of (char), set of (int)](String`IndexAll2(\u00271\u0027))[\"1231567190\", \"1231567191\"]))))))))))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(String`isInclude(\"1234567890\")\"abc\")","legal function application obligation:pre_isInclude(\"1234567890\")","legal function application obligation:((String`isInclude(\"1234567890\")(\"abc\") \u003d false) \u003d\u003e pre_(isInclude(\"Shin\")\"Shin\"))","legal function application obligation:((String`isInclude(\"1234567890\")(\"abc\") \u003d false) \u003d\u003e pre_(isInclude\"Shin\"))","legal function application obligation:((String`isInclude(\"1234567890\")(\"abc\") \u003d false) \u003d\u003e ((isInclude(\"Shin\")(\"Shin\") \u003d true) \u003d\u003e pre_(isInclude(\"Shin\")\"S\")))","legal function application obligation:((String`isInclude(\"1234567890\")(\"abc\") \u003d false) \u003d\u003e ((isInclude(\"Shin\")(\"Shin\") \u003d true) \u003d\u003e pre_(isInclude\"Shin\")))","legal function application obligation:((String`isInclude(\"1234567890\")(\"abc\") \u003d false) \u003d\u003e ((isInclude(\"Shin\")(\"Shin\") \u003d true) \u003d\u003e ((isInclude(\"Shin\")(\"S\") \u003d true) \u003d\u003e pre_(isInclude(\"Shin\")\"h\"))))","legal function application obligation:((String`isInclude(\"1234567890\")(\"abc\") \u003d false) \u003d\u003e ((isInclude(\"Shin\")(\"Shin\") \u003d true) \u003d\u003e ((isInclude(\"Shin\")(\"S\") \u003d true) \u003d\u003e pre_(isInclude\"Shin\"))))","legal function application obligation:((String`isInclude(\"1234567890\")(\"abc\") \u003d false) \u003d\u003e ((isInclude(\"Shin\")(\"Shin\") \u003d true) \u003d\u003e ((isInclude(\"Shin\")(\"S\") \u003d true) \u003d\u003e ((isInclude(\"Shin\")(\"h\") \u003d true) \u003d\u003e pre_(isInclude(\"Shin\")\"n\")))))","legal function application obligation:((String`isInclude(\"1234567890\")(\"abc\") \u003d false) \u003d\u003e ((isInclude(\"Shin\")(\"Shin\") \u003d true) \u003d\u003e ((isInclude(\"Shin\")(\"S\") \u003d true) \u003d\u003e ((isInclude(\"Shin\")(\"h\") \u003d true) \u003d\u003e pre_(isInclude\"Shin\")))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(String`isInclude(\"Shin Sahara\")\"\")","legal function application obligation:pre_isInclude(\"Shin Sahara\")","type compatibility obligation:is_(RESULT, ())","type compatibility obligation:is_(RESULT, ())","legal sequence application obligation:let 対象文字列1:seq1 of (char) \u003d \"private 次状態を得る : () \u003d\u003d\u003e 「状態」\n次状態を得る(aガード, aガード引数, aイベント, aイベント引数, a処理時間) \u003d\u003d (\ncases mk_(aガード, 現在状態, aイベント) :\n\tmk_(-,-,(エラー検知)) -\u003e return エラー中,\n\", ss1:seq of (seq of (char)) \u003d String`getLines(対象文字列1), 対象文字列2:seq1 of (char) \u003d \"佐原\n伸\", ss2:seq of (seq of (char)) \u003d String`getLines(対象文字列2) in (1 in set (inds ss1))","legal sequence application obligation:let 対象文字列1:seq1 of (char) \u003d \"private 次状態を得る : () \u003d\u003d\u003e 「状態」\n次状態を得る(aガード, aガード引数, aイベント, aイベント引数, a処理時間) \u003d\u003d (\ncases mk_(aガード, 現在状態, aイベント) :\n\tmk_(-,-,(エラー検知)) -\u003e return エラー中,\n\", ss1:seq of (seq of (char)) \u003d String`getLines(対象文字列1), 対象文字列2:seq1 of (char) \u003d \"佐原\n伸\", ss2:seq of (seq of (char)) \u003d String`getLines(対象文字列2) in ((ss1(1) \u003d \"private 次状態を得る : () \u003d\u003d\u003e 「状態」\") \u003d\u003e (2 in set (inds ss1)))","legal sequence application obligation:let 対象文字列1:seq1 of (char) \u003d \"private 次状態を得る : () \u003d\u003d\u003e 「状態」\n次状態を得る(aガード, aガード引数, aイベント, aイベント引数, a処理時間) \u003d\u003d (\ncases mk_(aガード, 現在状態, aイベント) :\n\tmk_(-,-,(エラー検知)) -\u003e return エラー中,\n\", ss1:seq of (seq of (char)) \u003d String`getLines(対象文字列1), 対象文字列2:seq1 of (char) \u003d \"佐原\n伸\", ss2:seq of (seq of (char)) \u003d String`getLines(対象文字列2) in ((ss1(1) \u003d \"private 次状態を得る : () \u003d\u003d\u003e 「状態」\") \u003d\u003e ((ss1(2) \u003d \"次状態を得る(aガード, aガード引数, aイベント, aイベント引数, a処理時間) \u003d\u003d (\") \u003d\u003e (3 in set (inds ss1))))","legal sequence application obligation:let 対象文字列1:seq1 of (char) \u003d \"private 次状態を得る : () \u003d\u003d\u003e 「状態」\n次状態を得る(aガード, aガード引数, aイベント, aイベント引数, a処理時間) \u003d\u003d (\ncases mk_(aガード, 現在状態, aイベント) :\n\tmk_(-,-,(エラー検知)) -\u003e return エラー中,\n\", ss1:seq of (seq of (char)) \u003d String`getLines(対象文字列1), 対象文字列2:seq1 of (char) \u003d \"佐原\n伸\", ss2:seq of (seq of (char)) \u003d String`getLines(対象文字列2) in ((ss1(1) \u003d \"private 次状態を得る : () \u003d\u003d\u003e 「状態」\") \u003d\u003e ((ss1(2) \u003d \"次状態を得る(aガード, aガード引数, aイベント, aイベント引数, a処理時間) \u003d\u003d (\") \u003d\u003e ((ss1(3) \u003d \"cases mk_(aガード, 現在状態, aイベント) :\") \u003d\u003e (4 in set (inds ss1)))))","legal sequence application obligation:let 対象文字列1:seq1 of (char) \u003d \"private 次状態を得る : () \u003d\u003d\u003e 「状態」\n次状態を得る(aガード, aガード引数, aイベント, aイベント引数, a処理時間) \u003d\u003d (\ncases mk_(aガード, 現在状態, aイベント) :\n\tmk_(-,-,(エラー検知)) -\u003e return エラー中,\n\", ss1:seq of (seq of (char)) \u003d String`getLines(対象文字列1), 対象文字列2:seq1 of (char) \u003d \"佐原\n伸\", ss2:seq of (seq of (char)) \u003d String`getLines(対象文字列2) in ((ss1(1) \u003d \"private 次状態を得る : () \u003d\u003d\u003e 「状態」\") \u003d\u003e ((ss1(2) \u003d \"次状態を得る(aガード, aガード引数, aイベント, aイベント引数, a処理時間) \u003d\u003d (\") \u003d\u003e ((ss1(3) \u003d \"cases mk_(aガード, 現在状態, aイベント) :\") \u003d\u003e ((ss1(4) \u003d \"\tmk_(-,-,(エラー検知)) -\u003e return エラー中,\") \u003d\u003e (1 in set (inds ss2))))))","legal sequence application obligation:let 対象文字列1:seq1 of (char) \u003d \"private 次状態を得る : () \u003d\u003d\u003e 「状態」\n次状態を得る(aガード, aガード引数, aイベント, aイベント引数, a処理時間) \u003d\u003d (\ncases mk_(aガード, 現在状態, aイベント) :\n\tmk_(-,-,(エラー検知)) -\u003e return エラー中,\n\", ss1:seq of (seq of (char)) \u003d String`getLines(対象文字列1), 対象文字列2:seq1 of (char) \u003d \"佐原\n伸\", ss2:seq of (seq of (char)) \u003d String`getLines(対象文字列2) in ((ss1(1) \u003d \"private 次状態を得る : () \u003d\u003d\u003e 「状態」\") \u003d\u003e ((ss1(2) \u003d \"次状態を得る(aガード, aガード引数, aイベント, aイベント引数, a処理時間) \u003d\u003d (\") \u003d\u003e ((ss1(3) \u003d \"cases mk_(aガード, 現在状態, aイベント) :\") \u003d\u003e ((ss1(4) \u003d \"\tmk_(-,-,(エラー検知)) -\u003e return エラー中,\") \u003d\u003e ((ss2(1) \u003d \"佐原\") \u003d\u003e (2 in set (inds ss2)))))))","type compatibility obligation:is_(RESULT, ())","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(isSomeString(Character`isLetterOrDigit)\"007isTheMmurder\")","legal function application obligation:pre_(isSomeStringCharacter`isLetterOrDigit)","legal function application obligation:(isSomeString(Character`isLetterOrDigit)(\"007isTheMmurder\") \u003d\u003e pre_(isSomeString(Character`isLetterOrDigit)\"007 is the mmurder\"))","legal function application obligation:(isSomeString(Character`isLetterOrDigit)(\"007isTheMmurder\") \u003d\u003e pre_(isSomeStringCharacter`isLetterOrDigit))","legal function application obligation:(isSomeString(Character`isLetterOrDigit)(\"007isTheMmurder\") \u003d\u003e ((not isSomeString(Character`isLetterOrDigit)(\"007 is the mmurder\")) \u003d\u003e pre_(isSomeString(Character`isCapitalLetter)\"SAHARA\")))","legal function application obligation:(isSomeString(Character`isLetterOrDigit)(\"007isTheMmurder\") \u003d\u003e ((not isSomeString(Character`isLetterOrDigit)(\"007 is the mmurder\")) \u003d\u003e pre_(isSomeStringCharacter`isCapitalLetter)))","legal function application obligation:(isSomeString(Character`isLetterOrDigit)(\"007isTheMmurder\") \u003d\u003e ((not isSomeString(Character`isLetterOrDigit)(\"007 is the mmurder\")) \u003d\u003e (isSomeString(Character`isCapitalLetter)(\"SAHARA\") \u003d\u003e pre_(isSomeString(Character`isCapitalLetter)\"Sahara\"))))","legal function application obligation:(isSomeString(Character`isLetterOrDigit)(\"007isTheMmurder\") \u003d\u003e ((not isSomeString(Character`isLetterOrDigit)(\"007 is the mmurder\")) \u003d\u003e (isSomeString(Character`isCapitalLetter)(\"SAHARA\") \u003d\u003e pre_(isSomeStringCharacter`isCapitalLetter))))","legal function application obligation:(isSomeString(Character`isLetterOrDigit)(\"007isTheMmurder\") \u003d\u003e ((not isSomeString(Character`isLetterOrDigit)(\"007 is the mmurder\")) \u003d\u003e (isSomeString(Character`isCapitalLetter)(\"SAHARA\") \u003d\u003e ((not isSomeString(Character`isCapitalLetter)(\"Sahara\")) \u003d\u003e pre_(isSomeString(Character`isLowercaseLetter)\"sahara\")))))","legal function application obligation:(isSomeString(Character`isLetterOrDigit)(\"007isTheMmurder\") \u003d\u003e ((not isSomeString(Character`isLetterOrDigit)(\"007 is the mmurder\")) \u003d\u003e (isSomeString(Character`isCapitalLetter)(\"SAHARA\") \u003d\u003e ((not isSomeString(Character`isCapitalLetter)(\"Sahara\")) \u003d\u003e pre_(isSomeStringCharacter`isLowercaseLetter)))))","legal function application obligation:(isSomeString(Character`isLetterOrDigit)(\"007isTheMmurder\") \u003d\u003e ((not isSomeString(Character`isLetterOrDigit)(\"007 is the mmurder\")) \u003d\u003e (isSomeString(Character`isCapitalLetter)(\"SAHARA\") \u003d\u003e ((not isSomeString(Character`isCapitalLetter)(\"Sahara\")) \u003d\u003e (isSomeString(Character`isLowercaseLetter)(\"sahara\") \u003d\u003e pre_(isSomeString(Character`isLowercaseLetter)\"Sahara\"))))))","legal function application obligation:(isSomeString(Character`isLetterOrDigit)(\"007isTheMmurder\") \u003d\u003e ((not isSomeString(Character`isLetterOrDigit)(\"007 is the mmurder\")) \u003d\u003e (isSomeString(Character`isCapitalLetter)(\"SAHARA\") \u003d\u003e ((not isSomeString(Character`isCapitalLetter)(\"Sahara\")) \u003d\u003e (isSomeString(Character`isLowercaseLetter)(\"sahara\") \u003d\u003e pre_(isSomeStringCharacter`isLowercaseLetter))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:(forall f:(@T1 * @T2 -\u003e @T3), x:@T1, y:@T2 \u0026 pre_(fx, y))","legal function application obligation:(forall f:(@T1 -\u003e (@T2 -\u003e @T3)), x:@T1, y:@T2 \u0026 pre_(f(x)y))","legal function application obligation:(forall f:(@T1 -\u003e (@T2 -\u003e @T3)), x:@T1, y:@T2 \u0026 pre_(fx))","function establishes postcondition obligation:(forall aSet:set of (@T) \u0026 post_asSequence(aSet, (cases aSet :\n{} -\u003e [],\n{x} union xs -\u003e ([x] ^ (asSequence)[@T](xs))\n end)))","recursive function obligation:(forall aSet:set of (@T) \u0026 ((not ({} \u003d aSet)) \u003d\u003e (exists {x} union xs:set of (@T) \u0026 ((({x} union xs) \u003d aSet) \u003d\u003e let {x} union xs \u003d aSet in ((cardinality)[set of (@T)](aSet) \u003e (cardinality)[@T](xs))))))","cases exhaustive obligation:(forall aSet:set of (@T) \u0026 ((aSet \u003d {}) or (exists {x} union xs:set of (@T) \u0026 (aSet \u003d ({x} union xs)))))","legal function application obligation:(forall f:(@T1 -\u003e @T2), aSet:set of (@T1) \u0026 (forall s in set aSet \u0026 pre_(fs)))","legal function application obligation:(forall aSet:set of (@T) \u0026 ((is_(aSet, set of (int)) or (is_(aSet, set of (nat)) or (is_(aSet, set of (nat1)) or (is_(aSet, set of (real)) or is_(aSet, set of (rat)))))) \u003d\u003e pre_((SumAux)[@T](aSet)0)))","legal function application obligation:(forall aSet:set of (@T) \u0026 ((is_(aSet, set of (int)) or (is_(aSet, set of (nat)) or (is_(aSet, set of (nat1)) or (is_(aSet, set of (real)) or is_(aSet, set of (rat)))))) \u003d\u003e pre_SumAux(aSet)))","legal function application obligation:(forall aSet:set of (@T), aSum:@T \u0026 ((pre_Sum)[@T](aSet) \u003d\u003e ((not ({} \u003d aSet)) \u003d\u003e (exists {e} union s:set of (@T) \u0026 ((({e} union s) \u003d aSet) \u003d\u003e let {e} union s \u003d aSet in pre_((SumAux)[@T](s)(if (is_(aSum, real) and is_(e, real))\nthen (aSum + e)\nelse (undefined))))))))","legal function application obligation:(forall aSet:set of (@T), aSum:@T \u0026 ((pre_Sum)[@T](aSet) \u003d\u003e ((not ({} \u003d aSet)) \u003d\u003e (exists {e} union s:set of (@T) \u0026 ((({e} union s) \u003d aSet) \u003d\u003e let {e} union s \u003d aSet in pre_SumAux(s))))))","cases exhaustive obligation:(forall aSet:set of (@T), aSum:@T \u0026 ((pre_Sum)[@T](aSet) \u003d\u003e ((aSet \u003d {}) or (exists {e} union s:set of (@T) \u0026 (aSet \u003d ({e} union s))))))","type compatibility obligation:is_(RESULT, ())","type compatibility obligation:is_(q4, (seq of (int) * seq of (int)))","type compatibility obligation:is_(q7, (seq of (int) * seq of (int)))","type compatibility obligation:is_(q8, (seq of (int) * seq of (int)))","type compatibility obligation:is_(q9, (seq of (int) * seq of (int)))","type compatibility obligation:is_(q10, (seq of (int) * seq of (int)))","type compatibility obligation:is_(q10, (seq of (int) * seq of (int)))","type compatibility obligation:((DoubleListQueue`isEmpty)[int](q0) \u003d\u003e ((q0 \u003d mk_([], [])) \u003d\u003e (((DoubleListQueue`toList)[int](q1) \u003d [1]) \u003d\u003e ((q1 \u003d mk_([], [1])) \u003d\u003e (((DoubleListQueue`toList)[int](q2) \u003d [1, 2]) \u003d\u003e ((q2 \u003d mk_([], [2, 1])) \u003d\u003e (((DoubleListQueue`toList)[int](q3) \u003d [1, 2, 3]) \u003d\u003e ((q3 \u003d mk_([], [3, 2, 1])) \u003d\u003e ((h1 \u003d 1) \u003d\u003e is_(q4, (seq of (int) * seq of (int))))))))))))","type compatibility obligation:((DoubleListQueue`isEmpty)[int](q0) \u003d\u003e ((q0 \u003d mk_([], [])) \u003d\u003e (((DoubleListQueue`toList)[int](q1) \u003d [1]) \u003d\u003e ((q1 \u003d mk_([], [1])) \u003d\u003e (((DoubleListQueue`toList)[int](q2) \u003d [1, 2]) \u003d\u003e ((q2 \u003d mk_([], [2, 1])) \u003d\u003e (((DoubleListQueue`toList)[int](q3) \u003d [1, 2, 3]) \u003d\u003e ((q3 \u003d mk_([], [3, 2, 1])) \u003d\u003e ((h1 \u003d 1) \u003d\u003e (((DoubleListQueue`toList)[int](q4) \u003d [2, 3]) \u003d\u003e ((q4 \u003d mk_([2, 3], [])) \u003d\u003e (((DoubleListQueue`toList)[int](q5) \u003d [2, 3, 4]) \u003d\u003e ((q5 \u003d mk_([2, 3], [4])) \u003d\u003e (((DoubleListQueue`toList)[int](q6) \u003d [2, 3, 4, 5]) \u003d\u003e ((q6 \u003d mk_([2, 3], [5, 4])) \u003d\u003e is_(q7, (seq of (int) * seq of (int))))))))))))))))))","type compatibility obligation:((DoubleListQueue`isEmpty)[int](q0) \u003d\u003e ((q0 \u003d mk_([], [])) \u003d\u003e (((DoubleListQueue`toList)[int](q1) \u003d [1]) \u003d\u003e ((q1 \u003d mk_([], [1])) \u003d\u003e (((DoubleListQueue`toList)[int](q2) \u003d [1, 2]) \u003d\u003e ((q2 \u003d mk_([], [2, 1])) \u003d\u003e (((DoubleListQueue`toList)[int](q3) \u003d [1, 2, 3]) \u003d\u003e ((q3 \u003d mk_([], [3, 2, 1])) \u003d\u003e ((h1 \u003d 1) \u003d\u003e (((DoubleListQueue`toList)[int](q4) \u003d [2, 3]) \u003d\u003e ((q4 \u003d mk_([2, 3], [])) \u003d\u003e (((DoubleListQueue`toList)[int](q5) \u003d [2, 3, 4]) \u003d\u003e ((q5 \u003d mk_([2, 3], [4])) \u003d\u003e (((DoubleListQueue`toList)[int](q6) \u003d [2, 3, 4, 5]) \u003d\u003e ((q6 \u003d mk_([2, 3], [5, 4])) \u003d\u003e (((DoubleListQueue`toList)[int](q7) \u003d [3, 4, 5]) \u003d\u003e ((q7 \u003d mk_([3], [5, 4])) \u003d\u003e is_(q8, (seq of (int) * seq of (int))))))))))))))))))))","type compatibility obligation:((DoubleListQueue`isEmpty)[int](q0) \u003d\u003e ((q0 \u003d mk_([], [])) \u003d\u003e (((DoubleListQueue`toList)[int](q1) \u003d [1]) \u003d\u003e ((q1 \u003d mk_([], [1])) \u003d\u003e (((DoubleListQueue`toList)[int](q2) \u003d [1, 2]) \u003d\u003e ((q2 \u003d mk_([], [2, 1])) \u003d\u003e (((DoubleListQueue`toList)[int](q3) \u003d [1, 2, 3]) \u003d\u003e ((q3 \u003d mk_([], [3, 2, 1])) \u003d\u003e ((h1 \u003d 1) \u003d\u003e (((DoubleListQueue`toList)[int](q4) \u003d [2, 3]) \u003d\u003e ((q4 \u003d mk_([2, 3], [])) \u003d\u003e (((DoubleListQueue`toList)[int](q5) \u003d [2, 3, 4]) \u003d\u003e ((q5 \u003d mk_([2, 3], [4])) \u003d\u003e (((DoubleListQueue`toList)[int](q6) \u003d [2, 3, 4, 5]) \u003d\u003e ((q6 \u003d mk_([2, 3], [5, 4])) \u003d\u003e (((DoubleListQueue`toList)[int](q7) \u003d [3, 4, 5]) \u003d\u003e ((q7 \u003d mk_([3], [5, 4])) \u003d\u003e (((DoubleListQueue`toList)[int](q8) \u003d [4, 5]) \u003d\u003e ((q8 \u003d mk_([], [5, 4])) \u003d\u003e is_(q9, (seq of (int) * seq of (int))))))))))))))))))))))","type compatibility obligation:((DoubleListQueue`isEmpty)[int](q0) \u003d\u003e ((q0 \u003d mk_([], [])) \u003d\u003e (((DoubleListQueue`toList)[int](q1) \u003d [1]) \u003d\u003e ((q1 \u003d mk_([], [1])) \u003d\u003e (((DoubleListQueue`toList)[int](q2) \u003d [1, 2]) \u003d\u003e ((q2 \u003d mk_([], [2, 1])) \u003d\u003e (((DoubleListQueue`toList)[int](q3) \u003d [1, 2, 3]) \u003d\u003e ((q3 \u003d mk_([], [3, 2, 1])) \u003d\u003e ((h1 \u003d 1) \u003d\u003e (((DoubleListQueue`toList)[int](q4) \u003d [2, 3]) \u003d\u003e ((q4 \u003d mk_([2, 3], [])) \u003d\u003e (((DoubleListQueue`toList)[int](q5) \u003d [2, 3, 4]) \u003d\u003e ((q5 \u003d mk_([2, 3], [4])) \u003d\u003e (((DoubleListQueue`toList)[int](q6) \u003d [2, 3, 4, 5]) \u003d\u003e ((q6 \u003d mk_([2, 3], [5, 4])) \u003d\u003e (((DoubleListQueue`toList)[int](q7) \u003d [3, 4, 5]) \u003d\u003e ((q7 \u003d mk_([3], [5, 4])) \u003d\u003e (((DoubleListQueue`toList)[int](q8) \u003d [4, 5]) \u003d\u003e ((q8 \u003d mk_([], [5, 4])) \u003d\u003e (((DoubleListQueue`toList)[int](q9) \u003d [5]) \u003d\u003e ((q9 \u003d mk_([5], [])) \u003d\u003e is_(q10, (seq of (int) * seq of (int))))))))))))))))))))))))","type compatibility obligation:((DoubleListQueue`isEmpty)[int](q0) \u003d\u003e ((q0 \u003d mk_([], [])) \u003d\u003e (((DoubleListQueue`toList)[int](q1) \u003d [1]) \u003d\u003e ((q1 \u003d mk_([], [1])) \u003d\u003e (((DoubleListQueue`toList)[int](q2) \u003d [1, 2]) \u003d\u003e ((q2 \u003d mk_([], [2, 1])) \u003d\u003e (((DoubleListQueue`toList)[int](q3) \u003d [1, 2, 3]) \u003d\u003e ((q3 \u003d mk_([], [3, 2, 1])) \u003d\u003e ((h1 \u003d 1) \u003d\u003e (((DoubleListQueue`toList)[int](q4) \u003d [2, 3]) \u003d\u003e ((q4 \u003d mk_([2, 3], [])) \u003d\u003e (((DoubleListQueue`toList)[int](q5) \u003d [2, 3, 4]) \u003d\u003e ((q5 \u003d mk_([2, 3], [4])) \u003d\u003e (((DoubleListQueue`toList)[int](q6) \u003d [2, 3, 4, 5]) \u003d\u003e ((q6 \u003d mk_([2, 3], [5, 4])) \u003d\u003e (((DoubleListQueue`toList)[int](q7) \u003d [3, 4, 5]) \u003d\u003e ((q7 \u003d mk_([3], [5, 4])) \u003d\u003e (((DoubleListQueue`toList)[int](q8) \u003d [4, 5]) \u003d\u003e ((q8 \u003d mk_([], [5, 4])) \u003d\u003e (((DoubleListQueue`toList)[int](q9) \u003d [5]) \u003d\u003e ((q9 \u003d mk_([5], [])) \u003d\u003e (((DoubleListQueue`toList)[int](q10) \u003d []) \u003d\u003e is_(q10, (seq of (int) * seq of (int)))))))))))))))))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((Function`Fwhile)[int](p11)(f1)1)","legal function application obligation:pre_((Function`Fwhile)[int](p11)f1)","legal function application obligation:(((Function`Fwhile)[int](p11)(f1)(1) \u003d 1024) \u003d\u003e pre_((Function`Fwhile)[seq of (char)](p21)(f2)\"123456\"))","legal function application obligation:(((Function`Fwhile)[int](p11)(f1)(1) \u003d 1024) \u003d\u003e pre_((Function`Fwhile)[seq of (char)](p21)f2))","legal function application obligation:(((Function`Fwhile)[int](p11)(f1)(1) \u003d 1024) \u003d\u003e (((Function`Fwhile)[seq of (char)](p21)(f2)(\"123456\") \u003d \"1234560000\") \u003d\u003e pre_((Function`Funtil)[int](p1)(f1)1)))","legal function application obligation:(((Function`Fwhile)[int](p11)(f1)(1) \u003d 1024) \u003d\u003e (((Function`Fwhile)[seq of (char)](p21)(f2)(\"123456\") \u003d \"1234560000\") \u003d\u003e pre_((Function`Funtil)[int](p1)f1)))","legal function application obligation:(((Function`Fwhile)[int](p11)(f1)(1) \u003d 1024) \u003d\u003e (((Function`Fwhile)[seq of (char)](p21)(f2)(\"123456\") \u003d \"1234560000\") \u003d\u003e (((Function`Funtil)[int](p1)(f1)(1) \u003d 1024) \u003d\u003e pre_((Function`Funtil)[seq of (char)](p2)(f2)\"123456\"))))","legal function application obligation:(((Function`Fwhile)[int](p11)(f1)(1) \u003d 1024) \u003d\u003e (((Function`Fwhile)[seq of (char)](p21)(f2)(\"123456\") \u003d \"1234560000\") \u003d\u003e (((Function`Funtil)[int](p1)(f1)(1) \u003d 1024) \u003d\u003e pre_((Function`Funtil)[seq of (char)](p2)f2))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((Function`Seq)[int](funcSeq1)2)","legal function application obligation:(((Function`Seq)[int](funcSeq1)(2) \u003d (((2 * 2) * 3) ** 2)) \u003d\u003e pre_((Function`Seq)[seq of (char)](funcSeq2)\"12345678\"))","type compatibility obligation:is_(RESULT, ())","type compatibility obligation:is_(let fn:seq1 of (char) \u003d \"./fread-func.txt\" in (Function`readFn)[ReadingFunctionType](fn), (INT -\u003e (INT -\u003e INT)))","legal function application obligation:pre_(ReadingFunction()(3)2)","legal function application obligation:pre_(ReadingFunction()3)","legal function application obligation:((ReadingFunction()(3)(2) \u003d 1) \u003d\u003e pre_(ReadingFunction()(4)4))","legal function application obligation:((ReadingFunction()(3)(2) \u003d 1) \u003d\u003e pre_(ReadingFunction()4))","legal function application obligation:((ReadingFunction()(3)(2) \u003d 1) \u003d\u003e ((ReadingFunction()(4)(4) \u003d 0) \u003d\u003e pre_(ReadingFunction()(4)-3)))","legal function application obligation:((ReadingFunction()(3)(2) \u003d 1) \u003d\u003e ((ReadingFunction()(4)(4) \u003d 0) \u003d\u003e pre_(ReadingFunction()4)))","legal function application obligation:((ReadingFunction()(3)(2) \u003d 1) \u003d\u003e ((ReadingFunction()(4)(4) \u003d 0) \u003d\u003e ((ReadingFunction()(4)(-3) \u003d -2) \u003d\u003e pre_(ReadingFunction()(-4)3))))","legal function application obligation:((ReadingFunction()(3)(2) \u003d 1) \u003d\u003e ((ReadingFunction()(4)(4) \u003d 0) \u003d\u003e ((ReadingFunction()(4)(-3) \u003d -2) \u003d\u003e pre_(ReadingFunction()-4))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((FHashtable`PutAll)[int, seq of (char)]({|-\u003e})(aHashCode){1 |-\u003e \"Sahara\", 2 |-\u003e \"Sato\", 14 |-\u003e \"Sakoh\"})","legal function application obligation:pre_((FHashtable`PutAll)[int, seq of (char)]({|-\u003e})aHashCode)","enumeration map injectivity obligation:(forall m1, m2 in set {{1 |-\u003e \"Sahara\"}, {2 |-\u003e \"Sato\"}, {14 |-\u003e \"Sakoh\"}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","legal function application obligation:let aHashCode:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), p1:map (int) to (map (int) to (seq of (char))) \u003d (FHashtable`PutAll)[int, seq of (char)]({|-\u003e})(aHashCode)({1 |-\u003e \"Sahara\", 2 |-\u003e \"Sato\", 14 |-\u003e \"Sakoh\"}), c1:(seq of (char) +\u003e bool) \u003d (FHashtable`Contains)[int, seq of (char)](p1) in pre_(c1\"Sahara\")","legal function application obligation:let aHashCode:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), p1:map (int) to (map (int) to (seq of (char))) \u003d (FHashtable`PutAll)[int, seq of (char)]({|-\u003e})(aHashCode)({1 |-\u003e \"Sahara\", 2 |-\u003e \"Sato\", 14 |-\u003e \"Sakoh\"}), c1:(seq of (char) +\u003e bool) \u003d (FHashtable`Contains)[int, seq of (char)](p1) in (c1(\"Sahara\") \u003d\u003e pre_(c1\"Sato\"))","legal function application obligation:let aHashCode:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), p1:map (int) to (map (int) to (seq of (char))) \u003d (FHashtable`PutAll)[int, seq of (char)]({|-\u003e})(aHashCode)({1 |-\u003e \"Sahara\", 2 |-\u003e \"Sato\", 14 |-\u003e \"Sakoh\"}), c1:(seq of (char) +\u003e bool) \u003d (FHashtable`Contains)[int, seq of (char)](p1) in (c1(\"Sahara\") \u003d\u003e (c1(\"Sato\") \u003d\u003e pre_(c1\"Sakoh\")))","legal function application obligation:let aHashCode:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), p1:map (int) to (map (int) to (seq of (char))) \u003d (FHashtable`PutAll)[int, seq of (char)]({|-\u003e})(aHashCode)({1 |-\u003e \"Sahara\", 2 |-\u003e \"Sato\", 14 |-\u003e \"Sakoh\"}), c1:(seq of (char) +\u003e bool) \u003d (FHashtable`Contains)[int, seq of (char)](p1) in (c1(\"Sahara\") \u003d\u003e (c1(\"Sato\") \u003d\u003e (c1(\"Sakoh\") \u003d\u003e pre_(c1\"\"))))","legal function application obligation:(forall x:seq of (char) \u0026 ((not (x \u003d \"\")) \u003d\u003e pre_((FSequence`Take)[char](1)x)))","legal function application obligation:pre_((FHashtable`PutAll)[seq of (char), int]({|-\u003e})(aHashCode){\"a\" |-\u003e 1, \"b\" |-\u003e 2, \"c\" |-\u003e 3})","legal function application obligation:pre_((FHashtable`PutAll)[seq of (char), int]({|-\u003e})aHashCode)","enumeration map injectivity obligation:(forall m1, m2 in set {{\"a\" |-\u003e 1}, {\"b\" |-\u003e 2}, {\"c\" |-\u003e 3}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","legal function application obligation:pre_((FHashtable`Remove)[seq of (char), int](h2)(aHashCode)\"b\")","legal function application obligation:pre_((FHashtable`Remove)[seq of (char), int](h2)aHashCode)","legal function application obligation:let aHashCode:(seq of (char) -\u003e seq of (char)) \u003d (lambda [x:seq of (char)] \u0026 (if (x \u003d \"\")\nthen \"\"\nelse (FSequence`Take)[char](1)(x))), h2:map (seq of (char)) to (map (seq of (char)) to (int)) \u003d (FHashtable`PutAll)[seq of (char), int]({|-\u003e})(aHashCode)({\"a\" |-\u003e 1, \"b\" |-\u003e 2, \"c\" |-\u003e 3}), h3:map (int) to (map (int) to (seq of (char))) \u003d (FHashtable`Clear)[int, seq of (char)](), deletedh2:map (seq of (char)) to (map (seq of (char)) to (int)) \u003d (FHashtable`Remove)[seq of (char), int](h2)(aHashCode)(\"b\"), c1:(int +\u003e bool) \u003d (FHashtable`Contains)[seq of (char), int](deletedh2), ck1:(seq of (char) +\u003e bool) \u003d (FHashtable`ContainsKey)[seq of (char), int](deletedh2) in ((h3 \u003d {|-\u003e}) \u003d\u003e pre_((FHashtable`Get)[seq of (char), int](deletedh2)(aHashCode)\"b\"))","legal function application obligation:let aHashCode:(seq of (char) -\u003e seq of (char)) \u003d (lambda [x:seq of (char)] \u0026 (if (x \u003d \"\")\nthen \"\"\nelse (FSequence`Take)[char](1)(x))), h2:map (seq of (char)) to (map (seq of (char)) to (int)) \u003d (FHashtable`PutAll)[seq of (char), int]({|-\u003e})(aHashCode)({\"a\" |-\u003e 1, \"b\" |-\u003e 2, \"c\" |-\u003e 3}), h3:map (int) to (map (int) to (seq of (char))) \u003d (FHashtable`Clear)[int, seq of (char)](), deletedh2:map (seq of (char)) to (map (seq of (char)) to (int)) \u003d (FHashtable`Remove)[seq of (char), int](h2)(aHashCode)(\"b\"), c1:(int +\u003e bool) \u003d (FHashtable`Contains)[seq of (char), int](deletedh2), ck1:(seq of (char) +\u003e bool) \u003d (FHashtable`ContainsKey)[seq of (char), int](deletedh2) in ((h3 \u003d {|-\u003e}) \u003d\u003e pre_((FHashtable`Get)[seq of (char), int](deletedh2)aHashCode))","legal function application obligation:let aHashCode:(seq of (char) -\u003e seq of (char)) \u003d (lambda [x:seq of (char)] \u0026 (if (x \u003d \"\")\nthen \"\"\nelse (FSequence`Take)[char](1)(x))), h2:map (seq of (char)) to (map (seq of (char)) to (int)) \u003d (FHashtable`PutAll)[seq of (char), int]({|-\u003e})(aHashCode)({\"a\" |-\u003e 1, \"b\" |-\u003e 2, \"c\" |-\u003e 3}), h3:map (int) to (map (int) to (seq of (char))) \u003d (FHashtable`Clear)[int, seq of (char)](), deletedh2:map (seq of (char)) to (map (seq of (char)) to (int)) \u003d (FHashtable`Remove)[seq of (char), int](h2)(aHashCode)(\"b\"), c1:(int +\u003e bool) \u003d (FHashtable`Contains)[seq of (char), int](deletedh2), ck1:(seq of (char) +\u003e bool) \u003d (FHashtable`ContainsKey)[seq of (char), int](deletedh2) in ((h3 \u003d {|-\u003e}) \u003d\u003e (((FHashtable`Get)[seq of (char), int](deletedh2)(aHashCode)(\"b\") \u003d nil) \u003d\u003e pre_(c12)))","legal function application obligation:let aHashCode:(seq of (char) -\u003e seq of (char)) \u003d (lambda [x:seq of (char)] \u0026 (if (x \u003d \"\")\nthen \"\"\nelse (FSequence`Take)[char](1)(x))), h2:map (seq of (char)) to (map (seq of (char)) to (int)) \u003d (FHashtable`PutAll)[seq of (char), int]({|-\u003e})(aHashCode)({\"a\" |-\u003e 1, \"b\" |-\u003e 2, \"c\" |-\u003e 3}), h3:map (int) to (map (int) to (seq of (char))) \u003d (FHashtable`Clear)[int, seq of (char)](), deletedh2:map (seq of (char)) to (map (seq of (char)) to (int)) \u003d (FHashtable`Remove)[seq of (char), int](h2)(aHashCode)(\"b\"), c1:(int +\u003e bool) \u003d (FHashtable`Contains)[seq of (char), int](deletedh2), ck1:(seq of (char) +\u003e bool) \u003d (FHashtable`ContainsKey)[seq of (char), int](deletedh2) in ((h3 \u003d {|-\u003e}) \u003d\u003e (((FHashtable`Get)[seq of (char), int](deletedh2)(aHashCode)(\"b\") \u003d nil) \u003d\u003e ((c1(2) \u003d false) \u003d\u003e pre_(c11))))","legal function application obligation:let aHashCode:(seq of (char) -\u003e seq of (char)) \u003d (lambda [x:seq of (char)] \u0026 (if (x \u003d \"\")\nthen \"\"\nelse (FSequence`Take)[char](1)(x))), h2:map (seq of (char)) to (map (seq of (char)) to (int)) \u003d (FHashtable`PutAll)[seq of (char), int]({|-\u003e})(aHashCode)({\"a\" |-\u003e 1, \"b\" |-\u003e 2, \"c\" |-\u003e 3}), h3:map (int) to (map (int) to (seq of (char))) \u003d (FHashtable`Clear)[int, seq of (char)](), deletedh2:map (seq of (char)) to (map (seq of (char)) to (int)) \u003d (FHashtable`Remove)[seq of (char), int](h2)(aHashCode)(\"b\"), c1:(int +\u003e bool) \u003d (FHashtable`Contains)[seq of (char), int](deletedh2), ck1:(seq of (char) +\u003e bool) \u003d (FHashtable`ContainsKey)[seq of (char), int](deletedh2) in ((h3 \u003d {|-\u003e}) \u003d\u003e (((FHashtable`Get)[seq of (char), int](deletedh2)(aHashCode)(\"b\") \u003d nil) \u003d\u003e ((c1(2) \u003d false) \u003d\u003e (c1(1) \u003d\u003e pre_(c13)))))","legal function application obligation:let aHashCode:(seq of (char) -\u003e seq of (char)) \u003d (lambda [x:seq of (char)] \u0026 (if (x \u003d \"\")\nthen \"\"\nelse (FSequence`Take)[char](1)(x))), h2:map (seq of (char)) to (map (seq of (char)) to (int)) \u003d (FHashtable`PutAll)[seq of (char), int]({|-\u003e})(aHashCode)({\"a\" |-\u003e 1, \"b\" |-\u003e 2, \"c\" |-\u003e 3}), h3:map (int) to (map (int) to (seq of (char))) \u003d (FHashtable`Clear)[int, seq of (char)](), deletedh2:map (seq of (char)) to (map (seq of (char)) to (int)) \u003d (FHashtable`Remove)[seq of (char), int](h2)(aHashCode)(\"b\"), c1:(int +\u003e bool) \u003d (FHashtable`Contains)[seq of (char), int](deletedh2), ck1:(seq of (char) +\u003e bool) \u003d (FHashtable`ContainsKey)[seq of (char), int](deletedh2) in ((h3 \u003d {|-\u003e}) \u003d\u003e (((FHashtable`Get)[seq of (char), int](deletedh2)(aHashCode)(\"b\") \u003d nil) \u003d\u003e ((c1(2) \u003d false) \u003d\u003e (c1(1) \u003d\u003e (c1(3) \u003d\u003e pre_(ck1\"b\"))))))","legal function application obligation:let aHashCode:(seq of (char) -\u003e seq of (char)) \u003d (lambda [x:seq of (char)] \u0026 (if (x \u003d \"\")\nthen \"\"\nelse (FSequence`Take)[char](1)(x))), h2:map (seq of (char)) to (map (seq of (char)) to (int)) \u003d (FHashtable`PutAll)[seq of (char), int]({|-\u003e})(aHashCode)({\"a\" |-\u003e 1, \"b\" |-\u003e 2, \"c\" |-\u003e 3}), h3:map (int) to (map (int) to (seq of (char))) \u003d (FHashtable`Clear)[int, seq of (char)](), deletedh2:map (seq of (char)) to (map (seq of (char)) to (int)) \u003d (FHashtable`Remove)[seq of (char), int](h2)(aHashCode)(\"b\"), c1:(int +\u003e bool) \u003d (FHashtable`Contains)[seq of (char), int](deletedh2), ck1:(seq of (char) +\u003e bool) \u003d (FHashtable`ContainsKey)[seq of (char), int](deletedh2) in ((h3 \u003d {|-\u003e}) \u003d\u003e (((FHashtable`Get)[seq of (char), int](deletedh2)(aHashCode)(\"b\") \u003d nil) \u003d\u003e ((c1(2) \u003d false) \u003d\u003e (c1(1) \u003d\u003e (c1(3) \u003d\u003e ((ck1(\"b\") \u003d false) \u003d\u003e pre_(ck1\"a\")))))))","legal function application obligation:let aHashCode:(seq of (char) -\u003e seq of (char)) \u003d (lambda [x:seq of (char)] \u0026 (if (x \u003d \"\")\nthen \"\"\nelse (FSequence`Take)[char](1)(x))), h2:map (seq of (char)) to (map (seq of (char)) to (int)) \u003d (FHashtable`PutAll)[seq of (char), int]({|-\u003e})(aHashCode)({\"a\" |-\u003e 1, \"b\" |-\u003e 2, \"c\" |-\u003e 3}), h3:map (int) to (map (int) to (seq of (char))) \u003d (FHashtable`Clear)[int, seq of (char)](), deletedh2:map (seq of (char)) to (map (seq of (char)) to (int)) \u003d (FHashtable`Remove)[seq of (char), int](h2)(aHashCode)(\"b\"), c1:(int +\u003e bool) \u003d (FHashtable`Contains)[seq of (char), int](deletedh2), ck1:(seq of (char) +\u003e bool) \u003d (FHashtable`ContainsKey)[seq of (char), int](deletedh2) in ((h3 \u003d {|-\u003e}) \u003d\u003e (((FHashtable`Get)[seq of (char), int](deletedh2)(aHashCode)(\"b\") \u003d nil) \u003d\u003e ((c1(2) \u003d false) \u003d\u003e (c1(1) \u003d\u003e (c1(3) \u003d\u003e ((ck1(\"b\") \u003d false) \u003d\u003e (ck1(\"a\") \u003d\u003e pre_(ck1\"c\"))))))))","legal function application obligation:pre_(put({|-\u003e})(aHashCode)(1)\"Sahara\")","legal function application obligation:pre_(put({|-\u003e})(aHashCode)1)","legal function application obligation:pre_(put({|-\u003e})aHashCode)","legal function application obligation:pre_(put{|-\u003e})","legal function application obligation:pre_(put(p1)(aHashCode)(2)\"Bush\")","legal function application obligation:pre_(put(p1)(aHashCode)2)","legal function application obligation:pre_(put(p1)aHashCode)","legal function application obligation:pre_(putp1)","legal function application obligation:pre_(put(p2)(aHashCode)(2)\"Sato\")","legal function application obligation:pre_(put(p2)(aHashCode)2)","legal function application obligation:pre_(put(p2)aHashCode)","legal function application obligation:pre_(putp2)","legal function application obligation:pre_(put(p3)(aHashCode)(14)\"Sakoh\")","legal function application obligation:pre_(put(p3)(aHashCode)14)","legal function application obligation:pre_(put(p3)aHashCode)","legal function application obligation:pre_(putp3)","legal function application obligation:pre_((FHashtable`Get)[int, seq of (char)](p4)aHashCode)","legal function application obligation:let aHashCode:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), put:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e (seq of (char) +\u003e map (int) to (map (int) to (seq of (char))))))) \u003d (FHashtable`Put)[int, seq of (char)], p1:map (int) to (map (int) to (seq of (char))) \u003d put({|-\u003e})(aHashCode)(1)(\"Sahara\"), p2:map (int) to (map (int) to (seq of (char))) \u003d put(p1)(aHashCode)(2)(\"Bush\"), p3:map (int) to (map (int) to (seq of (char))) \u003d put(p2)(aHashCode)(2)(\"Sato\"), p4:map (int) to (map (int) to (seq of (char))) \u003d put(p3)(aHashCode)(14)(\"Sakoh\"), get:((int +\u003e int) +\u003e (int +\u003e [seq of (char)])) \u003d (FHashtable`Get)[int, seq of (char)](p4), g:(int +\u003e [seq of (char)]) \u003d (FHashtable`Get)[int, seq of (char)](p4)(aHashCode) in pre_(get(aHashCode)1)","legal function application obligation:let aHashCode:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), put:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e (seq of (char) +\u003e map (int) to (map (int) to (seq of (char))))))) \u003d (FHashtable`Put)[int, seq of (char)], p1:map (int) to (map (int) to (seq of (char))) \u003d put({|-\u003e})(aHashCode)(1)(\"Sahara\"), p2:map (int) to (map (int) to (seq of (char))) \u003d put(p1)(aHashCode)(2)(\"Bush\"), p3:map (int) to (map (int) to (seq of (char))) \u003d put(p2)(aHashCode)(2)(\"Sato\"), p4:map (int) to (map (int) to (seq of (char))) \u003d put(p3)(aHashCode)(14)(\"Sakoh\"), get:((int +\u003e int) +\u003e (int +\u003e [seq of (char)])) \u003d (FHashtable`Get)[int, seq of (char)](p4), g:(int +\u003e [seq of (char)]) \u003d (FHashtable`Get)[int, seq of (char)](p4)(aHashCode) in pre_(getaHashCode)","legal function application obligation:let aHashCode:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), put:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e (seq of (char) +\u003e map (int) to (map (int) to (seq of (char))))))) \u003d (FHashtable`Put)[int, seq of (char)], p1:map (int) to (map (int) to (seq of (char))) \u003d put({|-\u003e})(aHashCode)(1)(\"Sahara\"), p2:map (int) to (map (int) to (seq of (char))) \u003d put(p1)(aHashCode)(2)(\"Bush\"), p3:map (int) to (map (int) to (seq of (char))) \u003d put(p2)(aHashCode)(2)(\"Sato\"), p4:map (int) to (map (int) to (seq of (char))) \u003d put(p3)(aHashCode)(14)(\"Sakoh\"), get:((int +\u003e int) +\u003e (int +\u003e [seq of (char)])) \u003d (FHashtable`Get)[int, seq of (char)](p4), g:(int +\u003e [seq of (char)]) \u003d (FHashtable`Get)[int, seq of (char)](p4)(aHashCode) in ((get(aHashCode)(1) \u003d \"Sahara\") \u003d\u003e pre_(get(aHashCode)2))","legal function application obligation:let aHashCode:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), put:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e (seq of (char) +\u003e map (int) to (map (int) to (seq of (char))))))) \u003d (FHashtable`Put)[int, seq of (char)], p1:map (int) to (map (int) to (seq of (char))) \u003d put({|-\u003e})(aHashCode)(1)(\"Sahara\"), p2:map (int) to (map (int) to (seq of (char))) \u003d put(p1)(aHashCode)(2)(\"Bush\"), p3:map (int) to (map (int) to (seq of (char))) \u003d put(p2)(aHashCode)(2)(\"Sato\"), p4:map (int) to (map (int) to (seq of (char))) \u003d put(p3)(aHashCode)(14)(\"Sakoh\"), get:((int +\u003e int) +\u003e (int +\u003e [seq of (char)])) \u003d (FHashtable`Get)[int, seq of (char)](p4), g:(int +\u003e [seq of (char)]) \u003d (FHashtable`Get)[int, seq of (char)](p4)(aHashCode) in ((get(aHashCode)(1) \u003d \"Sahara\") \u003d\u003e pre_(getaHashCode))","legal function application obligation:let aHashCode:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), put:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e (seq of (char) +\u003e map (int) to (map (int) to (seq of (char))))))) \u003d (FHashtable`Put)[int, seq of (char)], p1:map (int) to (map (int) to (seq of (char))) \u003d put({|-\u003e})(aHashCode)(1)(\"Sahara\"), p2:map (int) to (map (int) to (seq of (char))) \u003d put(p1)(aHashCode)(2)(\"Bush\"), p3:map (int) to (map (int) to (seq of (char))) \u003d put(p2)(aHashCode)(2)(\"Sato\"), p4:map (int) to (map (int) to (seq of (char))) \u003d put(p3)(aHashCode)(14)(\"Sakoh\"), get:((int +\u003e int) +\u003e (int +\u003e [seq of (char)])) \u003d (FHashtable`Get)[int, seq of (char)](p4), g:(int +\u003e [seq of (char)]) \u003d (FHashtable`Get)[int, seq of (char)](p4)(aHashCode) in ((get(aHashCode)(1) \u003d \"Sahara\") \u003d\u003e ((get(aHashCode)(2) \u003d \"Sato\") \u003d\u003e pre_(get(aHashCode)14)))","legal function application obligation:let aHashCode:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), put:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e (seq of (char) +\u003e map (int) to (map (int) to (seq of (char))))))) \u003d (FHashtable`Put)[int, seq of (char)], p1:map (int) to (map (int) to (seq of (char))) \u003d put({|-\u003e})(aHashCode)(1)(\"Sahara\"), p2:map (int) to (map (int) to (seq of (char))) \u003d put(p1)(aHashCode)(2)(\"Bush\"), p3:map (int) to (map (int) to (seq of (char))) \u003d put(p2)(aHashCode)(2)(\"Sato\"), p4:map (int) to (map (int) to (seq of (char))) \u003d put(p3)(aHashCode)(14)(\"Sakoh\"), get:((int +\u003e int) +\u003e (int +\u003e [seq of (char)])) \u003d (FHashtable`Get)[int, seq of (char)](p4), g:(int +\u003e [seq of (char)]) \u003d (FHashtable`Get)[int, seq of (char)](p4)(aHashCode) in ((get(aHashCode)(1) \u003d \"Sahara\") \u003d\u003e ((get(aHashCode)(2) \u003d \"Sato\") \u003d\u003e pre_(getaHashCode)))","legal function application obligation:let aHashCode:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), put:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e (seq of (char) +\u003e map (int) to (map (int) to (seq of (char))))))) \u003d (FHashtable`Put)[int, seq of (char)], p1:map (int) to (map (int) to (seq of (char))) \u003d put({|-\u003e})(aHashCode)(1)(\"Sahara\"), p2:map (int) to (map (int) to (seq of (char))) \u003d put(p1)(aHashCode)(2)(\"Bush\"), p3:map (int) to (map (int) to (seq of (char))) \u003d put(p2)(aHashCode)(2)(\"Sato\"), p4:map (int) to (map (int) to (seq of (char))) \u003d put(p3)(aHashCode)(14)(\"Sakoh\"), get:((int +\u003e int) +\u003e (int +\u003e [seq of (char)])) \u003d (FHashtable`Get)[int, seq of (char)](p4), g:(int +\u003e [seq of (char)]) \u003d (FHashtable`Get)[int, seq of (char)](p4)(aHashCode) in ((get(aHashCode)(1) \u003d \"Sahara\") \u003d\u003e ((get(aHashCode)(2) \u003d \"Sato\") \u003d\u003e ((get(aHashCode)(14) \u003d \"Sakoh\") \u003d\u003e pre_(get(aHashCode)99))))","legal function application obligation:let aHashCode:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), put:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e (seq of (char) +\u003e map (int) to (map (int) to (seq of (char))))))) \u003d (FHashtable`Put)[int, seq of (char)], p1:map (int) to (map (int) to (seq of (char))) \u003d put({|-\u003e})(aHashCode)(1)(\"Sahara\"), p2:map (int) to (map (int) to (seq of (char))) \u003d put(p1)(aHashCode)(2)(\"Bush\"), p3:map (int) to (map (int) to (seq of (char))) \u003d put(p2)(aHashCode)(2)(\"Sato\"), p4:map (int) to (map (int) to (seq of (char))) \u003d put(p3)(aHashCode)(14)(\"Sakoh\"), get:((int +\u003e int) +\u003e (int +\u003e [seq of (char)])) \u003d (FHashtable`Get)[int, seq of (char)](p4), g:(int +\u003e [seq of (char)]) \u003d (FHashtable`Get)[int, seq of (char)](p4)(aHashCode) in ((get(aHashCode)(1) \u003d \"Sahara\") \u003d\u003e ((get(aHashCode)(2) \u003d \"Sato\") \u003d\u003e ((get(aHashCode)(14) \u003d \"Sakoh\") \u003d\u003e pre_(getaHashCode))))","legal function application obligation:let aHashCode:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), put:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e (seq of (char) +\u003e map (int) to (map (int) to (seq of (char))))))) \u003d (FHashtable`Put)[int, seq of (char)], p1:map (int) to (map (int) to (seq of (char))) \u003d put({|-\u003e})(aHashCode)(1)(\"Sahara\"), p2:map (int) to (map (int) to (seq of (char))) \u003d put(p1)(aHashCode)(2)(\"Bush\"), p3:map (int) to (map (int) to (seq of (char))) \u003d put(p2)(aHashCode)(2)(\"Sato\"), p4:map (int) to (map (int) to (seq of (char))) \u003d put(p3)(aHashCode)(14)(\"Sakoh\"), get:((int +\u003e int) +\u003e (int +\u003e [seq of (char)])) \u003d (FHashtable`Get)[int, seq of (char)](p4), g:(int +\u003e [seq of (char)]) \u003d (FHashtable`Get)[int, seq of (char)](p4)(aHashCode) in ((get(aHashCode)(1) \u003d \"Sahara\") \u003d\u003e ((get(aHashCode)(2) \u003d \"Sato\") \u003d\u003e ((get(aHashCode)(14) \u003d \"Sakoh\") \u003d\u003e ((get(aHashCode)(99) \u003d nil) \u003d\u003e pre_((FSequence`Fmap)[int, seq of (char)](g)[1, 14])))))","type compatibility obligation:let aHashCode:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), put:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e (seq of (char) +\u003e map (int) to (map (int) to (seq of (char))))))) \u003d (FHashtable`Put)[int, seq of (char)], p1:map (int) to (map (int) to (seq of (char))) \u003d put({|-\u003e})(aHashCode)(1)(\"Sahara\"), p2:map (int) to (map (int) to (seq of (char))) \u003d put(p1)(aHashCode)(2)(\"Bush\"), p3:map (int) to (map (int) to (seq of (char))) \u003d put(p2)(aHashCode)(2)(\"Sato\"), p4:map (int) to (map (int) to (seq of (char))) \u003d put(p3)(aHashCode)(14)(\"Sakoh\"), get:((int +\u003e int) +\u003e (int +\u003e [seq of (char)])) \u003d (FHashtable`Get)[int, seq of (char)](p4), g:(int +\u003e [seq of (char)]) \u003d (FHashtable`Get)[int, seq of (char)](p4)(aHashCode) in ((get(aHashCode)(1) \u003d \"Sahara\") \u003d\u003e ((get(aHashCode)(2) \u003d \"Sato\") \u003d\u003e ((get(aHashCode)(14) \u003d \"Sakoh\") \u003d\u003e ((get(aHashCode)(99) \u003d nil) \u003d\u003e is_(g, (int +\u003e seq of (char)))))))","legal function application obligation:let aHashCode:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), put:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e (seq of (char) +\u003e map (int) to (map (int) to (seq of (char))))))) \u003d (FHashtable`Put)[int, seq of (char)], p1:map (int) to (map (int) to (seq of (char))) \u003d put({|-\u003e})(aHashCode)(1)(\"Sahara\"), p2:map (int) to (map (int) to (seq of (char))) \u003d put(p1)(aHashCode)(2)(\"Bush\"), p3:map (int) to (map (int) to (seq of (char))) \u003d put(p2)(aHashCode)(2)(\"Sato\"), p4:map (int) to (map (int) to (seq of (char))) \u003d put(p3)(aHashCode)(14)(\"Sakoh\"), get:((int +\u003e int) +\u003e (int +\u003e [seq of (char)])) \u003d (FHashtable`Get)[int, seq of (char)](p4), g:(int +\u003e [seq of (char)]) \u003d (FHashtable`Get)[int, seq of (char)](p4)(aHashCode) in ((get(aHashCode)(1) \u003d \"Sahara\") \u003d\u003e ((get(aHashCode)(2) \u003d \"Sato\") \u003d\u003e ((get(aHashCode)(14) \u003d \"Sakoh\") \u003d\u003e ((get(aHashCode)(99) \u003d nil) \u003d\u003e (((FSequence`Fmap)[int, seq of (char)](g)([1, 14]) \u003d [\"Sahara\", \"Sakoh\"]) \u003d\u003e pre_((FSequence`Fmap)[int, seq of (char)](g)[1, 2]))))))","type compatibility obligation:let aHashCode:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), put:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e (seq of (char) +\u003e map (int) to (map (int) to (seq of (char))))))) \u003d (FHashtable`Put)[int, seq of (char)], p1:map (int) to (map (int) to (seq of (char))) \u003d put({|-\u003e})(aHashCode)(1)(\"Sahara\"), p2:map (int) to (map (int) to (seq of (char))) \u003d put(p1)(aHashCode)(2)(\"Bush\"), p3:map (int) to (map (int) to (seq of (char))) \u003d put(p2)(aHashCode)(2)(\"Sato\"), p4:map (int) to (map (int) to (seq of (char))) \u003d put(p3)(aHashCode)(14)(\"Sakoh\"), get:((int +\u003e int) +\u003e (int +\u003e [seq of (char)])) \u003d (FHashtable`Get)[int, seq of (char)](p4), g:(int +\u003e [seq of (char)]) \u003d (FHashtable`Get)[int, seq of (char)](p4)(aHashCode) in ((get(aHashCode)(1) \u003d \"Sahara\") \u003d\u003e ((get(aHashCode)(2) \u003d \"Sato\") \u003d\u003e ((get(aHashCode)(14) \u003d \"Sakoh\") \u003d\u003e ((get(aHashCode)(99) \u003d nil) \u003d\u003e (((FSequence`Fmap)[int, seq of (char)](g)([1, 14]) \u003d [\"Sahara\", \"Sakoh\"]) \u003d\u003e is_(g, (int +\u003e seq of (char))))))))","legal function application obligation:pre_(put({|-\u003e})(aHashCode)(1)\"Sahara\")","legal function application obligation:pre_(put({|-\u003e})(aHashCode)1)","legal function application obligation:pre_(put({|-\u003e})aHashCode)","legal function application obligation:pre_(put{|-\u003e})","legal function application obligation:pre_(put(p1)(aHashCode)(2)\"Bush\")","legal function application obligation:pre_(put(p1)(aHashCode)2)","legal function application obligation:pre_(put(p1)aHashCode)","legal function application obligation:pre_(putp1)","legal function application obligation:pre_(put(p2)(aHashCode)(2)\"Sato\")","legal function application obligation:pre_(put(p2)(aHashCode)2)","legal function application obligation:pre_(put(p2)aHashCode)","legal function application obligation:pre_(putp2)","legal function application obligation:pre_(put(p3)(aHashCode)(14)\"Sakoh\")","legal function application obligation:pre_(put(p3)(aHashCode)14)","legal function application obligation:pre_(put(p3)aHashCode)","legal function application obligation:pre_(putp3)","legal function application obligation:let aHashCode:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), put:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e (seq of (char) +\u003e map (int) to (map (int) to (seq of (char))))))) \u003d (FHashtable`Put)[int, seq of (char)], p1:map (int) to (map (int) to (seq of (char))) \u003d put({|-\u003e})(aHashCode)(1)(\"Sahara\"), p2:map (int) to (map (int) to (seq of (char))) \u003d put(p1)(aHashCode)(2)(\"Bush\"), p3:map (int) to (map (int) to (seq of (char))) \u003d put(p2)(aHashCode)(2)(\"Sato\"), p4:map (int) to (map (int) to (seq of (char))) \u003d put(p3)(aHashCode)(14)(\"Sakoh\"), k:(map (int) to (map (int) to (seq of (char))) +\u003e set of (int)) \u003d (FHashtable`KeySet)[int, seq of (char)], v:(map (int) to (map (int) to (seq of (char))) +\u003e set of (seq of (char))) \u003d (FHashtable`ValueSet)[int, seq of (char)] in pre_(kp1)","legal function application obligation:let aHashCode:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), put:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e (seq of (char) +\u003e map (int) to (map (int) to (seq of (char))))))) \u003d (FHashtable`Put)[int, seq of (char)], p1:map (int) to (map (int) to (seq of (char))) \u003d put({|-\u003e})(aHashCode)(1)(\"Sahara\"), p2:map (int) to (map (int) to (seq of (char))) \u003d put(p1)(aHashCode)(2)(\"Bush\"), p3:map (int) to (map (int) to (seq of (char))) \u003d put(p2)(aHashCode)(2)(\"Sato\"), p4:map (int) to (map (int) to (seq of (char))) \u003d put(p3)(aHashCode)(14)(\"Sakoh\"), k:(map (int) to (map (int) to (seq of (char))) +\u003e set of (int)) \u003d (FHashtable`KeySet)[int, seq of (char)], v:(map (int) to (map (int) to (seq of (char))) +\u003e set of (seq of (char))) \u003d (FHashtable`ValueSet)[int, seq of (char)] in ((k(p1) \u003d {1}) \u003d\u003e pre_(vp1))","legal function application obligation:let aHashCode:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), put:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e (seq of (char) +\u003e map (int) to (map (int) to (seq of (char))))))) \u003d (FHashtable`Put)[int, seq of (char)], p1:map (int) to (map (int) to (seq of (char))) \u003d put({|-\u003e})(aHashCode)(1)(\"Sahara\"), p2:map (int) to (map (int) to (seq of (char))) \u003d put(p1)(aHashCode)(2)(\"Bush\"), p3:map (int) to (map (int) to (seq of (char))) \u003d put(p2)(aHashCode)(2)(\"Sato\"), p4:map (int) to (map (int) to (seq of (char))) \u003d put(p3)(aHashCode)(14)(\"Sakoh\"), k:(map (int) to (map (int) to (seq of (char))) +\u003e set of (int)) \u003d (FHashtable`KeySet)[int, seq of (char)], v:(map (int) to (map (int) to (seq of (char))) +\u003e set of (seq of (char))) \u003d (FHashtable`ValueSet)[int, seq of (char)] in ((k(p1) \u003d {1}) \u003d\u003e ((v(p1) \u003d {\"Sahara\"}) \u003d\u003e pre_(kp2)))","legal function application obligation:let aHashCode:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), put:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e (seq of (char) +\u003e map (int) to (map (int) to (seq of (char))))))) \u003d (FHashtable`Put)[int, seq of (char)], p1:map (int) to (map (int) to (seq of (char))) \u003d put({|-\u003e})(aHashCode)(1)(\"Sahara\"), p2:map (int) to (map (int) to (seq of (char))) \u003d put(p1)(aHashCode)(2)(\"Bush\"), p3:map (int) to (map (int) to (seq of (char))) \u003d put(p2)(aHashCode)(2)(\"Sato\"), p4:map (int) to (map (int) to (seq of (char))) \u003d put(p3)(aHashCode)(14)(\"Sakoh\"), k:(map (int) to (map (int) to (seq of (char))) +\u003e set of (int)) \u003d (FHashtable`KeySet)[int, seq of (char)], v:(map (int) to (map (int) to (seq of (char))) +\u003e set of (seq of (char))) \u003d (FHashtable`ValueSet)[int, seq of (char)] in ((k(p1) \u003d {1}) \u003d\u003e ((v(p1) \u003d {\"Sahara\"}) \u003d\u003e ((k(p2) \u003d {1, 2}) \u003d\u003e pre_(vp2))))","legal function application obligation:let aHashCode:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), put:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e (seq of (char) +\u003e map (int) to (map (int) to (seq of (char))))))) \u003d (FHashtable`Put)[int, seq of (char)], p1:map (int) to (map (int) to (seq of (char))) \u003d put({|-\u003e})(aHashCode)(1)(\"Sahara\"), p2:map (int) to (map (int) to (seq of (char))) \u003d put(p1)(aHashCode)(2)(\"Bush\"), p3:map (int) to (map (int) to (seq of (char))) \u003d put(p2)(aHashCode)(2)(\"Sato\"), p4:map (int) to (map (int) to (seq of (char))) \u003d put(p3)(aHashCode)(14)(\"Sakoh\"), k:(map (int) to (map (int) to (seq of (char))) +\u003e set of (int)) \u003d (FHashtable`KeySet)[int, seq of (char)], v:(map (int) to (map (int) to (seq of (char))) +\u003e set of (seq of (char))) \u003d (FHashtable`ValueSet)[int, seq of (char)] in ((k(p1) \u003d {1}) \u003d\u003e ((v(p1) \u003d {\"Sahara\"}) \u003d\u003e ((k(p2) \u003d {1, 2}) \u003d\u003e ((v(p2) \u003d {\"Sahara\", \"Bush\"}) \u003d\u003e pre_(kp4)))))","legal function application obligation:let aHashCode:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), put:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e (seq of (char) +\u003e map (int) to (map (int) to (seq of (char))))))) \u003d (FHashtable`Put)[int, seq of (char)], p1:map (int) to (map (int) to (seq of (char))) \u003d put({|-\u003e})(aHashCode)(1)(\"Sahara\"), p2:map (int) to (map (int) to (seq of (char))) \u003d put(p1)(aHashCode)(2)(\"Bush\"), p3:map (int) to (map (int) to (seq of (char))) \u003d put(p2)(aHashCode)(2)(\"Sato\"), p4:map (int) to (map (int) to (seq of (char))) \u003d put(p3)(aHashCode)(14)(\"Sakoh\"), k:(map (int) to (map (int) to (seq of (char))) +\u003e set of (int)) \u003d (FHashtable`KeySet)[int, seq of (char)], v:(map (int) to (map (int) to (seq of (char))) +\u003e set of (seq of (char))) \u003d (FHashtable`ValueSet)[int, seq of (char)] in ((k(p1) \u003d {1}) \u003d\u003e ((v(p1) \u003d {\"Sahara\"}) \u003d\u003e ((k(p2) \u003d {1, 2}) \u003d\u003e ((v(p2) \u003d {\"Sahara\", \"Bush\"}) \u003d\u003e ((k(p4) \u003d {1, 2, 14}) \u003d\u003e pre_(vp4))))))","legal function application obligation:pre_((FHashtable`PutAll)[int, seq of (char)]({|-\u003e})(aHashCode1){1 |-\u003e \"SaharaShin\", 2 |-\u003e \"SatoKei\", 14 |-\u003e \"SakohHiroshi\", 27 |-\u003e \"NishikawaNoriko\"})","legal function application obligation:pre_((FHashtable`PutAll)[int, seq of (char)]({|-\u003e})aHashCode1)","enumeration map injectivity obligation:(forall m1, m2 in set {{1 |-\u003e \"SaharaShin\"}, {2 |-\u003e \"SatoKei\"}, {14 |-\u003e \"SakohHiroshi\"}, {27 |-\u003e \"NishikawaNoriko\"}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","legal function application obligation:pre_((FHashtable`Remove)[int, seq of (char)](h1)(aHashCode1)14)","legal function application obligation:pre_((FHashtable`Remove)[int, seq of (char)](h1)aHashCode1)","legal function application obligation:pre_((FHashtable`PutAll)[int, seq of (char)]({|-\u003e})(aHashCode1){1 |-\u003e \"SaharaShin\", 2 |-\u003e \"SatoKei\", 14 |-\u003e \"SakohHiroshi\"})","legal function application obligation:pre_((FHashtable`PutAll)[int, seq of (char)]({|-\u003e})aHashCode1)","enumeration map injectivity obligation:(forall m1, m2 in set {{1 |-\u003e \"SaharaShin\"}, {2 |-\u003e \"SatoKei\"}, {14 |-\u003e \"SakohHiroshi\"}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","legal function application obligation:pre_(remove(h1)(aHashCode1)1)","legal function application obligation:pre_(remove(h1)aHashCode1)","legal function application obligation:pre_(removeh1)","legal function application obligation:pre_(remove(h2)(aHashCode1)2)","legal function application obligation:pre_(remove(h2)aHashCode1)","legal function application obligation:pre_(removeh2)","legal function application obligation:pre_(remove(h3)(aHashCode1)14)","legal function application obligation:pre_(remove(h3)aHashCode1)","legal function application obligation:pre_(removeh3)","legal function application obligation:let aHashCode1:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), remove:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e map (int) to (map (int) to (seq of (char)))))) \u003d (FHashtable`Remove)[int, seq of (char)], h1:map (int) to (map (int) to (seq of (char))) \u003d (FHashtable`PutAll)[int, seq of (char)]({|-\u003e})(aHashCode1)({1 |-\u003e \"SaharaShin\", 2 |-\u003e \"SatoKei\", 14 |-\u003e \"SakohHiroshi\"}), h2:map (int) to (map (int) to (seq of (char))) \u003d remove(h1)(aHashCode1)(1), h3:map (int) to (map (int) to (seq of (char))) \u003d remove(h2)(aHashCode1)(2), h4:map (int) to (map (int) to (seq of (char))) \u003d remove(h3)(aHashCode1)(14), isempty:(map (int) to (map (int) to (seq of (char))) +\u003e bool) \u003d (FHashtable`IsEmpty)[int, seq of (char)], size:(map (int) to (map (int) to (seq of (char))) +\u003e nat) \u003d (FHashtable`Size)[int, seq of (char)] in pre_(isemptyh4)","legal function application obligation:let aHashCode1:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), remove:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e map (int) to (map (int) to (seq of (char)))))) \u003d (FHashtable`Remove)[int, seq of (char)], h1:map (int) to (map (int) to (seq of (char))) \u003d (FHashtable`PutAll)[int, seq of (char)]({|-\u003e})(aHashCode1)({1 |-\u003e \"SaharaShin\", 2 |-\u003e \"SatoKei\", 14 |-\u003e \"SakohHiroshi\"}), h2:map (int) to (map (int) to (seq of (char))) \u003d remove(h1)(aHashCode1)(1), h3:map (int) to (map (int) to (seq of (char))) \u003d remove(h2)(aHashCode1)(2), h4:map (int) to (map (int) to (seq of (char))) \u003d remove(h3)(aHashCode1)(14), isempty:(map (int) to (map (int) to (seq of (char))) +\u003e bool) \u003d (FHashtable`IsEmpty)[int, seq of (char)], size:(map (int) to (map (int) to (seq of (char))) +\u003e nat) \u003d (FHashtable`Size)[int, seq of (char)] in (isempty(h4) \u003d\u003e pre_(sizeh4))","legal function application obligation:let aHashCode1:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), remove:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e map (int) to (map (int) to (seq of (char)))))) \u003d (FHashtable`Remove)[int, seq of (char)], h1:map (int) to (map (int) to (seq of (char))) \u003d (FHashtable`PutAll)[int, seq of (char)]({|-\u003e})(aHashCode1)({1 |-\u003e \"SaharaShin\", 2 |-\u003e \"SatoKei\", 14 |-\u003e \"SakohHiroshi\"}), h2:map (int) to (map (int) to (seq of (char))) \u003d remove(h1)(aHashCode1)(1), h3:map (int) to (map (int) to (seq of (char))) \u003d remove(h2)(aHashCode1)(2), h4:map (int) to (map (int) to (seq of (char))) \u003d remove(h3)(aHashCode1)(14), isempty:(map (int) to (map (int) to (seq of (char))) +\u003e bool) \u003d (FHashtable`IsEmpty)[int, seq of (char)], size:(map (int) to (map (int) to (seq of (char))) +\u003e nat) \u003d (FHashtable`Size)[int, seq of (char)] in (isempty(h4) \u003d\u003e ((size(h4) \u003d 0) \u003d\u003e pre_(isemptyh3)))","legal function application obligation:let aHashCode1:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), remove:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e map (int) to (map (int) to (seq of (char)))))) \u003d (FHashtable`Remove)[int, seq of (char)], h1:map (int) to (map (int) to (seq of (char))) \u003d (FHashtable`PutAll)[int, seq of (char)]({|-\u003e})(aHashCode1)({1 |-\u003e \"SaharaShin\", 2 |-\u003e \"SatoKei\", 14 |-\u003e \"SakohHiroshi\"}), h2:map (int) to (map (int) to (seq of (char))) \u003d remove(h1)(aHashCode1)(1), h3:map (int) to (map (int) to (seq of (char))) \u003d remove(h2)(aHashCode1)(2), h4:map (int) to (map (int) to (seq of (char))) \u003d remove(h3)(aHashCode1)(14), isempty:(map (int) to (map (int) to (seq of (char))) +\u003e bool) \u003d (FHashtable`IsEmpty)[int, seq of (char)], size:(map (int) to (map (int) to (seq of (char))) +\u003e nat) \u003d (FHashtable`Size)[int, seq of (char)] in (isempty(h4) \u003d\u003e ((size(h4) \u003d 0) \u003d\u003e ((isempty(h3) \u003d false) \u003d\u003e pre_(sizeh3))))","legal function application obligation:let aHashCode1:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), remove:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e map (int) to (map (int) to (seq of (char)))))) \u003d (FHashtable`Remove)[int, seq of (char)], h1:map (int) to (map (int) to (seq of (char))) \u003d (FHashtable`PutAll)[int, seq of (char)]({|-\u003e})(aHashCode1)({1 |-\u003e \"SaharaShin\", 2 |-\u003e \"SatoKei\", 14 |-\u003e \"SakohHiroshi\"}), h2:map (int) to (map (int) to (seq of (char))) \u003d remove(h1)(aHashCode1)(1), h3:map (int) to (map (int) to (seq of (char))) \u003d remove(h2)(aHashCode1)(2), h4:map (int) to (map (int) to (seq of (char))) \u003d remove(h3)(aHashCode1)(14), isempty:(map (int) to (map (int) to (seq of (char))) +\u003e bool) \u003d (FHashtable`IsEmpty)[int, seq of (char)], size:(map (int) to (map (int) to (seq of (char))) +\u003e nat) \u003d (FHashtable`Size)[int, seq of (char)] in (isempty(h4) \u003d\u003e ((size(h4) \u003d 0) \u003d\u003e ((isempty(h3) \u003d false) \u003d\u003e ((size(h3) \u003d 1) \u003d\u003e pre_(sizeh2)))))","legal function application obligation:let aHashCode1:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), remove:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e map (int) to (map (int) to (seq of (char)))))) \u003d (FHashtable`Remove)[int, seq of (char)], h1:map (int) to (map (int) to (seq of (char))) \u003d (FHashtable`PutAll)[int, seq of (char)]({|-\u003e})(aHashCode1)({1 |-\u003e \"SaharaShin\", 2 |-\u003e \"SatoKei\", 14 |-\u003e \"SakohHiroshi\"}), h2:map (int) to (map (int) to (seq of (char))) \u003d remove(h1)(aHashCode1)(1), h3:map (int) to (map (int) to (seq of (char))) \u003d remove(h2)(aHashCode1)(2), h4:map (int) to (map (int) to (seq of (char))) \u003d remove(h3)(aHashCode1)(14), isempty:(map (int) to (map (int) to (seq of (char))) +\u003e bool) \u003d (FHashtable`IsEmpty)[int, seq of (char)], size:(map (int) to (map (int) to (seq of (char))) +\u003e nat) \u003d (FHashtable`Size)[int, seq of (char)] in (isempty(h4) \u003d\u003e ((size(h4) \u003d 0) \u003d\u003e ((isempty(h3) \u003d false) \u003d\u003e ((size(h3) \u003d 1) \u003d\u003e ((size(h2) \u003d 2) \u003d\u003e pre_(sizeh1))))))","legal function application obligation:(forall akey:Object, aValue:Object \u0026 pre_((akey.hashCode)))","legal map application obligation:(forall akey:Object, aValue:Object \u0026 (hashcode in set (dom buckets)))","map compatible obligation:(forall akey:Object, aValue:Object \u0026 (forall ldom1 in set (dom buckets), rdom2 in set (dom {hashcode |-\u003e {akey |-\u003e aValue}}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (buckets(ldom1) \u003d {hashcode |-\u003e {akey |-\u003e aValue}}(rdom2)))))","legal map application obligation:(forall aContents:Contents \u0026 (key in set (dom aContents)))","legal function application obligation:(forall key:Object \u0026 pre_((key.hashCode)))","legal map application obligation:(forall key:Object \u0026 (hashcode in set (dom buckets)))","legal function application obligation:(forall key:Object \u0026 pre_((key.equals)aKey))","legal map application obligation:(forall key:Object \u0026 (aKey in set (dom aContents)))","legal function application obligation:(forall key:Object \u0026 pre_((key.hashCode)))","legal map application obligation:(forall key:Object \u0026 (hashcode in set (dom buckets)))","legal map application obligation:(forall anObject:Object \u0026 let buckets:Bucket \u003d (self.getBuckets)() in (forall hashcode in set (dom buckets) \u0026 (hashcode in set (dom buckets))))","legal function application obligation:(forall anObject:Object \u0026 let buckets:Bucket \u003d (self.getBuckets)() in (forall hashcode in set (dom buckets) \u0026 let aContents:Contents \u003d buckets(hashcode) in (forall key in set (dom aContents) \u0026 pre_((aContents(key).equals)anObject))))","legal map application obligation:(forall anObject:Object \u0026 let buckets:Bucket \u003d (self.getBuckets)() in (forall hashcode in set (dom buckets) \u0026 let aContents:Contents \u003d buckets(hashcode) in (forall key in set (dom aContents) \u0026 (key in set (dom aContents)))))","legal map application obligation:(forall aKey:Object \u0026 let buckets:Bucket \u003d (self.getBuckets)() in (forall hashcode in set (dom buckets) \u0026 (hashcode in set (dom buckets))))","legal function application obligation:(forall aKey:Object \u0026 let buckets:Bucket \u003d (self.getBuckets)() in (forall hashcode in set (dom buckets) \u0026 (forall key in set (dom buckets(hashcode)) \u0026 pre_((aKey.equals)key))))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aKey:@T1, aValue:@T2 \u0026 pre_(aHashCodeaKey))","legal map application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aKey:@T1, aValue:@T2 \u0026 let hashcode:@T1 \u003d aHashCode(aKey) in ((hashcode in set (dom aHashtable)) \u003d\u003e (hashcode in set (dom aHashtable))))","map compatible obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aKey:@T1, aValue:@T2 \u0026 let hashcode:@T1 \u003d aHashCode(aKey) in ((not (hashcode in set (dom aHashtable))) \u003d\u003e (forall ldom1 in set (dom aHashtable), rdom2 in set (dom {hashcode |-\u003e {aKey |-\u003e aValue}}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (aHashtable(ldom1) \u003d {hashcode |-\u003e {aKey |-\u003e aValue}}(rdom2))))))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aMap:map (@T1) to (@T2) \u0026 pre_((PutAllAux)[@T1, @T2](aHashtable)(aHashCode)(aMap)(dom aMap)))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aMap:map (@T1) to (@T2) \u0026 pre_((PutAllAux)[@T1, @T2](aHashtable)(aHashCode)aMap))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aMap:map (@T1) to (@T2) \u0026 pre_((PutAllAux)[@T1, @T2](aHashtable)aHashCode))","let be st existence obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aMap:map (@T1) to (@T2), aKeySet:set of (@T1) \u0026 ((not (aKeySet \u003d {})) \u003d\u003e (exists aKey in set aKeySet \u0026 true)))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aMap:map (@T1) to (@T2), aKeySet:set of (@T1) \u0026 ((not (aKeySet \u003d {})) \u003d\u003e (forall aKey in set aKeySet \u0026 pre_((Put)[@T1, @T2](aHashtable)(aHashCode)(aKey)aMap(aKey)))))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aMap:map (@T1) to (@T2), aKeySet:set of (@T1) \u0026 ((not (aKeySet \u003d {})) \u003d\u003e (forall aKey in set aKeySet \u0026 pre_((Put)[@T1, @T2](aHashtable)(aHashCode)aKey))))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aMap:map (@T1) to (@T2), aKeySet:set of (@T1) \u0026 ((not (aKeySet \u003d {})) \u003d\u003e (forall aKey in set aKeySet \u0026 pre_((Put)[@T1, @T2](aHashtable)aHashCode))))","legal map application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aMap:map (@T1) to (@T2), aKeySet:set of (@T1) \u0026 ((not (aKeySet \u003d {})) \u003d\u003e (forall aKey in set aKeySet \u0026 (aKey in set (dom aMap)))))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aMap:map (@T1) to (@T2), aKeySet:set of (@T1) \u0026 ((not (aKeySet \u003d {})) \u003d\u003e (forall aKey in set aKeySet \u0026 let newHashtable:map (@T1) to (map (@T1) to (@T2)) \u003d (Put)[@T1, @T2](aHashtable)(aHashCode)(aKey)(aMap(aKey)) in pre_((PutAllAux)[@T1, @T2](newHashtable)(aHashCode)(aMap)(aKeySet \\ {aKey})))))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aMap:map (@T1) to (@T2), aKeySet:set of (@T1) \u0026 ((not (aKeySet \u003d {})) \u003d\u003e (forall aKey in set aKeySet \u0026 let newHashtable:map (@T1) to (map (@T1) to (@T2)) \u003d (Put)[@T1, @T2](aHashtable)(aHashCode)(aKey)(aMap(aKey)) in pre_((PutAllAux)[@T1, @T2](newHashtable)(aHashCode)aMap))))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aMap:map (@T1) to (@T2), aKeySet:set of (@T1) \u0026 ((not (aKeySet \u003d {})) \u003d\u003e (forall aKey in set aKeySet \u0026 let newHashtable:map (@T1) to (map (@T1) to (@T2)) \u003d (Put)[@T1, @T2](aHashtable)(aHashCode)(aKey)(aMap(aKey)) in pre_((PutAllAux)[@T1, @T2](newHashtable)aHashCode))))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aKey:@T1 \u0026 pre_(aHashCodeaKey))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aKey:@T1 \u0026 let hashcode:@T1 \u003d aHashCode(aKey) in ((hashcode in set (dom aHashtable)) \u003d\u003e pre_((Map`Get)[@T1, @T2](aHashtable(hashcode))aKey)))","legal map application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aKey:@T1 \u0026 let hashcode:@T1 \u003d aHashCode(aKey) in ((hashcode in set (dom aHashtable)) \u003d\u003e (hashcode in set (dom aHashtable))))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aKey:@T1 \u0026 pre_(aHashCodeaKey))","comprehension map injectivity obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aKey:@T1 \u0026 let hashcode:@T1 \u003d aHashCode(aKey) in (forall m1, m2 in set {{h |-\u003e ({aKey} \u003c-: aHashtable(hashcode))} | h in set {hashcode}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4))))))","legal map application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aKey:@T1 \u0026 let hashcode:@T1 \u003d aHashCode(aKey) in (forall h in set {hashcode} \u0026 (hashcode in set (dom aHashtable))))","map compatible obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aKey:@T1 \u0026 let hashcode:@T1 \u003d aHashCode(aKey) in (forall ldom1 in set (dom {h |-\u003e ({aKey} \u003c-: aHashtable(hashcode)) | h in set {hashcode}}), rdom2 in set (dom ({hashcode} \u003c-: aHashtable)) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e ({h |-\u003e ({aKey} \u003c-: aHashtable(hashcode)) | h in set {hashcode}}(ldom1) \u003d ({hashcode} \u003c-: aHashtable)(rdom2)))))","legal function application obligation:pre_(((sq.Sum))[int][1, 2, 3, 4, 5, 6, 7, 8, 9])","legal function application obligation:((((sq.Sum))[int]([1, 2, 3, 4, 5, 6, 7, 8, 9]) \u003d 45) \u003d\u003e pre_(((sq.Sum))[int][]))","legal function application obligation:(((((sq.Sum))[int]([1, 2, 3, 4, 5, 6, 7, 8, 9]) \u003d 45) and (((sq.Sum))[int]([]) \u003d 0)) \u003d\u003e pre_Product([2, 3, 4]))","legal function application obligation:(((((sq.Sum))[int]([1, 2, 3, 4, 5, 6, 7, 8, 9]) \u003d 45) and (((sq.Sum))[int]([]) \u003d 0)) \u003d\u003e (((Sequence`Product)[int]([2, 3, 4]) \u003d 24) \u003d\u003e pre_Product([])))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(((sq.Sum))[real][0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9])","legal function application obligation:((((sq.Sum))[real]([0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]) \u003d 4.5) \u003d\u003e pre_(((sq.Sum))[real][]))","legal function application obligation:((((sq.Sum))[real]([0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]) \u003d 4.5) \u003d\u003e ((((sq.Sum))[real]([]) \u003d 0.0) \u003d\u003e pre_Product([2.0, 3.0, 4.0])))","legal function application obligation:((((sq.Sum))[real]([0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]) \u003d 4.5) \u003d\u003e ((((sq.Sum))[real]([]) \u003d 0.0) \u003d\u003e (((Sequence`Product)[real]([2.0, 3.0, 4.0]) \u003d 24.0) \u003d\u003e pre_Product([]))))","legal function application obligation:((((sq.Sum))[real]([0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]) \u003d 4.5) \u003d\u003e ((((sq.Sum))[real]([]) \u003d 0.0) \u003d\u003e (((Sequence`Product)[real]([2.0, 3.0, 4.0]) \u003d 24.0) \u003d\u003e (((Sequence`Product)[real]([]) \u003d 1.0) \u003d\u003e pre_Product([2.1, 3.2, 4.3])))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(((sq.isAscendingOrder))[int][1, 2, 4, 4, 7, 8, 8, 8])","legal function application obligation:(((sq.isAscendingOrder))[int]([1, 2, 4, 4, 7, 8, 8, 8]) \u003d\u003e pre_(((sq.isAscendingOrder))[real][1.0, 2.0, 3.0, 1.5]))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(((sq.isDescendingOrder))[int][3, 2, 2, 1, 1])","legal function application obligation:(((sq.isDescendingOrder))[int]([3, 2, 2, 1, 1]) \u003d\u003e pre_((Sequence`isDescendingTotalOrder)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))[3, 2, 2, 1, 1]))","legal function application obligation:(((sq.isDescendingOrder))[int]([3, 2, 2, 1, 1]) \u003d\u003e ((Sequence`isDescendingTotalOrder)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))([3, 2, 2, 1, 1]) \u003d\u003e pre_((Sequence`isDescendingTotalOrder)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))[3, 2, 2, 1, 2])))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:(forall x:(unresolved SequenceT05`RecordType), y:(unresolved SequenceT05`RecordType) \u0026 pre_((Sequence`isOrdered)[TestType](decideOrderFuncSeq)([(x.val), (x.str), (x.chr)])[(y.val), (y.str), (y.chr)]))","legal function application obligation:(forall x:(unresolved SequenceT05`RecordType), y:(unresolved SequenceT05`RecordType) \u0026 pre_((Sequence`isOrdered)[TestType](decideOrderFuncSeq)[(x.val), (x.str), (x.chr)]))","legal function application obligation:pre_((Sequence`sort)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))[3, 1, 5, 4])","legal function application obligation:(((Sequence`sort)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))([3, 1, 5, 4]) \u003d [1, 3, 4, 5]) \u003d\u003e pre_((Sequence`sort)[seq of (char)]((lambda [x:seq of (char), y:seq of (char)] \u0026 String`LT(x, y)))[\"12\", \"111\", \"01\"]))","legal function application obligation:(((Sequence`sort)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))([3, 1, 5, 4]) \u003d [1, 3, 4, 5]) \u003d\u003e (((Sequence`sort)[seq of (char)]((lambda [x:seq of (char), y:seq of (char)] \u0026 String`LT(x, y)))([\"12\", \"111\", \"01\"]) \u003d [\"01\", \"111\", \"12\"]) \u003d\u003e pre_((Sequence`sort)[RecordType](decideOrderFunc)[mk_RecordType(10, \"sahara\", \u0027c\u0027), mk_RecordType(10, \"sahara\", \u0027a\u0027)])))","legal function application obligation:(((Sequence`sort)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))([3, 1, 5, 4]) \u003d [1, 3, 4, 5]) \u003d\u003e (((Sequence`sort)[seq of (char)]((lambda [x:seq of (char), y:seq of (char)] \u0026 String`LT(x, y)))([\"12\", \"111\", \"01\"]) \u003d [\"01\", \"111\", \"12\"]) \u003d\u003e (((Sequence`sort)[RecordType](decideOrderFunc)([mk_RecordType(10, \"sahara\", \u0027c\u0027), mk_RecordType(10, \"sahara\", \u0027a\u0027)]) \u003d [mk_RecordType(10, \"sahara\", \u0027a\u0027), mk_RecordType(10, \"sahara\", \u0027c\u0027)]) \u003d\u003e pre_(((sq.isOrdered))[TestType](decideOrderFuncSeq)([3, \"123\", \u0027a\u0027])[3, \"123\", \u0027A\u0027]))))","legal function application obligation:(((Sequence`sort)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))([3, 1, 5, 4]) \u003d [1, 3, 4, 5]) \u003d\u003e (((Sequence`sort)[seq of (char)]((lambda [x:seq of (char), y:seq of (char)] \u0026 String`LT(x, y)))([\"12\", \"111\", \"01\"]) \u003d [\"01\", \"111\", \"12\"]) \u003d\u003e (((Sequence`sort)[RecordType](decideOrderFunc)([mk_RecordType(10, \"sahara\", \u0027c\u0027), mk_RecordType(10, \"sahara\", \u0027a\u0027)]) \u003d [mk_RecordType(10, \"sahara\", \u0027a\u0027), mk_RecordType(10, \"sahara\", \u0027c\u0027)]) \u003d\u003e pre_(((sq.isOrdered))[TestType](decideOrderFuncSeq)[3, \"123\", \u0027a\u0027]))))","legal function application obligation:(((Sequence`sort)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))([3, 1, 5, 4]) \u003d [1, 3, 4, 5]) \u003d\u003e (((Sequence`sort)[seq of (char)]((lambda [x:seq of (char), y:seq of (char)] \u0026 String`LT(x, y)))([\"12\", \"111\", \"01\"]) \u003d [\"01\", \"111\", \"12\"]) \u003d\u003e (((Sequence`sort)[RecordType](decideOrderFunc)([mk_RecordType(10, \"sahara\", \u0027c\u0027), mk_RecordType(10, \"sahara\", \u0027a\u0027)]) \u003d [mk_RecordType(10, \"sahara\", \u0027a\u0027), mk_RecordType(10, \"sahara\", \u0027c\u0027)]) \u003d\u003e pre_(((sq.isOrdered))[TestType]decideOrderFuncSeq))))","legal function application obligation:(((Sequence`sort)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))([3, 1, 5, 4]) \u003d [1, 3, 4, 5]) \u003d\u003e (((Sequence`sort)[seq of (char)]((lambda [x:seq of (char), y:seq of (char)] \u0026 String`LT(x, y)))([\"12\", \"111\", \"01\"]) \u003d [\"01\", \"111\", \"12\"]) \u003d\u003e (((Sequence`sort)[RecordType](decideOrderFunc)([mk_RecordType(10, \"sahara\", \u0027c\u0027), mk_RecordType(10, \"sahara\", \u0027a\u0027)]) \u003d [mk_RecordType(10, \"sahara\", \u0027a\u0027), mk_RecordType(10, \"sahara\", \u0027c\u0027)]) \u003d\u003e ((((sq.isOrdered))[TestType](decideOrderFuncSeq)([3, \"123\", \u0027a\u0027])([3, \"123\", \u0027A\u0027]) \u003d true) \u003d\u003e pre_(((sq.isOrdered))[TestType](decideOrderFuncSeq)([3, \"123\", \u0027a\u0027])[3, \"123\", \u00270\u0027])))))","legal function application obligation:(((Sequence`sort)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))([3, 1, 5, 4]) \u003d [1, 3, 4, 5]) \u003d\u003e (((Sequence`sort)[seq of (char)]((lambda [x:seq of (char), y:seq of (char)] \u0026 String`LT(x, y)))([\"12\", \"111\", \"01\"]) \u003d [\"01\", \"111\", \"12\"]) \u003d\u003e (((Sequence`sort)[RecordType](decideOrderFunc)([mk_RecordType(10, \"sahara\", \u0027c\u0027), mk_RecordType(10, \"sahara\", \u0027a\u0027)]) \u003d [mk_RecordType(10, \"sahara\", \u0027a\u0027), mk_RecordType(10, \"sahara\", \u0027c\u0027)]) \u003d\u003e ((((sq.isOrdered))[TestType](decideOrderFuncSeq)([3, \"123\", \u0027a\u0027])([3, \"123\", \u0027A\u0027]) \u003d true) \u003d\u003e pre_(((sq.isOrdered))[TestType](decideOrderFuncSeq)[3, \"123\", \u0027a\u0027])))))","legal function application obligation:(((Sequence`sort)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))([3, 1, 5, 4]) \u003d [1, 3, 4, 5]) \u003d\u003e (((Sequence`sort)[seq of (char)]((lambda [x:seq of (char), y:seq of (char)] \u0026 String`LT(x, y)))([\"12\", \"111\", \"01\"]) \u003d [\"01\", \"111\", \"12\"]) \u003d\u003e (((Sequence`sort)[RecordType](decideOrderFunc)([mk_RecordType(10, \"sahara\", \u0027c\u0027), mk_RecordType(10, \"sahara\", \u0027a\u0027)]) \u003d [mk_RecordType(10, \"sahara\", \u0027a\u0027), mk_RecordType(10, \"sahara\", \u0027c\u0027)]) \u003d\u003e ((((sq.isOrdered))[TestType](decideOrderFuncSeq)([3, \"123\", \u0027a\u0027])([3, \"123\", \u0027A\u0027]) \u003d true) \u003d\u003e pre_(((sq.isOrdered))[TestType]decideOrderFuncSeq)))))","legal function application obligation:(((Sequence`sort)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))([3, 1, 5, 4]) \u003d [1, 3, 4, 5]) \u003d\u003e (((Sequence`sort)[seq of (char)]((lambda [x:seq of (char), y:seq of (char)] \u0026 String`LT(x, y)))([\"12\", \"111\", \"01\"]) \u003d [\"01\", \"111\", \"12\"]) \u003d\u003e (((Sequence`sort)[RecordType](decideOrderFunc)([mk_RecordType(10, \"sahara\", \u0027c\u0027), mk_RecordType(10, \"sahara\", \u0027a\u0027)]) \u003d [mk_RecordType(10, \"sahara\", \u0027a\u0027), mk_RecordType(10, \"sahara\", \u0027c\u0027)]) \u003d\u003e ((((sq.isOrdered))[TestType](decideOrderFuncSeq)([3, \"123\", \u0027a\u0027])([3, \"123\", \u0027A\u0027]) \u003d true) \u003d\u003e ((((sq.isOrdered))[TestType](decideOrderFuncSeq)([3, \"123\", \u0027a\u0027])([3, \"123\", \u00270\u0027]) \u003d false) \u003d\u003e pre_(((sq.isOrdered))[(char | int | seq of (char))](decideOrderFuncSeq)([])[]))))))","legal function application obligation:(((Sequence`sort)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))([3, 1, 5, 4]) \u003d [1, 3, 4, 5]) \u003d\u003e (((Sequence`sort)[seq of (char)]((lambda [x:seq of (char), y:seq of (char)] \u0026 String`LT(x, y)))([\"12\", \"111\", \"01\"]) \u003d [\"01\", \"111\", \"12\"]) \u003d\u003e (((Sequence`sort)[RecordType](decideOrderFunc)([mk_RecordType(10, \"sahara\", \u0027c\u0027), mk_RecordType(10, \"sahara\", \u0027a\u0027)]) \u003d [mk_RecordType(10, \"sahara\", \u0027a\u0027), mk_RecordType(10, \"sahara\", \u0027c\u0027)]) \u003d\u003e ((((sq.isOrdered))[TestType](decideOrderFuncSeq)([3, \"123\", \u0027a\u0027])([3, \"123\", \u0027A\u0027]) \u003d true) \u003d\u003e ((((sq.isOrdered))[TestType](decideOrderFuncSeq)([3, \"123\", \u0027a\u0027])([3, \"123\", \u00270\u0027]) \u003d false) \u003d\u003e pre_(((sq.isOrdered))[(char | int | seq of (char))](decideOrderFuncSeq)[]))))))","legal function application obligation:(((Sequence`sort)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))([3, 1, 5, 4]) \u003d [1, 3, 4, 5]) \u003d\u003e (((Sequence`sort)[seq of (char)]((lambda [x:seq of (char), y:seq of (char)] \u0026 String`LT(x, y)))([\"12\", \"111\", \"01\"]) \u003d [\"01\", \"111\", \"12\"]) \u003d\u003e (((Sequence`sort)[RecordType](decideOrderFunc)([mk_RecordType(10, \"sahara\", \u0027c\u0027), mk_RecordType(10, \"sahara\", \u0027a\u0027)]) \u003d [mk_RecordType(10, \"sahara\", \u0027a\u0027), mk_RecordType(10, \"sahara\", \u0027c\u0027)]) \u003d\u003e ((((sq.isOrdered))[TestType](decideOrderFuncSeq)([3, \"123\", \u0027a\u0027])([3, \"123\", \u0027A\u0027]) \u003d true) \u003d\u003e ((((sq.isOrdered))[TestType](decideOrderFuncSeq)([3, \"123\", \u0027a\u0027])([3, \"123\", \u00270\u0027]) \u003d false) \u003d\u003e pre_(((sq.isOrdered))[(char | int | seq of (char))]decideOrderFuncSeq))))))","legal function application obligation:(((Sequence`sort)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))([3, 1, 5, 4]) \u003d [1, 3, 4, 5]) \u003d\u003e (((Sequence`sort)[seq of (char)]((lambda [x:seq of (char), y:seq of (char)] \u0026 String`LT(x, y)))([\"12\", \"111\", \"01\"]) \u003d [\"01\", \"111\", \"12\"]) \u003d\u003e (((Sequence`sort)[RecordType](decideOrderFunc)([mk_RecordType(10, \"sahara\", \u0027c\u0027), mk_RecordType(10, \"sahara\", \u0027a\u0027)]) \u003d [mk_RecordType(10, \"sahara\", \u0027a\u0027), mk_RecordType(10, \"sahara\", \u0027c\u0027)]) \u003d\u003e ((((sq.isOrdered))[TestType](decideOrderFuncSeq)([3, \"123\", \u0027a\u0027])([3, \"123\", \u0027A\u0027]) \u003d true) \u003d\u003e ((((sq.isOrdered))[TestType](decideOrderFuncSeq)([3, \"123\", \u0027a\u0027])([3, \"123\", \u00270\u0027]) \u003d false) \u003d\u003e ((((sq.isOrdered))[(char | int | seq of (char))](decideOrderFuncSeq)([])([]) \u003d false) \u003d\u003e pre_(((sq.isOrdered))[(char | int | seq of (char))](decideOrderFuncSeq)([])[3, \"123\", \u00270\u0027])))))))","legal function application obligation:(((Sequence`sort)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))([3, 1, 5, 4]) \u003d [1, 3, 4, 5]) \u003d\u003e (((Sequence`sort)[seq of (char)]((lambda [x:seq of (char), y:seq of (char)] \u0026 String`LT(x, y)))([\"12\", \"111\", \"01\"]) \u003d [\"01\", \"111\", \"12\"]) \u003d\u003e (((Sequence`sort)[RecordType](decideOrderFunc)([mk_RecordType(10, \"sahara\", \u0027c\u0027), mk_RecordType(10, \"sahara\", \u0027a\u0027)]) \u003d [mk_RecordType(10, \"sahara\", \u0027a\u0027), mk_RecordType(10, \"sahara\", \u0027c\u0027)]) \u003d\u003e ((((sq.isOrdered))[TestType](decideOrderFuncSeq)([3, \"123\", \u0027a\u0027])([3, \"123\", \u0027A\u0027]) \u003d true) \u003d\u003e ((((sq.isOrdered))[TestType](decideOrderFuncSeq)([3, \"123\", \u0027a\u0027])([3, \"123\", \u00270\u0027]) \u003d false) \u003d\u003e ((((sq.isOrdered))[(char | int | seq of (char))](decideOrderFuncSeq)([])([]) \u003d false) \u003d\u003e pre_(((sq.isOrdered))[(char | int | seq of (char))](decideOrderFuncSeq)[])))))))","legal function application obligation:(((Sequence`sort)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))([3, 1, 5, 4]) \u003d [1, 3, 4, 5]) \u003d\u003e (((Sequence`sort)[seq of (char)]((lambda [x:seq of (char), y:seq of (char)] \u0026 String`LT(x, y)))([\"12\", \"111\", \"01\"]) \u003d [\"01\", \"111\", \"12\"]) \u003d\u003e (((Sequence`sort)[RecordType](decideOrderFunc)([mk_RecordType(10, \"sahara\", \u0027c\u0027), mk_RecordType(10, \"sahara\", \u0027a\u0027)]) \u003d [mk_RecordType(10, \"sahara\", \u0027a\u0027), mk_RecordType(10, \"sahara\", \u0027c\u0027)]) \u003d\u003e ((((sq.isOrdered))[TestType](decideOrderFuncSeq)([3, \"123\", \u0027a\u0027])([3, \"123\", \u0027A\u0027]) \u003d true) \u003d\u003e ((((sq.isOrdered))[TestType](decideOrderFuncSeq)([3, \"123\", \u0027a\u0027])([3, \"123\", \u00270\u0027]) \u003d false) \u003d\u003e ((((sq.isOrdered))[(char | int | seq of (char))](decideOrderFuncSeq)([])([]) \u003d false) \u003d\u003e pre_(((sq.isOrdered))[(char | int | seq of (char))]decideOrderFuncSeq)))))))","legal function application obligation:(((Sequence`sort)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))([3, 1, 5, 4]) \u003d [1, 3, 4, 5]) \u003d\u003e (((Sequence`sort)[seq of (char)]((lambda [x:seq of (char), y:seq of (char)] \u0026 String`LT(x, y)))([\"12\", \"111\", \"01\"]) \u003d [\"01\", \"111\", \"12\"]) \u003d\u003e (((Sequence`sort)[RecordType](decideOrderFunc)([mk_RecordType(10, \"sahara\", \u0027c\u0027), mk_RecordType(10, \"sahara\", \u0027a\u0027)]) \u003d [mk_RecordType(10, \"sahara\", \u0027a\u0027), mk_RecordType(10, \"sahara\", \u0027c\u0027)]) \u003d\u003e ((((sq.isOrdered))[TestType](decideOrderFuncSeq)([3, \"123\", \u0027a\u0027])([3, \"123\", \u0027A\u0027]) \u003d true) \u003d\u003e ((((sq.isOrdered))[TestType](decideOrderFuncSeq)([3, \"123\", \u0027a\u0027])([3, \"123\", \u00270\u0027]) \u003d false) \u003d\u003e ((((sq.isOrdered))[(char | int | seq of (char))](decideOrderFuncSeq)([])([]) \u003d false) \u003d\u003e ((((sq.isOrdered))[(char | int | seq of (char))](decideOrderFuncSeq)([])([3, \"123\", \u00270\u0027]) \u003d true) \u003d\u003e pre_(((sq.isOrdered))[(char | int | seq of (char))](decideOrderFuncSeq)([3, \"123\", \u00270\u0027])[]))))))))","legal function application obligation:(((Sequence`sort)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))([3, 1, 5, 4]) \u003d [1, 3, 4, 5]) \u003d\u003e (((Sequence`sort)[seq of (char)]((lambda [x:seq of (char), y:seq of (char)] \u0026 String`LT(x, y)))([\"12\", \"111\", \"01\"]) \u003d [\"01\", \"111\", \"12\"]) \u003d\u003e (((Sequence`sort)[RecordType](decideOrderFunc)([mk_RecordType(10, \"sahara\", \u0027c\u0027), mk_RecordType(10, \"sahara\", \u0027a\u0027)]) \u003d [mk_RecordType(10, \"sahara\", \u0027a\u0027), mk_RecordType(10, \"sahara\", \u0027c\u0027)]) \u003d\u003e ((((sq.isOrdered))[TestType](decideOrderFuncSeq)([3, \"123\", \u0027a\u0027])([3, \"123\", \u0027A\u0027]) \u003d true) \u003d\u003e ((((sq.isOrdered))[TestType](decideOrderFuncSeq)([3, \"123\", \u0027a\u0027])([3, \"123\", \u00270\u0027]) \u003d false) \u003d\u003e ((((sq.isOrdered))[(char | int | seq of (char))](decideOrderFuncSeq)([])([]) \u003d false) \u003d\u003e ((((sq.isOrdered))[(char | int | seq of (char))](decideOrderFuncSeq)([])([3, \"123\", \u00270\u0027]) \u003d true) \u003d\u003e pre_(((sq.isOrdered))[(char | int | seq of (char))](decideOrderFuncSeq)[3, \"123\", \u00270\u0027]))))))))","legal function application obligation:(((Sequence`sort)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))([3, 1, 5, 4]) \u003d [1, 3, 4, 5]) \u003d\u003e (((Sequence`sort)[seq of (char)]((lambda [x:seq of (char), y:seq of (char)] \u0026 String`LT(x, y)))([\"12\", \"111\", \"01\"]) \u003d [\"01\", \"111\", \"12\"]) \u003d\u003e (((Sequence`sort)[RecordType](decideOrderFunc)([mk_RecordType(10, \"sahara\", \u0027c\u0027), mk_RecordType(10, \"sahara\", \u0027a\u0027)]) \u003d [mk_RecordType(10, \"sahara\", \u0027a\u0027), mk_RecordType(10, \"sahara\", \u0027c\u0027)]) \u003d\u003e ((((sq.isOrdered))[TestType](decideOrderFuncSeq)([3, \"123\", \u0027a\u0027])([3, \"123\", \u0027A\u0027]) \u003d true) \u003d\u003e ((((sq.isOrdered))[TestType](decideOrderFuncSeq)([3, \"123\", \u0027a\u0027])([3, \"123\", \u00270\u0027]) \u003d false) \u003d\u003e ((((sq.isOrdered))[(char | int | seq of (char))](decideOrderFuncSeq)([])([]) \u003d false) \u003d\u003e ((((sq.isOrdered))[(char | int | seq of (char))](decideOrderFuncSeq)([])([3, \"123\", \u00270\u0027]) \u003d true) \u003d\u003e pre_(((sq.isOrdered))[(char | int | seq of (char))]decideOrderFuncSeq))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(((sq.Merge))[int](decideOrderFunc1)([1, 4, 6])[2, 3, 4, 5])","legal function application obligation:pre_(((sq.Merge))[int](decideOrderFunc1)[1, 4, 6])","legal function application obligation:pre_(((sq.Merge))[int]decideOrderFunc1)","legal function application obligation:((((sq.Merge))[int](decideOrderFunc1)([1, 4, 6])([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 4, 5, 6]) \u003d\u003e pre_(((sq.Merge))[char](decideOrderFunc2)(\"146\")\"2345\"))","legal function application obligation:((((sq.Merge))[int](decideOrderFunc1)([1, 4, 6])([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 4, 5, 6]) \u003d\u003e pre_(((sq.Merge))[char](decideOrderFunc2)\"146\"))","legal function application obligation:((((sq.Merge))[int](decideOrderFunc1)([1, 4, 6])([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 4, 5, 6]) \u003d\u003e pre_(((sq.Merge))[char]decideOrderFunc2))","legal function application obligation:((((sq.Merge))[int](decideOrderFunc1)([1, 4, 6])([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 4, 5, 6]) \u003d\u003e ((((sq.Merge))[char](decideOrderFunc2)(\"146\")(\"2345\") \u003d \"1234456\") \u003d\u003e pre_(((sq.Merge))[char](decideOrderFunc2)(\"\")\"2345\")))","legal function application obligation:((((sq.Merge))[int](decideOrderFunc1)([1, 4, 6])([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 4, 5, 6]) \u003d\u003e ((((sq.Merge))[char](decideOrderFunc2)(\"146\")(\"2345\") \u003d \"1234456\") \u003d\u003e pre_(((sq.Merge))[char](decideOrderFunc2)\"\")))","legal function application obligation:((((sq.Merge))[int](decideOrderFunc1)([1, 4, 6])([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 4, 5, 6]) \u003d\u003e ((((sq.Merge))[char](decideOrderFunc2)(\"146\")(\"2345\") \u003d \"1234456\") \u003d\u003e pre_(((sq.Merge))[char]decideOrderFunc2)))","legal function application obligation:((((sq.Merge))[int](decideOrderFunc1)([1, 4, 6])([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 4, 5, 6]) \u003d\u003e ((((sq.Merge))[char](decideOrderFunc2)(\"146\")(\"2345\") \u003d \"1234456\") \u003d\u003e ((((sq.Merge))[char](decideOrderFunc2)(\"\")(\"2345\") \u003d \"2345\") \u003d\u003e pre_(((sq.Merge))[char](decideOrderFunc2)(\"146\")\"\"))))","legal function application obligation:((((sq.Merge))[int](decideOrderFunc1)([1, 4, 6])([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 4, 5, 6]) \u003d\u003e ((((sq.Merge))[char](decideOrderFunc2)(\"146\")(\"2345\") \u003d \"1234456\") \u003d\u003e ((((sq.Merge))[char](decideOrderFunc2)(\"\")(\"2345\") \u003d \"2345\") \u003d\u003e pre_(((sq.Merge))[char](decideOrderFunc2)\"146\"))))","legal function application obligation:((((sq.Merge))[int](decideOrderFunc1)([1, 4, 6])([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 4, 5, 6]) \u003d\u003e ((((sq.Merge))[char](decideOrderFunc2)(\"146\")(\"2345\") \u003d \"1234456\") \u003d\u003e ((((sq.Merge))[char](decideOrderFunc2)(\"\")(\"2345\") \u003d \"2345\") \u003d\u003e pre_(((sq.Merge))[char]decideOrderFunc2))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(((sq.take))[int](2)[2, 3, 4, 5])","legal function application obligation:pre_(((sq.take))[int]2)","legal function application obligation:((((sq.take))[int](2)([2, 3, 4, 5]) \u003d [2, 3]) \u003d\u003e pre_(((sq.drop))[char](5)\"Shin Sahara\"))","legal function application obligation:((((sq.take))[int](2)([2, 3, 4, 5]) \u003d [2, 3]) \u003d\u003e pre_(((sq.drop))[char]5))","legal function application obligation:((((sq.take))[int](2)([2, 3, 4, 5]) \u003d [2, 3]) \u003d\u003e ((((sq.drop))[char](5)(\"Shin Sahara\") \u003d \"Sahara\") \u003d\u003e pre_(((sq.last))[int][1, 2, 3])))","legal function application obligation:((((sq.take))[int](2)([2, 3, 4, 5]) \u003d [2, 3]) \u003d\u003e ((((sq.drop))[char](5)(\"Shin Sahara\") \u003d \"Sahara\") \u003d\u003e ((((sq.last))[int]([1, 2, 3]) \u003d 3) \u003d\u003e pre_(((sq.filter))[int]((lambda [x:int] \u0026 ((x mod 2) \u003d 0)))[1, 2, 3, 4, 5, 6]))))","legal function application obligation:((((sq.take))[int](2)([2, 3, 4, 5]) \u003d [2, 3]) \u003d\u003e ((((sq.drop))[char](5)(\"Shin Sahara\") \u003d \"Sahara\") \u003d\u003e ((((sq.last))[int]([1, 2, 3]) \u003d 3) \u003d\u003e pre_(((sq.filter))[int](lambda [x:int] \u0026 ((x mod 2) \u003d 0))))))","legal function application obligation:((((sq.take))[int](2)([2, 3, 4, 5]) \u003d [2, 3]) \u003d\u003e ((((sq.drop))[char](5)(\"Shin Sahara\") \u003d \"Sahara\") \u003d\u003e ((((sq.last))[int]([1, 2, 3]) \u003d 3) \u003d\u003e ((((sq.filter))[int]((lambda [x:int] \u0026 ((x mod 2) \u003d 0)))([1, 2, 3, 4, 5, 6]) \u003d [2, 4, 6]) \u003d\u003e pre_((Sequence`SubSeq)[char](4)(3)\"1234567890\")))))","legal function application obligation:((((sq.take))[int](2)([2, 3, 4, 5]) \u003d [2, 3]) \u003d\u003e ((((sq.drop))[char](5)(\"Shin Sahara\") \u003d \"Sahara\") \u003d\u003e ((((sq.last))[int]([1, 2, 3]) \u003d 3) \u003d\u003e ((((sq.filter))[int]((lambda [x:int] \u0026 ((x mod 2) \u003d 0)))([1, 2, 3, 4, 5, 6]) \u003d [2, 4, 6]) \u003d\u003e pre_((Sequence`SubSeq)[char](4)3)))))","type compatibility obligation:is_(RESULT, ())","type compatibility obligation:is_(RESULT, ())","type compatibility obligation:is_(RESULT, ())","type compatibility obligation:is_(RESULT, ())","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((Sequence`isMember)[int](2)[1, 2, 3, 4, 5, 6])","legal function application obligation:((Sequence`isMember)[int](2)([1, 2, 3, 4, 5, 6]) \u003d\u003e pre_((Sequence`isMember)[int](0)[1, 2, 3, 4, 5, 6]))","legal function application obligation:((Sequence`isMember)[int](2)([1, 2, 3, 4, 5, 6]) \u003d\u003e (((Sequence`isMember)[int](0)([1, 2, 3, 4, 5, 6]) \u003d false) \u003d\u003e pre_((Sequence`isMember)[int](6)[1, 2, 3, 4, 5, 6])))","legal function application obligation:((Sequence`isMember)[int](2)([1, 2, 3, 4, 5, 6]) \u003d\u003e (((Sequence`isMember)[int](0)([1, 2, 3, 4, 5, 6]) \u003d false) \u003d\u003e ((Sequence`isMember)[int](6)([1, 2, 3, 4, 5, 6]) \u003d\u003e pre_((Sequence`isAnyMember)[int]([6])[1, 2, 3, 4, 5, 6]))))","legal function application obligation:((Sequence`isMember)[int](2)([1, 2, 3, 4, 5, 6]) \u003d\u003e (((Sequence`isMember)[int](0)([1, 2, 3, 4, 5, 6]) \u003d false) \u003d\u003e ((Sequence`isMember)[int](6)([1, 2, 3, 4, 5, 6]) \u003d\u003e ((Sequence`isAnyMember)[int]([6])([1, 2, 3, 4, 5, 6]) \u003d\u003e pre_((Sequence`isAnyMember)[int]([0, 7])[1, 2, 3, 4, 5, 6])))))","legal function application obligation:((Sequence`isMember)[int](2)([1, 2, 3, 4, 5, 6]) \u003d\u003e (((Sequence`isMember)[int](0)([1, 2, 3, 4, 5, 6]) \u003d false) \u003d\u003e ((Sequence`isMember)[int](6)([1, 2, 3, 4, 5, 6]) \u003d\u003e ((Sequence`isAnyMember)[int]([6])([1, 2, 3, 4, 5, 6]) \u003d\u003e (((Sequence`isAnyMember)[int]([0, 7])([1, 2, 3, 4, 5, 6]) \u003d false) \u003d\u003e pre_((Sequence`isAnyMember)[int]([4, 6])[1, 2, 3, 4, 5, 6]))))))","legal function application obligation:((Sequence`isMember)[int](2)([1, 2, 3, 4, 5, 6]) \u003d\u003e (((Sequence`isMember)[int](0)([1, 2, 3, 4, 5, 6]) \u003d false) \u003d\u003e ((Sequence`isMember)[int](6)([1, 2, 3, 4, 5, 6]) \u003d\u003e ((Sequence`isAnyMember)[int]([6])([1, 2, 3, 4, 5, 6]) \u003d\u003e (((Sequence`isAnyMember)[int]([0, 7])([1, 2, 3, 4, 5, 6]) \u003d false) \u003d\u003e ((Sequence`isAnyMember)[int]([4, 6])([1, 2, 3, 4, 5, 6]) \u003d\u003e pre_((Sequence`isAnyMember)[int]([])[1, 2, 3, 4, 5, 6])))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((Sequence`fmap)[int, int]((lambda [x:int] \u0026 (x mod 3)))[1, 2, 3, 4, 5])","legal function application obligation:(((Sequence`fmap)[int, int]((lambda [x:int] \u0026 (x mod 3)))([1, 2, 3, 4, 5]) \u003d [1, 2, 0, 1, 2]) \u003d\u003e pre_((Sequence`fmap)[seq of (char), seq of (char)]((Sequence`take)[char](2))[\"Shin Sahara\", \"Hiroshi Sakoh\"]))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((index)[int](1)[1, 2, 3, 4, 5])","legal function application obligation:pre_((index)[int]1)","legal function application obligation:(((index)[int](1)([1, 2, 3, 4, 5]) \u003d 1) \u003d\u003e pre_((index)[int](5)[1, 2, 3, 4, 5]))","legal function application obligation:(((index)[int](1)([1, 2, 3, 4, 5]) \u003d 1) \u003d\u003e pre_((index)[int]5))","legal function application obligation:(((index)[int](1)([1, 2, 3, 4, 5]) \u003d 1) \u003d\u003e (((index)[int](5)([1, 2, 3, 4, 5]) \u003d 5) \u003d\u003e pre_((index)[int](9)[1, 2, 3, 4, 5])))","legal function application obligation:(((index)[int](1)([1, 2, 3, 4, 5]) \u003d 1) \u003d\u003e (((index)[int](5)([1, 2, 3, 4, 5]) \u003d 5) \u003d\u003e pre_((index)[int]9)))","legal function application obligation:(((index)[int](1)([1, 2, 3, 4, 5]) \u003d 1) \u003d\u003e (((index)[int](5)([1, 2, 3, 4, 5]) \u003d 5) \u003d\u003e (((index)[int](9)([1, 2, 3, 4, 5]) \u003d 0) \u003d\u003e pre_((index)[char](\u0027b\u0027)[\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]))))","legal function application obligation:(((index)[int](1)([1, 2, 3, 4, 5]) \u003d 1) \u003d\u003e (((index)[int](5)([1, 2, 3, 4, 5]) \u003d 5) \u003d\u003e (((index)[int](9)([1, 2, 3, 4, 5]) \u003d 0) \u003d\u003e pre_((index)[char]\u0027b\u0027))))","legal function application obligation:(((index)[int](1)([1, 2, 3, 4, 5]) \u003d 1) \u003d\u003e (((index)[int](5)([1, 2, 3, 4, 5]) \u003d 5) \u003d\u003e (((index)[int](9)([1, 2, 3, 4, 5]) \u003d 0) \u003d\u003e (((index)[char](\u0027b\u0027)([\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d 2) \u003d\u003e pre_((index)[char](\u0027z\u0027)[\u0027a\u0027, \u0027b\u0027, \u0027c\u0027])))))","legal function application obligation:(((index)[int](1)([1, 2, 3, 4, 5]) \u003d 1) \u003d\u003e (((index)[int](5)([1, 2, 3, 4, 5]) \u003d 5) \u003d\u003e (((index)[int](9)([1, 2, 3, 4, 5]) \u003d 0) \u003d\u003e (((index)[char](\u0027b\u0027)([\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d 2) \u003d\u003e pre_((index)[char]\u0027z\u0027)))))","legal function application obligation:(((index)[int](1)([1, 2, 3, 4, 5]) \u003d 1) \u003d\u003e (((index)[int](5)([1, 2, 3, 4, 5]) \u003d 5) \u003d\u003e (((index)[int](9)([1, 2, 3, 4, 5]) \u003d 0) \u003d\u003e (((index)[char](\u0027b\u0027)([\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d 2) \u003d\u003e (((index)[char](\u0027z\u0027)([\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d 0) \u003d\u003e pre_((indexAll)[int](9)[1, 2, 3, 4, 5]))))))","legal function application obligation:(((index)[int](1)([1, 2, 3, 4, 5]) \u003d 1) \u003d\u003e (((index)[int](5)([1, 2, 3, 4, 5]) \u003d 5) \u003d\u003e (((index)[int](9)([1, 2, 3, 4, 5]) \u003d 0) \u003d\u003e (((index)[char](\u0027b\u0027)([\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d 2) \u003d\u003e (((index)[char](\u0027z\u0027)([\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d 0) \u003d\u003e pre_((indexAll)[int]9))))))","legal function application obligation:(((index)[int](1)([1, 2, 3, 4, 5]) \u003d 1) \u003d\u003e (((index)[int](5)([1, 2, 3, 4, 5]) \u003d 5) \u003d\u003e (((index)[int](9)([1, 2, 3, 4, 5]) \u003d 0) \u003d\u003e (((index)[char](\u0027b\u0027)([\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d 2) \u003d\u003e (((index)[char](\u0027z\u0027)([\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d 0) \u003d\u003e (((indexAll)[int](9)([1, 2, 3, 4, 5]) \u003d {}) \u003d\u003e pre_((indexAll)[int](9)[])))))))","legal function application obligation:(((index)[int](1)([1, 2, 3, 4, 5]) \u003d 1) \u003d\u003e (((index)[int](5)([1, 2, 3, 4, 5]) \u003d 5) \u003d\u003e (((index)[int](9)([1, 2, 3, 4, 5]) \u003d 0) \u003d\u003e (((index)[char](\u0027b\u0027)([\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d 2) \u003d\u003e (((index)[char](\u0027z\u0027)([\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d 0) \u003d\u003e (((indexAll)[int](9)([1, 2, 3, 4, 5]) \u003d {}) \u003d\u003e pre_((indexAll)[int]9)))))))","legal function application obligation:(((index)[int](1)([1, 2, 3, 4, 5]) \u003d 1) \u003d\u003e (((index)[int](5)([1, 2, 3, 4, 5]) \u003d 5) \u003d\u003e (((index)[int](9)([1, 2, 3, 4, 5]) \u003d 0) \u003d\u003e (((index)[char](\u0027b\u0027)([\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d 2) \u003d\u003e (((index)[char](\u0027z\u0027)([\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d 0) \u003d\u003e (((indexAll)[int](9)([1, 2, 3, 4, 5]) \u003d {}) \u003d\u003e (((indexAll)[int](9)([]) \u003d {}) \u003d\u003e pre_((indexAll)[int](1)[1, 2, 3, 4, 1]))))))))","legal function application obligation:(((index)[int](1)([1, 2, 3, 4, 5]) \u003d 1) \u003d\u003e (((index)[int](5)([1, 2, 3, 4, 5]) \u003d 5) \u003d\u003e (((index)[int](9)([1, 2, 3, 4, 5]) \u003d 0) \u003d\u003e (((index)[char](\u0027b\u0027)([\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d 2) \u003d\u003e (((index)[char](\u0027z\u0027)([\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d 0) \u003d\u003e (((indexAll)[int](9)([1, 2, 3, 4, 5]) \u003d {}) \u003d\u003e (((indexAll)[int](9)([]) \u003d {}) \u003d\u003e pre_((indexAll)[int]1))))))))","legal function application obligation:(((index)[int](1)([1, 2, 3, 4, 5]) \u003d 1) \u003d\u003e (((index)[int](5)([1, 2, 3, 4, 5]) \u003d 5) \u003d\u003e (((index)[int](9)([1, 2, 3, 4, 5]) \u003d 0) \u003d\u003e (((index)[char](\u0027b\u0027)([\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d 2) \u003d\u003e (((index)[char](\u0027z\u0027)([\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d 0) \u003d\u003e (((indexAll)[int](9)([1, 2, 3, 4, 5]) \u003d {}) \u003d\u003e (((indexAll)[int](9)([]) \u003d {}) \u003d\u003e (((indexAll)[int](1)([1, 2, 3, 4, 1]) \u003d {1, 5}) \u003d\u003e pre_((indexAll)[int](1)[1, 2, 3, 4, 1, 1])))))))))","legal function application obligation:(((index)[int](1)([1, 2, 3, 4, 5]) \u003d 1) \u003d\u003e (((index)[int](5)([1, 2, 3, 4, 5]) \u003d 5) \u003d\u003e (((index)[int](9)([1, 2, 3, 4, 5]) \u003d 0) \u003d\u003e (((index)[char](\u0027b\u0027)([\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d 2) \u003d\u003e (((index)[char](\u0027z\u0027)([\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d 0) \u003d\u003e (((indexAll)[int](9)([1, 2, 3, 4, 5]) \u003d {}) \u003d\u003e (((indexAll)[int](9)([]) \u003d {}) \u003d\u003e (((indexAll)[int](1)([1, 2, 3, 4, 1]) \u003d {1, 5}) \u003d\u003e pre_((indexAll)[int]1)))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(avg1[])","legal function application obligation:((avg1([]) \u003d nil) \u003d\u003e pre_(avg1[1, 2, 3, 4]))","legal function application obligation:((avg1([]) \u003d nil) \u003d\u003e ((avg1([1, 2, 3, 4]) \u003d ((((1 + 2) + 3) + 4) / 4)) \u003d\u003e pre_(avg2[1.3, 2.4, 3.5])))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(ins1(1)(1)[2, 3, 4, 5])","legal function application obligation:pre_(ins1(1)1)","legal function application obligation:pre_(ins11)","legal function application obligation:((ins1(1)(1)([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e pre_(ins1(3)(3)[1, 2, 4, 5]))","legal function application obligation:((ins1(1)(1)([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e pre_(ins1(3)3))","legal function application obligation:((ins1(1)(1)([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e pre_(ins13))","legal function application obligation:((ins1(1)(1)([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e pre_(ins1(3)(3)[1, 2])))","legal function application obligation:((ins1(1)(1)([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e pre_(ins1(3)3)))","legal function application obligation:((ins1(1)(1)([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e pre_(ins13)))","legal function application obligation:((ins1(1)(1)([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e pre_(ins1(4)(3)[1, 2]))))","legal function application obligation:((ins1(1)(1)([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e pre_(ins1(4)3))))","legal function application obligation:((ins1(1)(1)([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e pre_(ins14))))","legal function application obligation:((ins1(1)(1)([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins1(4)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e pre_(ins1(5)(3)[1, 2])))))","legal function application obligation:((ins1(1)(1)([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins1(4)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e pre_(ins1(5)3)))))","legal function application obligation:((ins1(1)(1)([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins1(4)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e pre_(ins15)))))","legal function application obligation:((ins1(1)(1)([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins1(4)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins1(5)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e pre_(ins2(1)(\u00271\u0027)\"2345\"))))))","legal function application obligation:((ins1(1)(1)([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins1(4)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins1(5)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e pre_(ins2(1)\u00271\u0027))))))","legal function application obligation:((ins1(1)(1)([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins1(4)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins1(5)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e pre_(ins21))))))","legal function application obligation:((ins1(1)(1)([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins1(4)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins1(5)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins2(1)(\u00271\u0027)(\"2345\") \u003d \"12345\") \u003d\u003e pre_(ins2(3)(\u00273\u0027)\"1245\")))))))","legal function application obligation:((ins1(1)(1)([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins1(4)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins1(5)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins2(1)(\u00271\u0027)(\"2345\") \u003d \"12345\") \u003d\u003e pre_(ins2(3)\u00273\u0027)))))))","legal function application obligation:((ins1(1)(1)([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins1(4)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins1(5)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins2(1)(\u00271\u0027)(\"2345\") \u003d \"12345\") \u003d\u003e pre_(ins23)))))))","legal function application obligation:((ins1(1)(1)([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins1(4)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins1(5)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins2(1)(\u00271\u0027)(\"2345\") \u003d \"12345\") \u003d\u003e ((ins2(3)(\u00273\u0027)(\"1245\") \u003d \"12345\") \u003d\u003e pre_(ins2(3)(\u00273\u0027)\"12\"))))))))","legal function application obligation:((ins1(1)(1)([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins1(4)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins1(5)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins2(1)(\u00271\u0027)(\"2345\") \u003d \"12345\") \u003d\u003e ((ins2(3)(\u00273\u0027)(\"1245\") \u003d \"12345\") \u003d\u003e pre_(ins2(3)\u00273\u0027))))))))","legal function application obligation:((ins1(1)(1)([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins1(4)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins1(5)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins2(1)(\u00271\u0027)(\"2345\") \u003d \"12345\") \u003d\u003e ((ins2(3)(\u00273\u0027)(\"1245\") \u003d \"12345\") \u003d\u003e pre_(ins23))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(rm1(1)[1, 2, 3, 4, 5])","legal function application obligation:pre_(rm11)","legal function application obligation:((rm1(1)([1, 2, 3, 4, 5]) \u003d [2, 3, 4, 5]) \u003d\u003e pre_(rm1(3)[1, 2, 4, 3]))","legal function application obligation:((rm1(1)([1, 2, 3, 4, 5]) \u003d [2, 3, 4, 5]) \u003d\u003e pre_(rm13))","legal function application obligation:((rm1(1)([1, 2, 3, 4, 5]) \u003d [2, 3, 4, 5]) \u003d\u003e ((rm1(3)([1, 2, 4, 3]) \u003d [1, 2, 3]) \u003d\u003e pre_(rm1(3)[1, 2])))","legal function application obligation:((rm1(1)([1, 2, 3, 4, 5]) \u003d [2, 3, 4, 5]) \u003d\u003e ((rm1(3)([1, 2, 4, 3]) \u003d [1, 2, 3]) \u003d\u003e pre_(rm13)))","legal function application obligation:((rm1(1)([1, 2, 3, 4, 5]) \u003d [2, 3, 4, 5]) \u003d\u003e ((rm1(3)([1, 2, 4, 3]) \u003d [1, 2, 3]) \u003d\u003e ((rm1(3)([1, 2]) \u003d [1, 2]) \u003d\u003e pre_(rm1(4)[1, 2]))))","legal function application obligation:((rm1(1)([1, 2, 3, 4, 5]) \u003d [2, 3, 4, 5]) \u003d\u003e ((rm1(3)([1, 2, 4, 3]) \u003d [1, 2, 3]) \u003d\u003e ((rm1(3)([1, 2]) \u003d [1, 2]) \u003d\u003e pre_(rm14))))","legal function application obligation:((rm1(1)([1, 2, 3, 4, 5]) \u003d [2, 3, 4, 5]) \u003d\u003e ((rm1(3)([1, 2, 4, 3]) \u003d [1, 2, 3]) \u003d\u003e ((rm1(3)([1, 2]) \u003d [1, 2]) \u003d\u003e ((rm1(4)([1, 2]) \u003d [1, 2]) \u003d\u003e pre_(rm1(5)[1, 2])))))","legal function application obligation:((rm1(1)([1, 2, 3, 4, 5]) \u003d [2, 3, 4, 5]) \u003d\u003e ((rm1(3)([1, 2, 4, 3]) \u003d [1, 2, 3]) \u003d\u003e ((rm1(3)([1, 2]) \u003d [1, 2]) \u003d\u003e ((rm1(4)([1, 2]) \u003d [1, 2]) \u003d\u003e pre_(rm15)))))","legal function application obligation:((rm1(1)([1, 2, 3, 4, 5]) \u003d [2, 3, 4, 5]) \u003d\u003e ((rm1(3)([1, 2, 4, 3]) \u003d [1, 2, 3]) \u003d\u003e ((rm1(3)([1, 2]) \u003d [1, 2]) \u003d\u003e ((rm1(4)([1, 2]) \u003d [1, 2]) \u003d\u003e ((rm1(5)([1, 2]) \u003d [1, 2]) \u003d\u003e pre_(rm2(1)\"12345\"))))))","legal function application obligation:((rm1(1)([1, 2, 3, 4, 5]) \u003d [2, 3, 4, 5]) \u003d\u003e ((rm1(3)([1, 2, 4, 3]) \u003d [1, 2, 3]) \u003d\u003e ((rm1(3)([1, 2]) \u003d [1, 2]) \u003d\u003e ((rm1(4)([1, 2]) \u003d [1, 2]) \u003d\u003e ((rm1(5)([1, 2]) \u003d [1, 2]) \u003d\u003e pre_(rm21))))))","legal function application obligation:((rm1(1)([1, 2, 3, 4, 5]) \u003d [2, 3, 4, 5]) \u003d\u003e ((rm1(3)([1, 2, 4, 3]) \u003d [1, 2, 3]) \u003d\u003e ((rm1(3)([1, 2]) \u003d [1, 2]) \u003d\u003e ((rm1(4)([1, 2]) \u003d [1, 2]) \u003d\u003e ((rm1(5)([1, 2]) \u003d [1, 2]) \u003d\u003e ((rm2(1)(\"12345\") \u003d \"2345\") \u003d\u003e pre_(rm2(3)\"1243\")))))))","legal function application obligation:((rm1(1)([1, 2, 3, 4, 5]) \u003d [2, 3, 4, 5]) \u003d\u003e ((rm1(3)([1, 2, 4, 3]) \u003d [1, 2, 3]) \u003d\u003e ((rm1(3)([1, 2]) \u003d [1, 2]) \u003d\u003e ((rm1(4)([1, 2]) \u003d [1, 2]) \u003d\u003e ((rm1(5)([1, 2]) \u003d [1, 2]) \u003d\u003e ((rm2(1)(\"12345\") \u003d \"2345\") \u003d\u003e pre_(rm23)))))))","legal function application obligation:((rm1(1)([1, 2, 3, 4, 5]) \u003d [2, 3, 4, 5]) \u003d\u003e ((rm1(3)([1, 2, 4, 3]) \u003d [1, 2, 3]) \u003d\u003e ((rm1(3)([1, 2]) \u003d [1, 2]) \u003d\u003e ((rm1(4)([1, 2]) \u003d [1, 2]) \u003d\u003e ((rm1(5)([1, 2]) \u003d [1, 2]) \u003d\u003e ((rm2(1)(\"12345\") \u003d \"2345\") \u003d\u003e ((rm2(3)(\"1243\") \u003d \"123\") \u003d\u003e pre_(rm2(3)\"12\"))))))))","legal function application obligation:((rm1(1)([1, 2, 3, 4, 5]) \u003d [2, 3, 4, 5]) \u003d\u003e ((rm1(3)([1, 2, 4, 3]) \u003d [1, 2, 3]) \u003d\u003e ((rm1(3)([1, 2]) \u003d [1, 2]) \u003d\u003e ((rm1(4)([1, 2]) \u003d [1, 2]) \u003d\u003e ((rm1(5)([1, 2]) \u003d [1, 2]) \u003d\u003e ((rm2(1)(\"12345\") \u003d \"2345\") \u003d\u003e ((rm2(3)(\"1243\") \u003d \"123\") \u003d\u003e pre_(rm23))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(up1(1)(10)[1, 2, 3, 4, 5])","legal function application obligation:pre_(up1(1)10)","legal function application obligation:pre_(up11)","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e pre_(up1(3)(40)[1, 2, 4, 3]))","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e pre_(up1(3)40))","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e pre_(up13))","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e ((up1(3)(40)([1, 2, 4, 3]) \u003d [1, 2, 40, 3]) \u003d\u003e pre_(up1(2)(30)[1, 2])))","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e ((up1(3)(40)([1, 2, 4, 3]) \u003d [1, 2, 40, 3]) \u003d\u003e pre_(up1(2)30)))","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e ((up1(3)(40)([1, 2, 4, 3]) \u003d [1, 2, 40, 3]) \u003d\u003e pre_(up12)))","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e ((up1(3)(40)([1, 2, 4, 3]) \u003d [1, 2, 40, 3]) \u003d\u003e ((up1(2)(30)([1, 2]) \u003d [1, 30]) \u003d\u003e pre_(up1(3)(30)[1, 2]))))","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e ((up1(3)(40)([1, 2, 4, 3]) \u003d [1, 2, 40, 3]) \u003d\u003e ((up1(2)(30)([1, 2]) \u003d [1, 30]) \u003d\u003e pre_(up1(3)30))))","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e ((up1(3)(40)([1, 2, 4, 3]) \u003d [1, 2, 40, 3]) \u003d\u003e ((up1(2)(30)([1, 2]) \u003d [1, 30]) \u003d\u003e pre_(up13))))","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e ((up1(3)(40)([1, 2, 4, 3]) \u003d [1, 2, 40, 3]) \u003d\u003e ((up1(2)(30)([1, 2]) \u003d [1, 30]) \u003d\u003e ((up1(3)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e pre_(up1(4)(30)[1, 2])))))","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e ((up1(3)(40)([1, 2, 4, 3]) \u003d [1, 2, 40, 3]) \u003d\u003e ((up1(2)(30)([1, 2]) \u003d [1, 30]) \u003d\u003e ((up1(3)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e pre_(up1(4)30)))))","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e ((up1(3)(40)([1, 2, 4, 3]) \u003d [1, 2, 40, 3]) \u003d\u003e ((up1(2)(30)([1, 2]) \u003d [1, 30]) \u003d\u003e ((up1(3)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e pre_(up14)))))","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e ((up1(3)(40)([1, 2, 4, 3]) \u003d [1, 2, 40, 3]) \u003d\u003e ((up1(2)(30)([1, 2]) \u003d [1, 30]) \u003d\u003e ((up1(3)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e ((up1(4)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e pre_(up2(1)(\u0027a\u0027)\"12345\"))))))","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e ((up1(3)(40)([1, 2, 4, 3]) \u003d [1, 2, 40, 3]) \u003d\u003e ((up1(2)(30)([1, 2]) \u003d [1, 30]) \u003d\u003e ((up1(3)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e ((up1(4)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e pre_(up2(1)\u0027a\u0027))))))","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e ((up1(3)(40)([1, 2, 4, 3]) \u003d [1, 2, 40, 3]) \u003d\u003e ((up1(2)(30)([1, 2]) \u003d [1, 30]) \u003d\u003e ((up1(3)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e ((up1(4)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e pre_(up21))))))","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e ((up1(3)(40)([1, 2, 4, 3]) \u003d [1, 2, 40, 3]) \u003d\u003e ((up1(2)(30)([1, 2]) \u003d [1, 30]) \u003d\u003e ((up1(3)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e ((up1(4)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e ((up2(1)(\u0027a\u0027)(\"12345\") \u003d \"a2345\") \u003d\u003e pre_(up2(3)(\u0027b\u0027)\"1243\")))))))","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e ((up1(3)(40)([1, 2, 4, 3]) \u003d [1, 2, 40, 3]) \u003d\u003e ((up1(2)(30)([1, 2]) \u003d [1, 30]) \u003d\u003e ((up1(3)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e ((up1(4)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e ((up2(1)(\u0027a\u0027)(\"12345\") \u003d \"a2345\") \u003d\u003e pre_(up2(3)\u0027b\u0027)))))))","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e ((up1(3)(40)([1, 2, 4, 3]) \u003d [1, 2, 40, 3]) \u003d\u003e ((up1(2)(30)([1, 2]) \u003d [1, 30]) \u003d\u003e ((up1(3)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e ((up1(4)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e ((up2(1)(\u0027a\u0027)(\"12345\") \u003d \"a2345\") \u003d\u003e pre_(up23)))))))","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e ((up1(3)(40)([1, 2, 4, 3]) \u003d [1, 2, 40, 3]) \u003d\u003e ((up1(2)(30)([1, 2]) \u003d [1, 30]) \u003d\u003e ((up1(3)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e ((up1(4)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e ((up2(1)(\u0027a\u0027)(\"12345\") \u003d \"a2345\") \u003d\u003e ((up2(3)(\u0027b\u0027)(\"1243\") \u003d \"12b3\") \u003d\u003e pre_(up2(3)(\u0027c\u0027)\"123\"))))))))","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e ((up1(3)(40)([1, 2, 4, 3]) \u003d [1, 2, 40, 3]) \u003d\u003e ((up1(2)(30)([1, 2]) \u003d [1, 30]) \u003d\u003e ((up1(3)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e ((up1(4)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e ((up2(1)(\u0027a\u0027)(\"12345\") \u003d \"a2345\") \u003d\u003e ((up2(3)(\u0027b\u0027)(\"1243\") \u003d \"12b3\") \u003d\u003e pre_(up2(3)\u0027c\u0027))))))))","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e ((up1(3)(40)([1, 2, 4, 3]) \u003d [1, 2, 40, 3]) \u003d\u003e ((up1(2)(30)([1, 2]) \u003d [1, 30]) \u003d\u003e ((up1(3)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e ((up1(4)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e ((up2(1)(\u0027a\u0027)(\"12345\") \u003d \"a2345\") \u003d\u003e ((up2(3)(\u0027b\u0027)(\"1243\") \u003d \"12b3\") \u003d\u003e pre_(up23))))))))","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e ((up1(3)(40)([1, 2, 4, 3]) \u003d [1, 2, 40, 3]) \u003d\u003e ((up1(2)(30)([1, 2]) \u003d [1, 30]) \u003d\u003e ((up1(3)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e ((up1(4)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e ((up2(1)(\u0027a\u0027)(\"12345\") \u003d \"a2345\") \u003d\u003e ((up2(3)(\u0027b\u0027)(\"1243\") \u003d \"12b3\") \u003d\u003e ((up2(3)(\u0027c\u0027)(\"123\") \u003d \"12c\") \u003d\u003e pre_(up2(3)(\u0027c\u0027)\"12\")))))))))","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e ((up1(3)(40)([1, 2, 4, 3]) \u003d [1, 2, 40, 3]) \u003d\u003e ((up1(2)(30)([1, 2]) \u003d [1, 30]) \u003d\u003e ((up1(3)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e ((up1(4)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e ((up2(1)(\u0027a\u0027)(\"12345\") \u003d \"a2345\") \u003d\u003e ((up2(3)(\u0027b\u0027)(\"1243\") \u003d \"12b3\") \u003d\u003e ((up2(3)(\u0027c\u0027)(\"123\") \u003d \"12c\") \u003d\u003e pre_(up2(3)\u0027c\u0027)))))))))","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e ((up1(3)(40)([1, 2, 4, 3]) \u003d [1, 2, 40, 3]) \u003d\u003e ((up1(2)(30)([1, 2]) \u003d [1, 30]) \u003d\u003e ((up1(3)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e ((up1(4)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e ((up2(1)(\u0027a\u0027)(\"12345\") \u003d \"a2345\") \u003d\u003e ((up2(3)(\u0027b\u0027)(\"1243\") \u003d \"12b3\") \u003d\u003e ((up2(3)(\u0027c\u0027)(\"123\") \u003d \"12c\") \u003d\u003e pre_(up23)))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(removeDup[])","legal function application obligation:((removeDup([]) \u003d []) \u003d\u003e pre_(removeDup[1, 1, 2, 2, 2, 3, 4, 4, 4, 4]))","legal function application obligation:((removeDup([]) \u003d []) \u003d\u003e ((removeDup([1, 1, 2, 2, 2, 3, 4, 4, 4, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e pre_(removeDup[1, 2, 3, 4])))","legal function application obligation:((removeDup([]) \u003d []) \u003d\u003e ((removeDup([1, 1, 2, 2, 2, 3, 4, 4, 4, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeDup([1, 2, 3, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e pre_(removeMember(1)[]))))","legal function application obligation:((removeDup([]) \u003d []) \u003d\u003e ((removeDup([1, 1, 2, 2, 2, 3, 4, 4, 4, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeDup([1, 2, 3, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e pre_(removeMember1))))","legal function application obligation:((removeDup([]) \u003d []) \u003d\u003e ((removeDup([1, 1, 2, 2, 2, 3, 4, 4, 4, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeDup([1, 2, 3, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeMember(1)([]) \u003d []) \u003d\u003e pre_(removeMember(1)[1, 2, 3])))))","legal function application obligation:((removeDup([]) \u003d []) \u003d\u003e ((removeDup([1, 1, 2, 2, 2, 3, 4, 4, 4, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeDup([1, 2, 3, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeMember(1)([]) \u003d []) \u003d\u003e pre_(removeMember1)))))","legal function application obligation:((removeDup([]) \u003d []) \u003d\u003e ((removeDup([1, 1, 2, 2, 2, 3, 4, 4, 4, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeDup([1, 2, 3, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeMember(1)([]) \u003d []) \u003d\u003e ((removeMember(1)([1, 2, 3]) \u003d [2, 3]) \u003d\u003e pre_(removeMember(4)[1, 2, 3]))))))","legal function application obligation:((removeDup([]) \u003d []) \u003d\u003e ((removeDup([1, 1, 2, 2, 2, 3, 4, 4, 4, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeDup([1, 2, 3, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeMember(1)([]) \u003d []) \u003d\u003e ((removeMember(1)([1, 2, 3]) \u003d [2, 3]) \u003d\u003e pre_(removeMember4))))))","legal function application obligation:((removeDup([]) \u003d []) \u003d\u003e ((removeDup([1, 1, 2, 2, 2, 3, 4, 4, 4, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeDup([1, 2, 3, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeMember(1)([]) \u003d []) \u003d\u003e ((removeMember(1)([1, 2, 3]) \u003d [2, 3]) \u003d\u003e ((removeMember(4)([1, 2, 3]) \u003d [1, 2, 3]) \u003d\u003e pre_(removeMembers([])[])))))))","legal function application obligation:((removeDup([]) \u003d []) \u003d\u003e ((removeDup([1, 1, 2, 2, 2, 3, 4, 4, 4, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeDup([1, 2, 3, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeMember(1)([]) \u003d []) \u003d\u003e ((removeMember(1)([1, 2, 3]) \u003d [2, 3]) \u003d\u003e ((removeMember(4)([1, 2, 3]) \u003d [1, 2, 3]) \u003d\u003e pre_(removeMembers[])))))))","legal function application obligation:((removeDup([]) \u003d []) \u003d\u003e ((removeDup([1, 1, 2, 2, 2, 3, 4, 4, 4, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeDup([1, 2, 3, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeMember(1)([]) \u003d []) \u003d\u003e ((removeMember(1)([1, 2, 3]) \u003d [2, 3]) \u003d\u003e ((removeMember(4)([1, 2, 3]) \u003d [1, 2, 3]) \u003d\u003e ((removeMembers([])([]) \u003d []) \u003d\u003e pre_(removeMembers([])[1, 2, 3]))))))))","legal function application obligation:((removeDup([]) \u003d []) \u003d\u003e ((removeDup([1, 1, 2, 2, 2, 3, 4, 4, 4, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeDup([1, 2, 3, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeMember(1)([]) \u003d []) \u003d\u003e ((removeMember(1)([1, 2, 3]) \u003d [2, 3]) \u003d\u003e ((removeMember(4)([1, 2, 3]) \u003d [1, 2, 3]) \u003d\u003e ((removeMembers([])([]) \u003d []) \u003d\u003e pre_(removeMembers[]))))))))","legal function application obligation:((removeDup([]) \u003d []) \u003d\u003e ((removeDup([1, 1, 2, 2, 2, 3, 4, 4, 4, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeDup([1, 2, 3, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeMember(1)([]) \u003d []) \u003d\u003e ((removeMember(1)([1, 2, 3]) \u003d [2, 3]) \u003d\u003e ((removeMember(4)([1, 2, 3]) \u003d [1, 2, 3]) \u003d\u003e ((removeMembers([])([]) \u003d []) \u003d\u003e ((removeMembers([])([1, 2, 3]) \u003d [1, 2, 3]) \u003d\u003e pre_(removeMembers([1, 2, 3])[])))))))))","legal function application obligation:((removeDup([]) \u003d []) \u003d\u003e ((removeDup([1, 1, 2, 2, 2, 3, 4, 4, 4, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeDup([1, 2, 3, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeMember(1)([]) \u003d []) \u003d\u003e ((removeMember(1)([1, 2, 3]) \u003d [2, 3]) \u003d\u003e ((removeMember(4)([1, 2, 3]) \u003d [1, 2, 3]) \u003d\u003e ((removeMembers([])([]) \u003d []) \u003d\u003e ((removeMembers([])([1, 2, 3]) \u003d [1, 2, 3]) \u003d\u003e pre_(removeMembers[1, 2, 3])))))))))","legal function application obligation:((removeDup([]) \u003d []) \u003d\u003e ((removeDup([1, 1, 2, 2, 2, 3, 4, 4, 4, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeDup([1, 2, 3, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeMember(1)([]) \u003d []) \u003d\u003e ((removeMember(1)([1, 2, 3]) \u003d [2, 3]) \u003d\u003e ((removeMember(4)([1, 2, 3]) \u003d [1, 2, 3]) \u003d\u003e ((removeMembers([])([]) \u003d []) \u003d\u003e ((removeMembers([])([1, 2, 3]) \u003d [1, 2, 3]) \u003d\u003e ((removeMembers([1, 2, 3])([]) \u003d []) \u003d\u003e pre_(removeMembers([1, 2, 3])[1, 2, 3]))))))))))","legal function application obligation:((removeDup([]) \u003d []) \u003d\u003e ((removeDup([1, 1, 2, 2, 2, 3, 4, 4, 4, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeDup([1, 2, 3, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeMember(1)([]) \u003d []) \u003d\u003e ((removeMember(1)([1, 2, 3]) \u003d [2, 3]) \u003d\u003e ((removeMember(4)([1, 2, 3]) \u003d [1, 2, 3]) \u003d\u003e ((removeMembers([])([]) \u003d []) \u003d\u003e ((removeMembers([])([1, 2, 3]) \u003d [1, 2, 3]) \u003d\u003e ((removeMembers([1, 2, 3])([]) \u003d []) \u003d\u003e pre_(removeMembers[1, 2, 3]))))))))))","legal function application obligation:((removeDup([]) \u003d []) \u003d\u003e ((removeDup([1, 1, 2, 2, 2, 3, 4, 4, 4, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeDup([1, 2, 3, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeMember(1)([]) \u003d []) \u003d\u003e ((removeMember(1)([1, 2, 3]) \u003d [2, 3]) \u003d\u003e ((removeMember(4)([1, 2, 3]) \u003d [1, 2, 3]) \u003d\u003e ((removeMembers([])([]) \u003d []) \u003d\u003e ((removeMembers([])([1, 2, 3]) \u003d [1, 2, 3]) \u003d\u003e ((removeMembers([1, 2, 3])([]) \u003d []) \u003d\u003e ((removeMembers([1, 2, 3])([1, 2, 3]) \u003d []) \u003d\u003e pre_(removeMembers([1, 4, 5])[1, 2, 3, 4])))))))))))","legal function application obligation:((removeDup([]) \u003d []) \u003d\u003e ((removeDup([1, 1, 2, 2, 2, 3, 4, 4, 4, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeDup([1, 2, 3, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeMember(1)([]) \u003d []) \u003d\u003e ((removeMember(1)([1, 2, 3]) \u003d [2, 3]) \u003d\u003e ((removeMember(4)([1, 2, 3]) \u003d [1, 2, 3]) \u003d\u003e ((removeMembers([])([]) \u003d []) \u003d\u003e ((removeMembers([])([1, 2, 3]) \u003d [1, 2, 3]) \u003d\u003e ((removeMembers([1, 2, 3])([]) \u003d []) \u003d\u003e ((removeMembers([1, 2, 3])([1, 2, 3]) \u003d []) \u003d\u003e pre_(removeMembers[1, 4, 5])))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(zip[], [])","legal function application obligation:((zip([], []) \u003d []) \u003d\u003e pre_(zip[1, 2, 3], [\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]))","legal function application obligation:((zip([], []) \u003d []) \u003d\u003e ((zip([1, 2, 3], [\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d [mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027), mk_(3, \u0027c\u0027)]) \u003d\u003e pre_(zip[1, 2], [\u0027a\u0027, \u0027b\u0027, \u0027c\u0027])))","legal function application obligation:((zip([], []) \u003d []) \u003d\u003e ((zip([1, 2, 3], [\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d [mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027), mk_(3, \u0027c\u0027)]) \u003d\u003e ((zip([1, 2], [\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d [mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027)]) \u003d\u003e pre_(zip[1, 2, 3], [\u0027a\u0027, \u0027b\u0027]))))","legal function application obligation:((zip([], []) \u003d []) \u003d\u003e ((zip([1, 2, 3], [\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d [mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027), mk_(3, \u0027c\u0027)]) \u003d\u003e ((zip([1, 2], [\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d [mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027)]) \u003d\u003e ((zip([1, 2, 3], [\u0027a\u0027, \u0027b\u0027]) \u003d [mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027)]) \u003d\u003e pre_(zip2([])[])))))","legal function application obligation:((zip([], []) \u003d []) \u003d\u003e ((zip([1, 2, 3], [\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d [mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027), mk_(3, \u0027c\u0027)]) \u003d\u003e ((zip([1, 2], [\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d [mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027)]) \u003d\u003e ((zip([1, 2, 3], [\u0027a\u0027, \u0027b\u0027]) \u003d [mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027)]) \u003d\u003e pre_(zip2[])))))","legal function application obligation:((zip([], []) \u003d []) \u003d\u003e ((zip([1, 2, 3], [\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d [mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027), mk_(3, \u0027c\u0027)]) \u003d\u003e ((zip([1, 2], [\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d [mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027)]) \u003d\u003e ((zip([1, 2, 3], [\u0027a\u0027, \u0027b\u0027]) \u003d [mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027)]) \u003d\u003e ((zip2([])([]) \u003d []) \u003d\u003e pre_(zip2([1, 2, 3])[\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]))))))","legal function application obligation:((zip([], []) \u003d []) \u003d\u003e ((zip([1, 2, 3], [\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d [mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027), mk_(3, \u0027c\u0027)]) \u003d\u003e ((zip([1, 2], [\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d [mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027)]) \u003d\u003e ((zip([1, 2, 3], [\u0027a\u0027, \u0027b\u0027]) \u003d [mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027)]) \u003d\u003e ((zip2([])([]) \u003d []) \u003d\u003e pre_(zip2[1, 2, 3]))))))","legal function application obligation:((zip([], []) \u003d []) \u003d\u003e ((zip([1, 2, 3], [\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d [mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027), mk_(3, \u0027c\u0027)]) \u003d\u003e ((zip([1, 2], [\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d [mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027)]) \u003d\u003e ((zip([1, 2, 3], [\u0027a\u0027, \u0027b\u0027]) \u003d [mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027)]) \u003d\u003e ((zip2([])([]) \u003d []) \u003d\u003e ((zip2([1, 2, 3])([\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d [mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027), mk_(3, \u0027c\u0027)]) \u003d\u003e pre_(unzip[])))))))","legal function application obligation:((zip([], []) \u003d []) \u003d\u003e ((zip([1, 2, 3], [\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d [mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027), mk_(3, \u0027c\u0027)]) \u003d\u003e ((zip([1, 2], [\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d [mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027)]) \u003d\u003e ((zip([1, 2, 3], [\u0027a\u0027, \u0027b\u0027]) \u003d [mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027)]) \u003d\u003e ((zip2([])([]) \u003d []) \u003d\u003e ((zip2([1, 2, 3])([\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d [mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027), mk_(3, \u0027c\u0027)]) \u003d\u003e ((unzip([]) \u003d mk_([], [])) \u003d\u003e pre_(unzip[mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027), mk_(3, \u0027c\u0027)]))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(span(p1)[])","legal function application obligation:pre_(spanp1)","legal function application obligation:((span(p1)([]) \u003d mk_([], [])) \u003d\u003e pre_(span(p1)[2, 4, 6, 1, 3]))","legal function application obligation:((span(p1)([]) \u003d mk_([], [])) \u003d\u003e pre_(spanp1))","legal function application obligation:((span(p1)([]) \u003d mk_([], [])) \u003d\u003e ((span(p1)([2, 4, 6, 1, 3]) \u003d mk_([2, 4, 6], [1, 3])) \u003d\u003e pre_(span(p2)[1, 2, 3, 4, 5])))","legal function application obligation:((span(p1)([]) \u003d mk_([], [])) \u003d\u003e ((span(p1)([2, 4, 6, 1, 3]) \u003d mk_([2, 4, 6], [1, 3])) \u003d\u003e pre_(spanp2)))","legal function application obligation:((span(p1)([]) \u003d mk_([], [])) \u003d\u003e ((span(p1)([2, 4, 6, 1, 3]) \u003d mk_([2, 4, 6], [1, 3])) \u003d\u003e ((span(p2)([1, 2, 3, 4, 5]) \u003d mk_([1, 2, 3, 4, 5], [])) \u003d\u003e pre_(span(p2)[1, 2, 12, 13, 4, 15]))))","legal function application obligation:((span(p1)([]) \u003d mk_([], [])) \u003d\u003e ((span(p1)([2, 4, 6, 1, 3]) \u003d mk_([2, 4, 6], [1, 3])) \u003d\u003e ((span(p2)([1, 2, 3, 4, 5]) \u003d mk_([1, 2, 3, 4, 5], [])) \u003d\u003e pre_(spanp2))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(takeWhile(p1)[])","legal function application obligation:pre_(takeWhilep1)","legal function application obligation:((takeWhile(p1)([]) \u003d []) \u003d\u003e pre_(takeWhile(p1)[2, 4, 6, 8, 1, 3, 5, 2, 4]))","legal function application obligation:((takeWhile(p1)([]) \u003d []) \u003d\u003e pre_(takeWhilep1))","legal function application obligation:((takeWhile(p1)([]) \u003d []) \u003d\u003e ((takeWhile(p1)([2, 4, 6, 8, 1, 3, 5, 2, 4]) \u003d [2, 4, 6, 8]) \u003d\u003e pre_(dropWhile(p1)[])))","legal function application obligation:((takeWhile(p1)([]) \u003d []) \u003d\u003e ((takeWhile(p1)([2, 4, 6, 8, 1, 3, 5, 2, 4]) \u003d [2, 4, 6, 8]) \u003d\u003e pre_(dropWhilep1)))","legal function application obligation:((takeWhile(p1)([]) \u003d []) \u003d\u003e ((takeWhile(p1)([2, 4, 6, 8, 1, 3, 5, 2, 4]) \u003d [2, 4, 6, 8]) \u003d\u003e ((dropWhile(p1)([]) \u003d []) \u003d\u003e pre_(dropWhile(p1)[2, 4, 6, 8, 1, 2, 3, 4, 5]))))","legal function application obligation:((takeWhile(p1)([]) \u003d []) \u003d\u003e ((takeWhile(p1)([2, 4, 6, 8, 1, 3, 5, 2, 4]) \u003d [2, 4, 6, 8]) \u003d\u003e ((dropWhile(p1)([]) \u003d []) \u003d\u003e pre_(dropWhilep1))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(foldl(plus)(0)[1, 2, 3])","legal function application obligation:pre_(foldl(plus)0)","legal function application obligation:pre_(foldlplus)","legal function application obligation:((foldl(plus)(0)([1, 2, 3]) \u003d 6) \u003d\u003e pre_(foldl(product)(1)[2, 3, 4]))","legal function application obligation:((foldl(plus)(0)([1, 2, 3]) \u003d 6) \u003d\u003e pre_(foldl(product)1))","legal function application obligation:((foldl(plus)(0)([1, 2, 3]) \u003d 6) \u003d\u003e pre_(foldlproduct))","legal function application obligation:((foldl(plus)(0)([1, 2, 3]) \u003d 6) \u003d\u003e ((foldl(product)(1)([2, 3, 4]) \u003d 24) \u003d\u003e pre_(f2(append)([])\"abc\")))","legal function application obligation:((foldl(plus)(0)([1, 2, 3]) \u003d 6) \u003d\u003e ((foldl(product)(1)([2, 3, 4]) \u003d 24) \u003d\u003e pre_(f2(append)[])))","legal function application obligation:((foldl(plus)(0)([1, 2, 3]) \u003d 6) \u003d\u003e ((foldl(product)(1)([2, 3, 4]) \u003d 24) \u003d\u003e pre_(f2append)))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(foldr(plus)(0)[1, 2, 3])","legal function application obligation:pre_(foldr(plus)0)","legal function application obligation:pre_(foldrplus)","legal function application obligation:((foldr(plus)(0)([1, 2, 3]) \u003d 6) \u003d\u003e pre_(foldr(product)(1)[2, 3, 4]))","legal function application obligation:((foldr(plus)(0)([1, 2, 3]) \u003d 6) \u003d\u003e pre_(foldr(product)1))","legal function application obligation:((foldr(plus)(0)([1, 2, 3]) \u003d 6) \u003d\u003e pre_(foldrproduct))","legal function application obligation:((foldr(plus)(0)([1, 2, 3]) \u003d 6) \u003d\u003e ((foldr(product)(1)([2, 3, 4]) \u003d 24) \u003d\u003e pre_(f3(removeAt)(\"12345\")[1, 3, 5])))","legal function application obligation:((foldr(plus)(0)([1, 2, 3]) \u003d 6) \u003d\u003e ((foldr(product)(1)([2, 3, 4]) \u003d 24) \u003d\u003e pre_(f3(removeAt)\"12345\")))","legal function application obligation:((foldr(plus)(0)([1, 2, 3]) \u003d 6) \u003d\u003e ((foldr(product)(1)([2, 3, 4]) \u003d 24) \u003d\u003e pre_(f3removeAt)))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(Real`EQ(((sq.GetAverage))[real]([1.1, 2.2, 3.3]))2.2)","type compatibility obligation:is_(((sq.GetAverage))[real]([1.1, 2.2, 3.3]), real)","legal function application obligation:pre_(((sq.GetAverage))[real][1.1, 2.2, 3.3])","legal function application obligation:(Real`EQ(((sq.GetAverage))[real]([1.1, 2.2, 3.3]))(2.2) \u003d\u003e pre_(Real`EQ(((sq.GetAverage))[real]([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]))5.5))","type compatibility obligation:(Real`EQ(((sq.GetAverage))[real]([1.1, 2.2, 3.3]))(2.2) \u003d\u003e is_(((sq.GetAverage))[real]([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]), real))","legal function application obligation:(Real`EQ(((sq.GetAverage))[real]([1.1, 2.2, 3.3]))(2.2) \u003d\u003e pre_(((sq.GetAverage))[real][1, 2, 3, 4, 5, 6, 7, 8, 9, 10]))","type compatibility obligation:is_(RESULT, ())","type compatibility obligation:is_(RESULT, ())","type compatibility obligation:is_(RESULT, ())","enumeration map injectivity obligation:(forall m1, m2 in set {{\u00270\u0027 |-\u003e 1}, {\u00271\u0027 |-\u003e 2}, {\u00272\u0027 |-\u003e 3}, {\u00273\u0027 |-\u003e 4}, {\u00274\u0027 |-\u003e 5}, {\u00275\u0027 |-\u003e 6}, {\u00276\u0027 |-\u003e 7}, {\u00277\u0027 |-\u003e 8}, {\u00278\u0027 |-\u003e 9}, {\u00279\u0027 |-\u003e 10}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","enumeration map injectivity obligation:(forall m1, m2 in set {{\u0027A\u0027 |-\u003e 12}, {\u0027B\u0027 |-\u003e 14}, {\u0027C\u0027 |-\u003e 16}, {\u0027D\u0027 |-\u003e 18}, {\u0027E\u0027 |-\u003e 20}, {\u0027F\u0027 |-\u003e 22}, {\u0027G\u0027 |-\u003e 24}, {\u0027H\u0027 |-\u003e 26}, {\u0027I\u0027 |-\u003e 28}, {\u0027J\u0027 |-\u003e 30}, {\u0027K\u0027 |-\u003e 32}, {\u0027L\u0027 |-\u003e 34}, {\u0027M\u0027 |-\u003e 36}, {\u0027N\u0027 |-\u003e 38}, {\u0027O\u0027 |-\u003e 40}, {\u0027P\u0027 |-\u003e 42}, {\u0027Q\u0027 |-\u003e 44}, {\u0027R\u0027 |-\u003e 46}, {\u0027S\u0027 |-\u003e 48}, {\u0027T\u0027 |-\u003e 50}, {\u0027U\u0027 |-\u003e 52}, {\u0027V\u0027 |-\u003e 54}, {\u0027W\u0027 |-\u003e 56}, {\u0027X\u0027 |-\u003e 58}, {\u0027Y\u0027 |-\u003e 60}, {\u0027Z\u0027 |-\u003e 62}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","enumeration map injectivity obligation:(forall m1, m2 in set {{\u0027a\u0027 |-\u003e 11}, {\u0027b\u0027 |-\u003e 13}, {\u0027c\u0027 |-\u003e 15}, {\u0027d\u0027 |-\u003e 17}, {\u0027e\u0027 |-\u003e 19}, {\u0027f\u0027 |-\u003e 21}, {\u0027g\u0027 |-\u003e 23}, {\u0027h\u0027 |-\u003e 25}, {\u0027i\u0027 |-\u003e 27}, {\u0027j\u0027 |-\u003e 29}, {\u0027k\u0027 |-\u003e 31}, {\u0027l\u0027 |-\u003e 33}, {\u0027m\u0027 |-\u003e 35}, {\u0027n\u0027 |-\u003e 37}, {\u0027o\u0027 |-\u003e 39}, {\u0027p\u0027 |-\u003e 41}, {\u0027q\u0027 |-\u003e 43}, {\u0027r\u0027 |-\u003e 45}, {\u0027s\u0027 |-\u003e 47}, {\u0027t\u0027 |-\u003e 49}, {\u0027u\u0027 |-\u003e 51}, {\u0027v\u0027 |-\u003e 53}, {\u0027w\u0027 |-\u003e 55}, {\u0027x\u0027 |-\u003e 57}, {\u0027y\u0027 |-\u003e 59}, {\u0027z\u0027 |-\u003e 61}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","map compatible obligation:(forall ldom1 in set (dom vNumOrderMap), rdom2 in set (dom vChapitalCharOrderMap) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (vNumOrderMap(ldom1) \u003d vChapitalCharOrderMap(rdom2))))","map compatible obligation:(forall ldom1 in set (dom (vNumOrderMap munion vChapitalCharOrderMap)), rdom2 in set (dom vSmallCharOrderMap) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e ((vNumOrderMap munion vChapitalCharOrderMap)(ldom1) \u003d vSmallCharOrderMap(rdom2))))","type compatibility obligation:(forall c:char \u0026 (is_((if isDigit(c)\nthen let s:seq1 of (char) \u003d [c] in let mk_(-, i):(bool * [int]) \u003d (VDMUtil`seq_of_char2val)[int](s) in i\nelse false), bool) or is_((if isDigit(c)\nthen let s:seq1 of (char) \u003d [c] in let mk_(-, i):(bool * [int]) \u003d (VDMUtil`seq_of_char2val)[int](s) in i\nelse false), int)))","legal map application obligation:(forall c:char \u0026 ((c in set (dom vCharOrderMap)) \u003d\u003e (c in set (dom vCharOrderMap))))","map compatible obligation:(forall c:char \u0026 (forall ldom1 in set (dom vChapitalCharOrderMap), rdom2 in set (dom vSmallCharOrderMap) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (vChapitalCharOrderMap(ldom1) \u003d vSmallCharOrderMap(rdom2)))))","legal function application obligation:(forall c1:char, c2:char \u0026 pre_(Character`LT2(c1)c2))","legal function application obligation:(forall c1:char, c2:char \u0026 pre_(Character`LE2(c1)c2))","legal function application obligation:(forall c1:char, c2:char \u0026 pre_(Character`LT2(c1)c2))","legal function application obligation:(forall c1:char, c2:char \u0026 pre_(Character`GT2(c1)c2))","legal function application obligation:(forall c1:char, c2:char \u0026 pre_(Character`LT2(c2)c1))","legal function application obligation:(forall c1:char, c2:char \u0026 pre_(Character`GE2(c1)c2))","legal function application obligation:(forall c1:char, c2:char \u0026 pre_(Character`LT2(c1)c2))","legal map application obligation:(forall aMap:map (@T1) to (@T2), aKey:@T1 \u0026 ((aKey in set (dom aMap)) \u003d\u003e (aKey in set (dom aMap))))","legal function application obligation:pre_((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(-3)4)","legal function application obligation:pre_((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))-3)","legal function application obligation:(((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(-3)(4) \u003d -3) \u003d\u003e pre_((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(4)-3))","legal function application obligation:(((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(-3)(4) \u003d -3) \u003d\u003e pre_((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))4))","legal function application obligation:(((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(-3)(4) \u003d -3) \u003d\u003e (((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(4)(-3) \u003d -3) \u003d\u003e pre_((Number`min)[nat]((lambda [x:nat, y:nat] \u0026 (x \u003c y)))(2)10)))","legal function application obligation:(((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(-3)(4) \u003d -3) \u003d\u003e (((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(4)(-3) \u003d -3) \u003d\u003e pre_((Number`min)[nat]((lambda [x:nat, y:nat] \u0026 (x \u003c y)))2)))","legal function application obligation:(((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(-3)(4) \u003d -3) \u003d\u003e (((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(4)(-3) \u003d -3) \u003d\u003e (((Number`min)[nat]((lambda [x:nat, y:nat] \u0026 (x \u003c y)))(2)(10) \u003d 2) \u003d\u003e pre_((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(0)0))))","legal function application obligation:(((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(-3)(4) \u003d -3) \u003d\u003e (((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(4)(-3) \u003d -3) \u003d\u003e (((Number`min)[nat]((lambda [x:nat, y:nat] \u0026 (x \u003c y)))(2)(10) \u003d 2) \u003d\u003e pre_((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))0))))","legal function application obligation:(((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(-3)(4) \u003d -3) \u003d\u003e (((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(4)(-3) \u003d -3) \u003d\u003e (((Number`min)[nat]((lambda [x:nat, y:nat] \u0026 (x \u003c y)))(2)(10) \u003d 2) \u003d\u003e (((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(0)(0) \u003d 0) \u003d\u003e pre_((Number`max)[real]((lambda [x:real, y:real] \u0026 (x \u003c y)))(0.001)-0.001)))))","legal function application obligation:(((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(-3)(4) \u003d -3) \u003d\u003e (((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(4)(-3) \u003d -3) \u003d\u003e (((Number`min)[nat]((lambda [x:nat, y:nat] \u0026 (x \u003c y)))(2)(10) \u003d 2) \u003d\u003e (((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(0)(0) \u003d 0) \u003d\u003e pre_((Number`max)[real]((lambda [x:real, y:real] \u0026 (x \u003c y)))0.001)))))","legal function application obligation:(((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(-3)(4) \u003d -3) \u003d\u003e (((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(4)(-3) \u003d -3) \u003d\u003e (((Number`min)[nat]((lambda [x:nat, y:nat] \u0026 (x \u003c y)))(2)(10) \u003d 2) \u003d\u003e (((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(0)(0) \u003d 0) \u003d\u003e (((Number`max)[real]((lambda [x:real, y:real] \u0026 (x \u003c y)))(0.001)(-0.001) \u003d 0.001) \u003d\u003e pre_((Number`max)[real]((lambda [x:real, y:real] \u0026 (x \u003c y)))(-0.001)0.001))))))","legal function application obligation:(((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(-3)(4) \u003d -3) \u003d\u003e (((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(4)(-3) \u003d -3) \u003d\u003e (((Number`min)[nat]((lambda [x:nat, y:nat] \u0026 (x \u003c y)))(2)(10) \u003d 2) \u003d\u003e (((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(0)(0) \u003d 0) \u003d\u003e (((Number`max)[real]((lambda [x:real, y:real] \u0026 (x \u003c y)))(0.001)(-0.001) \u003d 0.001) \u003d\u003e pre_((Number`max)[real]((lambda [x:real, y:real] \u0026 (x \u003c y)))-0.001))))))","legal function application obligation:(((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(-3)(4) \u003d -3) \u003d\u003e (((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(4)(-3) \u003d -3) \u003d\u003e (((Number`min)[nat]((lambda [x:nat, y:nat] \u0026 (x \u003c y)))(2)(10) \u003d 2) \u003d\u003e (((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(0)(0) \u003d 0) \u003d\u003e (((Number`max)[real]((lambda [x:real, y:real] \u0026 (x \u003c y)))(0.001)(-0.001) \u003d 0.001) \u003d\u003e (((Number`max)[real]((lambda [x:real, y:real] \u0026 (x \u003c y)))(-0.001)(0.001) \u003d 0.001) \u003d\u003e pre_((Number`max)[real]((lambda [x:real, y:real] \u0026 (x \u003c y)))(0.0)0.0)))))))","legal function application obligation:(((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(-3)(4) \u003d -3) \u003d\u003e (((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(4)(-3) \u003d -3) \u003d\u003e (((Number`min)[nat]((lambda [x:nat, y:nat] \u0026 (x \u003c y)))(2)(10) \u003d 2) \u003d\u003e (((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(0)(0) \u003d 0) \u003d\u003e (((Number`max)[real]((lambda [x:real, y:real] \u0026 (x \u003c y)))(0.001)(-0.001) \u003d 0.001) \u003d\u003e (((Number`max)[real]((lambda [x:real, y:real] \u0026 (x \u003c y)))(-0.001)(0.001) \u003d 0.001) \u003d\u003e pre_((Number`max)[real]((lambda [x:real, y:real] \u0026 (x \u003c y)))0.0)))))))","type compatibility obligation:is_(RESULT, ())","type compatibility obligation:(((Number`isComputable)[char](\u0027a\u0027) \u003d false) \u003d\u003e (((Number`isComputable)[int](-9) \u003d true) \u003d\u003e (((Number`isComputable)[nat](0) \u003d true) \u003d\u003e (((Number`isComputable)[nat1](1) \u003d true) \u003d\u003e (((Number`isComputable)[real](1.234) \u003d true) \u003d\u003e is_(1.234, rat))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((Number`min)[seq of (int)]((lambda [s1:seq of (int), s2:seq of (int)] \u0026 ((len s1) \u003c (len s2))))([1, 2])[1, 2, 3])","legal function application obligation:pre_((Number`min)[seq of (int)]((lambda [s1:seq of (int), s2:seq of (int)] \u0026 ((len s1) \u003c (len s2))))[1, 2])","legal function application obligation:(((Number`min)[seq of (int)]((lambda [s1:seq of (int), s2:seq of (int)] \u0026 ((len s1) \u003c (len s2))))([1, 2])([1, 2, 3]) \u003d [1, 2]) \u003d\u003e pre_((Number`max)[seq of (int)]((lambda [s1:seq of (int), s2:seq of (int)] \u0026 ((len s1) \u003c (len s2))))([1, 2])[1, 2, 3]))","legal function application obligation:(((Number`min)[seq of (int)]((lambda [s1:seq of (int), s2:seq of (int)] \u0026 ((len s1) \u003c (len s2))))([1, 2])([1, 2, 3]) \u003d [1, 2]) \u003d\u003e pre_((Number`max)[seq of (int)]((lambda [s1:seq of (int), s2:seq of (int)] \u0026 ((len s1) \u003c (len s2))))[1, 2]))","type compatibility obligation:is_(RESULT, ())","type invariant satisfiable obligation:(exists d:NumberOfDayOfTheWeek \u0026 (d \u003c\u003d 6))","type compatibility obligation:(forall date:Date \u0026 (inv_NumberOfDayOfTheWeek(let modifiedJulianDate:int \u003d (floor (date.getModifiedJulianDate)()) in ((modifiedJulianDate - 4) mod daysInWeek)) and is_(let modifiedJulianDate:int \u003d (floor (date.getModifiedJulianDate)()) in ((modifiedJulianDate - 4) mod daysInWeek), nat)))","legal sequence application obligation:(forall date:Date \u0026 ((getNumberOfDayOfTheWeek(date) + 1) in set (inds namesOfDayOfTheWeek)))","legal function application obligation:(forall nameOfDayOfTheWeek:NameOfDayOfTheWeek \u0026 pre_((Sequence`Index)[NameOfDayOfTheWeek](nameOfDayOfTheWeek)namesOfDayOfTheWeek))","type compatibility obligation:(forall nameOfDayOfTheWeek:NameOfDayOfTheWeek \u0026 (inv_NumberOfDayOfTheWeek(((Sequence`Index)[NameOfDayOfTheWeek](nameOfDayOfTheWeek)(namesOfDayOfTheWeek) - 1)) and is_(((Sequence`Index)[NameOfDayOfTheWeek](nameOfDayOfTheWeek)(namesOfDayOfTheWeek) - 1), nat)))","cases exhaustive obligation:(forall year:int, month:int, nameOfDayOfTheWeek:NameOfDayOfTheWeek \u0026 let numberOfDayOfTheWeek:NumberOfDayOfTheWeek \u003d getNumberOfDayOfTheWeekFromName(nameOfDayOfTheWeek), firstDayOfMonth:Date \u003d getFirstDayOfMonth(year, month), diff:int \u003d (numberOfDayOfTheWeek - getNumberOfDayOfTheWeek(firstDayOfMonth)) in (((true \u003d (diff \u003d 0)) or (true \u003d (diff \u003e 0))) or (true \u003d (diff \u003c 0))))","legal function application obligation:(forall date1:Date, date2:Date, nameOfDayOfTheWeek:NameOfDayOfTheWeek \u0026 pre_(min(date1)date2))","legal function application obligation:(forall date1:Date, date2:Date, nameOfDayOfTheWeek:NameOfDayOfTheWeek \u0026 pre_(max(date1)date2))","non-zero obligation:(forall date1:Date, date2:Date, nameOfDayOfTheWeek:NameOfDayOfTheWeek \u0026 (daysInWeek \u003c\u003e 0))","non-zero obligation:(forall date:Date \u0026 (averageDaysInMonth \u003c\u003e 0))","non-zero obligation:(forall date:Date \u0026 (daysInYear \u003c\u003e 0))","non-zero obligation:(forall candidateYear:int, candidateOfMonth:int \u0026 ((candidateOfMonth \u003c\u003d 0) \u003d\u003e (monthsInYear \u003c\u003e 0)))","non-zero obligation:(forall candidateYear:int, candidateOfMonth:int \u0026 ((not (candidateOfMonth \u003c\u003d 0)) \u003d\u003e (monthsInYear \u003c\u003e 0)))","non-zero obligation:(forall year:int, month:int, day:int \u0026 (monthsInYear \u003c\u003e 0))","non-zero obligation:(forall year:int, month:int, day:int \u0026 (daysInYear \u003c\u003e 0))","legal function application obligation:(forall date:Date \u0026 pre_((date.date2Str)))","type compatibility obligation:(forall dateStr:seq of (char) \u0026 is_(let date:(Date | bool) \u003d getDateFromString(dateStr) in (if (date \u003d false)\nthen nil\nelse date), [Date]))","legal function application obligation:(forall date1:Date, date2:Date \u0026 pre_(min(date1)date2))","legal function application obligation:(forall date1:Date, date2:Date \u0026 pre_(max(date1)date2))","legal function application obligation:(forall date1:Date, date2:Date \u0026 pre_(min(date1)date2))","legal function application obligation:(forall date1:Date, date2:Date \u0026 pre_(max(date1)date2))","legal function application obligation:(forall date1:Date, date2:Date \u0026 pre_(min(date1)date2))","legal function application obligation:(forall date1:Date, date2:Date \u0026 pre_(max(date1)date2))","recursive function obligation:(forall date:Date \u0026 ((true \u003d (isSundayOrDayoff(date) or isSaturday(date))) \u003d\u003e (getPastWeekdaymeasure(date) \u003e getPastWeekdaymeasure((date.minus)(1)))))","type compatibility obligation:(forall d:Date \u0026 is_((d.getModifiedJulianDate)(), nat))","legal function application obligation:(forall date:Date \u0026 pre_((date.Year)))","non-zero obligation:(forall year:int, month:int, day:int \u0026 (yearInCentury \u003c\u003e 0))","legal function application obligation:(forall yyyymmdd:seq of (char) \u0026 pre_((getDateFrom_yyyy_mm_dd(year, month, day).date2Str)))","legal function application obligation:(forall year:int, dayOfWeek:NameOfDayOfTheWeek \u0026 pre_((self.getNthDayOfTheWeek)year, 1, 1, dayOfWeek))","type compatibility obligation:(forall year:int, dayOfWeek:NameOfDayOfTheWeek \u0026 is_((self.getNthDayOfTheWeek)(year, 1, 1, dayOfWeek), Date))","while loop termination obligation:NotYetImplemented","legal function application obligation:(forall year:int, dayOfWeek:NameOfDayOfTheWeek \u0026 pre_((self.lastDayOfTheWeekInMonth)year, 12, dayOfWeek))","legal map application obligation:(forall aYear:int \u0026 (aYear in set (dom (self.Year2Holidays))))","legal function application obligation:(forall fname:seq of (char) \u0026 pre_(((io.freadval))[(int * int * int)]fname))","type compatibility obligation:is_(RESULT, Date)","type compatibility obligation:(forall fname:seq of (char) \u0026 is_(RESULT, Date))","type compatibility obligation:(forall i:int \u0026 ((i \u003c 0) \u003d\u003e (-i \u003e\u003d 0)))","type compatibility obligation:(forall i:int \u0026 ((not (i \u003c 0)) \u003d\u003e (i \u003e\u003d 0)))","type compatibility obligation:(forall n:nat \u0026 let r:int \u003d (n mod 10), q:int \u003d (n div 10) in ((not (0 \u003d q)) \u003d\u003e (q \u003e\u003d 0)))","recursive function obligation:(forall n:nat \u0026 let r:int \u003d (n mod 10), q:int \u003d (n div 10) in ((not (0 \u003d q)) \u003d\u003e (ndiv10(n) \u003e ndiv10(q))))","type compatibility obligation:(forall n:nat \u0026 is_(let r:int \u003d (n mod 10), q:int \u003d (n div 10) in (cases q :\n0 -\u003e asChar(r)\nothers (asStringAux(q) ^ asChar(r))\n end), seq1 of (char)))","type compatibility obligation:(forall n:nat \u0026 ((n div 10) \u003e\u003d 0))","legal sequence application obligation:(forall cobolStrConversionCommand:seq of (char), i:int \u0026 let minusSymbol:char \u003d \u0027-\u0027 in ((i \u003c 0) \u003d\u003e (1 in set (inds cobolStrConversionCommand))))","legal function application obligation:(forall cobolStrConversionCommand:seq of (char), i:int \u0026 let minusSymbol:char \u003d \u0027-\u0027 in ((i \u003c 0) \u003d\u003e ((cobolStrConversionCommand(1) \u003d minusSymbol) \u003d\u003e pre_(asStringZAux(String`subStr(cobolStrConversionCommand, 2, (len cobolStrConversionCommand)))-i, true))))","type compatibility obligation:(forall cobolStrConversionCommand:seq of (char), i:int \u0026 let minusSymbol:char \u003d \u0027-\u0027 in ((i \u003c 0) \u003d\u003e ((cobolStrConversionCommand(1) \u003d minusSymbol) \u003d\u003e (-i \u003e\u003d 0))))","type compatibility obligation:(forall cobolStrConversionCommand:seq of (char), i:int \u0026 let minusSymbol:char \u003d \u0027-\u0027 in ((i \u003c 0) \u003d\u003e ((cobolStrConversionCommand(1) \u003d minusSymbol) \u003d\u003e is_(cobolStrConversionCommand, seq1 of (char)))))","legal function application obligation:(forall cobolStrConversionCommand:seq of (char), i:int \u0026 let minusSymbol:char \u003d \u0027-\u0027 in ((i \u003c 0) \u003d\u003e ((not (cobolStrConversionCommand(1) \u003d minusSymbol)) \u003d\u003e pre_(asStringZAux(cobolStrConversionCommand)-i, true))))","type compatibility obligation:(forall cobolStrConversionCommand:seq of (char), i:int \u0026 let minusSymbol:char \u003d \u0027-\u0027 in ((i \u003c 0) \u003d\u003e ((not (cobolStrConversionCommand(1) \u003d minusSymbol)) \u003d\u003e (-i \u003e\u003d 0))))","legal sequence application obligation:(forall cobolStrConversionCommand:seq of (char), i:int \u0026 let minusSymbol:char \u003d \u0027-\u0027 in ((not (i \u003c 0)) \u003d\u003e (1 in set (inds cobolStrConversionCommand))))","legal function application obligation:(forall cobolStrConversionCommand:seq of (char), i:int \u0026 let minusSymbol:char \u003d \u0027-\u0027 in ((not (i \u003c 0)) \u003d\u003e ((cobolStrConversionCommand(1) \u003d minusSymbol) \u003d\u003e pre_(asStringZAux(String`subStr(cobolStrConversionCommand, 2, (len cobolStrConversionCommand)))i, true))))","type compatibility obligation:(forall cobolStrConversionCommand:seq of (char), i:int \u0026 let minusSymbol:char \u003d \u0027-\u0027 in ((not (i \u003c 0)) \u003d\u003e ((cobolStrConversionCommand(1) \u003d minusSymbol) \u003d\u003e (i \u003e\u003d 0))))","type compatibility obligation:(forall cobolStrConversionCommand:seq of (char), i:int \u0026 let minusSymbol:char \u003d \u0027-\u0027 in ((not (i \u003c 0)) \u003d\u003e ((cobolStrConversionCommand(1) \u003d minusSymbol) \u003d\u003e is_(cobolStrConversionCommand, seq1 of (char)))))","legal function application obligation:(forall cobolStrConversionCommand:seq of (char), i:int \u0026 let minusSymbol:char \u003d \u0027-\u0027 in ((not (i \u003c 0)) \u003d\u003e ((not (cobolStrConversionCommand(1) \u003d minusSymbol)) \u003d\u003e pre_(asStringZAux(cobolStrConversionCommand)i, true))))","type compatibility obligation:(forall cobolStrConversionCommand:seq of (char), i:int \u0026 let minusSymbol:char \u003d \u0027-\u0027 in ((not (i \u003c 0)) \u003d\u003e ((not (cobolStrConversionCommand(1) \u003d minusSymbol)) \u003d\u003e (i \u003e\u003d 0))))","legal sequence application obligation:(forall cobolStrConversionCommand:seq of (char), n:nat, wasZero:bool \u0026 (cobolStrConversionCommandStrLen in set (inds cobolStrConversionCommand)))","type compatibility obligation:(forall cobolStrConversionCommand:seq of (char), n:nat, wasZero:bool \u0026 is_(cobolStrConversionCommand, seq1 of (char)))","type compatibility obligation:(forall cobolStrConversionCommand:seq of (char), n:nat, wasZero:bool \u0026 ((cobolStrConversionCommandStrLen - 1) \u003e\u003d 0))","legal function application obligation:(forall cobolStrConversionCommand:seq of (char), n:nat, wasZero:bool \u0026 let cobolStrConversionCommandStrLen:nat \u003d (len cobolStrConversionCommand), cobolStrConversionCommandChar:char \u003d cobolStrConversionCommand(cobolStrConversionCommandStrLen), cobolStrConversionCommandStr:seq of (char) \u003d String`subStr(cobolStrConversionCommand, 1, (cobolStrConversionCommandStrLen - 1)), r:int \u003d (n mod 10), q:int \u003d (n div 10), isZero:bool \u003d ((r \u003d 0) and (wasZero and (q \u003c\u003e 0))) in (([] \u003d cobolStrConversionCommandStr) \u003d\u003e pre_(asCharZ(cobolStrConversionCommandChar)r, isZero)))","type compatibility obligation:(forall cobolStrConversionCommand:seq of (char), n:nat, wasZero:bool \u0026 let cobolStrConversionCommandStrLen:nat \u003d (len cobolStrConversionCommand), cobolStrConversionCommandChar:char \u003d cobolStrConversionCommand(cobolStrConversionCommandStrLen), cobolStrConversionCommandStr:seq of (char) \u003d String`subStr(cobolStrConversionCommand, 1, (cobolStrConversionCommandStrLen - 1)), r:int \u003d (n mod 10), q:int \u003d (n div 10), isZero:bool \u003d ((r \u003d 0) and (wasZero and (q \u003c\u003e 0))) in (([] \u003d cobolStrConversionCommandStr) \u003d\u003e (r \u003e\u003d 0)))","legal function application obligation:(forall cobolStrConversionCommand:seq of (char), n:nat, wasZero:bool \u0026 let cobolStrConversionCommandStrLen:nat \u003d (len cobolStrConversionCommand), cobolStrConversionCommandChar:char \u003d cobolStrConversionCommand(cobolStrConversionCommandStrLen), cobolStrConversionCommandStr:seq of (char) \u003d String`subStr(cobolStrConversionCommand, 1, (cobolStrConversionCommandStrLen - 1)), r:int \u003d (n mod 10), q:int \u003d (n div 10), isZero:bool \u003d ((r \u003d 0) and (wasZero and (q \u003c\u003e 0))) in ((not ([] \u003d cobolStrConversionCommandStr)) \u003d\u003e pre_(asStringZAux(cobolStrConversionCommandStr)q, isZero)))","type compatibility obligation:(forall cobolStrConversionCommand:seq of (char), n:nat, wasZero:bool \u0026 let cobolStrConversionCommandStrLen:nat \u003d (len cobolStrConversionCommand), cobolStrConversionCommandChar:char \u003d cobolStrConversionCommand(cobolStrConversionCommandStrLen), cobolStrConversionCommandStr:seq of (char) \u003d String`subStr(cobolStrConversionCommand, 1, (cobolStrConversionCommandStrLen - 1)), r:int \u003d (n mod 10), q:int \u003d (n div 10), isZero:bool \u003d ((r \u003d 0) and (wasZero and (q \u003c\u003e 0))) in ((not ([] \u003d cobolStrConversionCommandStr)) \u003d\u003e (q \u003e\u003d 0)))","legal function application obligation:(forall cobolStrConversionCommand:seq of (char), n:nat, wasZero:bool \u0026 let cobolStrConversionCommandStrLen:nat \u003d (len cobolStrConversionCommand), cobolStrConversionCommandChar:char \u003d cobolStrConversionCommand(cobolStrConversionCommandStrLen), cobolStrConversionCommandStr:seq of (char) \u003d String`subStr(cobolStrConversionCommand, 1, (cobolStrConversionCommandStrLen - 1)), r:int \u003d (n mod 10), q:int \u003d (n div 10), isZero:bool \u003d ((r \u003d 0) and (wasZero and (q \u003c\u003e 0))) in ((not ([] \u003d cobolStrConversionCommandStr)) \u003d\u003e pre_(asCharZ(cobolStrConversionCommandChar)r, isZero)))","type compatibility obligation:(forall cobolStrConversionCommand:seq of (char), n:nat, wasZero:bool \u0026 let cobolStrConversionCommandStrLen:nat \u003d (len cobolStrConversionCommand), cobolStrConversionCommandChar:char \u003d cobolStrConversionCommand(cobolStrConversionCommandStrLen), cobolStrConversionCommandStr:seq of (char) \u003d String`subStr(cobolStrConversionCommand, 1, (cobolStrConversionCommandStrLen - 1)), r:int \u003d (n mod 10), q:int \u003d (n div 10), isZero:bool \u003d ((r \u003d 0) and (wasZero and (q \u003c\u003e 0))) in ((not ([] \u003d cobolStrConversionCommandStr)) \u003d\u003e (r \u003e\u003d 0)))","type compatibility obligation:(forall cobolStrConversionCommand:seq of (char), n:nat, wasZero:bool \u0026 is_(let cobolStrConversionCommandStrLen:nat \u003d (len cobolStrConversionCommand), cobolStrConversionCommandChar:char \u003d cobolStrConversionCommand(cobolStrConversionCommandStrLen), cobolStrConversionCommandStr:seq of (char) \u003d String`subStr(cobolStrConversionCommand, 1, (cobolStrConversionCommandStrLen - 1)), r:int \u003d (n mod 10), q:int \u003d (n div 10), isZero:bool \u003d ((r \u003d 0) and (wasZero and (q \u003c\u003e 0))) in (cases cobolStrConversionCommandStr :\n[] -\u003e asCharZ(cobolStrConversionCommandChar)(r, isZero)\nothers (asStringZAux(cobolStrConversionCommandStr)(q, isZero) ^ asCharZ(cobolStrConversionCommandChar)(r, isZero))\n end), seq1 of (char)))","legal function application obligation:(forall x:nat, y:nat \u0026 ((not (y \u003d 0)) \u003d\u003e pre_(GCD(y)(x rem y))))","type compatibility obligation:(forall x:nat, y:nat \u0026 ((not (y \u003d 0)) \u003d\u003e ((x rem y) \u003e\u003d 0)))","legal function application obligation:(forall x:nat, y:nat \u0026 ((not (exists mk_(-, 0):(nat * nat) \u0026 (mk_(any1, 0) \u003d mk_(x, y)))) \u003d\u003e ((not (exists mk_(0, -):(nat * nat) \u0026 (mk_(0, any1) \u003d mk_(x, y)))) \u003d\u003e (exists mk_(z, w):(nat * nat) \u0026 ((mk_(z, w) \u003d mk_(x, y)) \u003d\u003e let mk_(z, w) \u003d mk_(x, y) in pre_(GCD(z)w))))))","non-zero obligation:(forall x:nat, y:nat \u0026 ((not (exists mk_(-, 0):(nat * nat) \u0026 (mk_(any1, 0) \u003d mk_(x, y)))) \u003d\u003e ((not (exists mk_(0, -):(nat * nat) \u0026 (mk_(0, any1) \u003d mk_(x, y)))) \u003d\u003e (exists mk_(z, w):(nat * nat) \u0026 ((mk_(z, w) \u003d mk_(x, y)) \u003d\u003e let mk_(z, w) \u003d mk_(x, y) in (GCD(z)(w) \u003c\u003e 0))))))","cases exhaustive obligation:(forall x:nat, y:nat \u0026 (((exists mk_(-, 0):(nat * nat) \u0026 (mk_(x, y) \u003d mk_(any1, 0))) or (exists mk_(0, -):(nat * nat) \u0026 (mk_(x, y) \u003d mk_(0, any1)))) or (exists mk_(z, w):(nat * nat) \u0026 (mk_(x, y) \u003d mk_(z, w)))))","type compatibility obligation:(forall x:nat, y:nat \u0026 is_((cases mk_(x, y) :\nmk_(-, 0) -\u003e 0,\nmk_(0, -) -\u003e 0,\nmk_(z, w) -\u003e ((z / GCD(z)(w)) * w)\n end), nat))","legal function application obligation:(forall aTime:Time, aPeriod:Term \u0026 ((not ((aPeriod.getStartTime)() \u003d nil)) \u003d\u003e pre_(((aPeriod.getStartTime)().LE)aTime)))","legal function application obligation:(forall aTime:Time, aPeriod:Term \u0026 ((((aPeriod.getStartTime)() \u003d nil) or ((aPeriod.getStartTime)().LE)(aTime)) \u003d\u003e ((not ((aPeriod.getEndTime)() \u003d nil)) \u003d\u003e pre_(((aPeriod.getEndTime)().GE)aTime))))","legal function application obligation:(forall aPeriod:Term \u0026 pre_(((self.getStartTime)().EQ)(aPeriod.getStartTime)()))","type compatibility obligation:(forall aPeriod:Term \u0026 is_((aPeriod.getStartTime)(), Time))","legal function application obligation:(forall aPeriod:Term \u0026 (((self.getStartTime)().EQ)((aPeriod.getStartTime)()) \u003d\u003e pre_(((self.getEndTime)().EQ)(aPeriod.getEndTime)())))","type compatibility obligation:(forall aPeriod:Term \u0026 (((self.getStartTime)().EQ)((aPeriod.getStartTime)()) \u003d\u003e is_((aPeriod.getEndTime)(), Time)))","legal function application obligation:(forall s:seq of (char) \u0026 pre_(String`AsIntegerAux(s)0))","legal function application obligation:(forall s:seq of (char), sum:int \u0026 ((not (s \u003d [])) \u003d\u003e pre_(AsIntegerAux((tl s))((10 * sum) + Character`asDigit((hd s))))))","non-empty sequence obligation:(forall s:seq of (char), sum:int \u0026 ((not (s \u003d [])) \u003d\u003e (s \u003c\u003e [])))","type compatibility obligation:(forall s:seq of (char), sum:int \u0026 ((not (s \u003d [])) \u003d\u003e is_(Character`asDigit((hd s)), real)))","non-empty sequence obligation:(forall s:seq of (char), sum:int \u0026 ((not (s \u003d [])) \u003d\u003e (s \u003c\u003e [])))","legal function application obligation:(forall f:(char -\u003e bool), s:seq of (char) \u0026 (forall i in set (inds s) \u0026 pre_(fs(i))))","legal sequence application obligation:(forall f:(char -\u003e bool), s:seq of (char) \u0026 (forall i in set (inds s) \u0026 (i in set (inds s))))","legal function application obligation:(forall s:seq of (char) \u0026 pre_(isSomeString(Character`isDigit)s))","legal function application obligation:(forall s:seq of (char) \u0026 pre_(isSomeString(Character`isLetter)s))","legal function application obligation:(forall s:seq of (char) \u0026 pre_(isSomeString(Character`isLetterOrDigit)s))","legal function application obligation:(forall s:[seq of (char)] \u0026 pre_(isSomeString((lambda [c:char] \u0026 ((c \u003d \u0027 \u0027) or (c \u003d \u0027\t\u0027))))s))","type compatibility obligation:(forall s:[seq of (char)] \u0026 is_(s, seq of (char)))","legal function application obligation:(forall s1:seq of (char), s2:seq of (char) \u0026 pre_(String`LT2(s1)s2))","cases exhaustive obligation:(forall s1:seq of (char), s2:seq of (char) \u0026 ((((mk_(s1, s2) \u003d mk_([], [])) or (exists mk_([], -):(seq of (char) * seq of (char)) \u0026 (mk_(s1, s2) \u003d mk_([], any1)))) or (exists mk_(- ^ -, []):(seq of (char) * seq of (char)) \u0026 (mk_(s1, s2) \u003d mk_((any1 ^ any1), [])))) or (exists mk_([head1] ^ tails1, [head2] ^ tails2):(seq of (char) * seq of (char)) \u0026 (mk_(s1, s2) \u003d mk_(([head1] ^ tails1), ([head2] ^ tails2))))))","legal function application obligation:(forall s1:seq of (char), s2:seq of (char) \u0026 pre_(String`LE2(s1)s2))","legal function application obligation:(forall s1:seq of (char), s2:seq of (char) \u0026 pre_(String`LT2(s1)s2))","legal function application obligation:(forall s1:seq of (char), s2:seq of (char) \u0026 pre_(String`GT2(s1)s2))","legal function application obligation:(forall s1:seq of (char), s2:seq of (char) \u0026 pre_(String`GE2(s1)s2))","legal function application obligation:(forall s1:seq of (char), s2:seq of (char) \u0026 pre_(String`LT2(s1)s2))","legal function application obligation:(forall c:char, aStr:seq of (char) \u0026 pre_((Sequence`Index)[char](c)aStr))","legal function application obligation:(forall aStr:seq of (char), c:char \u0026 pre_((Sequence`IndexAll2)[char](c)aStr))","legal function application obligation:(forall c:char, aStr:seq of (char) \u0026 pre_((Sequence`IndexAll2)[char](c)aStr))","legal sequence application obligation:(forall aStr:seq of (char), aTargetStr:seq of (char) \u0026 ((aTargetStr \u003c\u003e \"\") \u003d\u003e (1 in set (inds aTargetStr))))","legal function application obligation:(forall aStr:seq of (char), aTargetStr:seq of (char) \u0026 ((aTargetStr \u003c\u003e \"\") \u003d\u003e let indexSet:set of (int) \u003d indexAll(aStr, aTargetStr(1)) in (forall i in set indexSet \u0026 pre_(SubStr(i)((len aTargetStr))aStr))))","type compatibility obligation:(forall aStr:seq of (char), aTargetStr:seq of (char) \u0026 ((aTargetStr \u003c\u003e \"\") \u003d\u003e let indexSet:set of (int) \u003d indexAll(aStr, aTargetStr(1)) in (forall i in set indexSet \u0026 is_(aStr, seq1 of (char)))))","legal function application obligation:(forall aStr:seq of (char), aTargetStr:seq of (char) \u0026 ((aTargetStr \u003c\u003e \"\") \u003d\u003e let indexSet:set of (int) \u003d indexAll(aStr, aTargetStr(1)) in (forall i in set indexSet \u0026 pre_(SubStr(i)(len aTargetStr)))))","type compatibility obligation:(forall aStr:seq of (char), aTargetStr:seq of (char) \u0026 ((aTargetStr \u003c\u003e \"\") \u003d\u003e let indexSet:set of (int) \u003d indexAll(aStr, aTargetStr(1)) in (forall i in set indexSet \u0026 (i \u003e\u003d 0))))","legal function application obligation:(forall s:seq of (char), aDelimitterSet:set of (char) \u0026 pre_((TakeWhile)[char]((lambda [c:char] \u0026 (c not in set aDelimitterSet)))s))","legal function application obligation:(forall s:seq of (char), aDelimitterSet:set of (char) \u0026 pre_((DropWhile)[char]((lambda [c:char] \u0026 (c not in set aDelimitterSet)))s))","legal function application obligation:(forall s:seq of (char) \u0026 pre_(getLinesAux(s)[]))","non-empty sequence obligation:(forall s:seq of (char), line:seq of (seq of (char)) \u0026 ((not (s \u003d [])) \u003d\u003e ((wTailStringCandidate \u003c\u003e []) \u003d\u003e (wTailStringCandidate \u003c\u003e []))))","non-empty sequence obligation:(forall s:seq of (char), line:seq of (seq of (char)) \u0026 ((not (s \u003d [])) \u003d\u003e (((wTailStringCandidate \u003c\u003e []) and ((hd wTailStringCandidate) \u003d \u0027\n\u0027)) \u003d\u003e (wTailStringCandidate \u003c\u003e []))))","legal function application obligation:(forall s:seq of (char), line:seq of (seq of (char)) \u0026 ((not (s \u003d [])) \u003d\u003e let wDelimitterSet:set of (char) \u003d {\u0027\n\u0027}, wHeadLine:seq of (char) \u003d GetToken(s, wDelimitterSet), wTailStringCandidate:seq of (char) \u003d DropToken(s, wDelimitterSet), wTailString:seq of (char) \u003d (if ((wTailStringCandidate \u003c\u003e []) and ((hd wTailStringCandidate) \u003d \u0027\n\u0027))\nthen (tl wTailStringCandidate)\nelse wTailStringCandidate) in pre_(getLinesAux(wTailString)(line ^ [wHeadLine]))))","legal sequence application obligation:(forall aStr:seq of (char), c:char \u0026 (i in set (inds aStr)))","legal sequence application obligation:(forall aStr:seq of (char), fromPos:nat, length:nat, fillChar:char \u0026 (((fromPos \u003e 0) and (length \u003e\u003d 0)) \u003d\u003e (i in set (inds aStr))))","legal function application obligation:pre_((i.asString)1234567890)","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e pre_((i.asString)-1234567890))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e pre_((i.asStringZ)(\"zzz9\")9900)))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e pre_((i.asStringZ)\"zzz9\")))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e pre_((i.asStringZ)(\"9\")0))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e pre_((i.asStringZ)\"9\"))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e pre_((i.asStringZ)(\"z\")0)))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e pre_((i.asStringZ)\"z\")))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e pre_((i.asStringZ)(\"z\")9))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e pre_((i.asStringZ)\"z\"))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e pre_((i.asStringZ)(\"zzz9\")9)))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e pre_((i.asStringZ)\"zzz9\")))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e pre_((i.asStringZ)(\"0009\")9))))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e pre_((i.asStringZ)\"0009\"))))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e (((i.asStringZ)(\"0009\")(9) \u003d \"0009\") \u003d\u003e pre_((i.asStringZ)(\"-0009\")9)))))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e (((i.asStringZ)(\"0009\")(9) \u003d \"0009\") \u003d\u003e pre_((i.asStringZ)\"-0009\")))))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e (((i.asStringZ)(\"0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-0009\")(9) \u003d \"0009\") \u003d\u003e pre_((i.asStringZ)(\"-zzz9\")-9999))))))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e (((i.asStringZ)(\"0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-0009\")(9) \u003d \"0009\") \u003d\u003e pre_((i.asStringZ)\"-zzz9\"))))))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e (((i.asStringZ)(\"0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9999) \u003d \"-9999\") \u003d\u003e pre_((i.asStringZ)(\"-zzz9\")-9)))))))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e (((i.asStringZ)(\"0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9999) \u003d \"-9999\") \u003d\u003e pre_((i.asStringZ)\"-zzz9\")))))))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e (((i.asStringZ)(\"0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9999) \u003d \"-9999\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9) \u003d \"- 9\") \u003d\u003e pre_((i.asStringZ)(\"zzz9\")-9999))))))))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e (((i.asStringZ)(\"0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9999) \u003d \"-9999\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9) \u003d \"- 9\") \u003d\u003e pre_((i.asStringZ)\"zzz9\"))))))))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e (((i.asStringZ)(\"0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9999) \u003d \"-9999\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9) \u003d \"- 9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9999) \u003d \"9999\") \u003d\u003e pre_((i.asStringZ)(\"zzz9\")-9)))))))))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e (((i.asStringZ)(\"0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9999) \u003d \"-9999\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9) \u003d \"- 9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9999) \u003d \"9999\") \u003d\u003e pre_((i.asStringZ)\"zzz9\")))))))))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e (((i.asStringZ)(\"0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9999) \u003d \"-9999\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9) \u003d \"- 9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9999) \u003d \"9999\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9) \u003d \" 9\") \u003d\u003e pre_((i.asString)0))))))))))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e (((i.asStringZ)(\"0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9999) \u003d \"-9999\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9) \u003d \"- 9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9999) \u003d \"9999\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9) \u003d \" 9\") \u003d\u003e (((i.asString)(0) \u003d \"0\") \u003d\u003e pre_((i.asChar)0)))))))))))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e (((i.asStringZ)(\"0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9999) \u003d \"-9999\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9) \u003d \"- 9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9999) \u003d \"9999\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9) \u003d \" 9\") \u003d\u003e (((i.asString)(0) \u003d \"0\") \u003d\u003e (((i.asChar)(0) \u003d \"0\") \u003d\u003e pre_((i.asChar)1))))))))))))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e (((i.asStringZ)(\"0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9999) \u003d \"-9999\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9) \u003d \"- 9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9999) \u003d \"9999\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9) \u003d \" 9\") \u003d\u003e (((i.asString)(0) \u003d \"0\") \u003d\u003e (((i.asChar)(0) \u003d \"0\") \u003d\u003e (((i.asChar)(1) \u003d \"1\") \u003d\u003e pre_((i.asChar)2)))))))))))))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e (((i.asStringZ)(\"0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9999) \u003d \"-9999\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9) \u003d \"- 9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9999) \u003d \"9999\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9) \u003d \" 9\") \u003d\u003e (((i.asString)(0) \u003d \"0\") \u003d\u003e (((i.asChar)(0) \u003d \"0\") \u003d\u003e (((i.asChar)(1) \u003d \"1\") \u003d\u003e (((i.asChar)(2) \u003d \"2\") \u003d\u003e pre_((i.asChar)3))))))))))))))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e (((i.asStringZ)(\"0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9999) \u003d \"-9999\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9) \u003d \"- 9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9999) \u003d \"9999\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9) \u003d \" 9\") \u003d\u003e (((i.asString)(0) \u003d \"0\") \u003d\u003e (((i.asChar)(0) \u003d \"0\") \u003d\u003e (((i.asChar)(1) \u003d \"1\") \u003d\u003e (((i.asChar)(2) \u003d \"2\") \u003d\u003e (((i.asChar)(3) \u003d \"3\") \u003d\u003e pre_((i.asChar)4)))))))))))))))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e (((i.asStringZ)(\"0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9999) \u003d \"-9999\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9) \u003d \"- 9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9999) \u003d \"9999\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9) \u003d \" 9\") \u003d\u003e (((i.asString)(0) \u003d \"0\") \u003d\u003e (((i.asChar)(0) \u003d \"0\") \u003d\u003e (((i.asChar)(1) \u003d \"1\") \u003d\u003e (((i.asChar)(2) \u003d \"2\") \u003d\u003e (((i.asChar)(3) \u003d \"3\") \u003d\u003e (((i.asChar)(4) \u003d \"4\") \u003d\u003e pre_((i.asChar)5))))))))))))))))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e (((i.asStringZ)(\"0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9999) \u003d \"-9999\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9) \u003d \"- 9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9999) \u003d \"9999\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9) \u003d \" 9\") \u003d\u003e (((i.asString)(0) \u003d \"0\") \u003d\u003e (((i.asChar)(0) \u003d \"0\") \u003d\u003e (((i.asChar)(1) \u003d \"1\") \u003d\u003e (((i.asChar)(2) \u003d \"2\") \u003d\u003e (((i.asChar)(3) \u003d \"3\") \u003d\u003e (((i.asChar)(4) \u003d \"4\") \u003d\u003e (((i.asChar)(5) \u003d \"5\") \u003d\u003e pre_((i.asChar)6)))))))))))))))))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e (((i.asStringZ)(\"0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9999) \u003d \"-9999\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9) \u003d \"- 9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9999) \u003d \"9999\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9) \u003d \" 9\") \u003d\u003e (((i.asString)(0) \u003d \"0\") \u003d\u003e (((i.asChar)(0) \u003d \"0\") \u003d\u003e (((i.asChar)(1) \u003d \"1\") \u003d\u003e (((i.asChar)(2) \u003d \"2\") \u003d\u003e (((i.asChar)(3) \u003d \"3\") \u003d\u003e (((i.asChar)(4) \u003d \"4\") \u003d\u003e (((i.asChar)(5) \u003d \"5\") \u003d\u003e (((i.asChar)(6) \u003d \"6\") \u003d\u003e pre_((i.asChar)7))))))))))))))))))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e (((i.asStringZ)(\"0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9999) \u003d \"-9999\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9) \u003d \"- 9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9999) \u003d \"9999\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9) \u003d \" 9\") \u003d\u003e (((i.asString)(0) \u003d \"0\") \u003d\u003e (((i.asChar)(0) \u003d \"0\") \u003d\u003e (((i.asChar)(1) \u003d \"1\") \u003d\u003e (((i.asChar)(2) \u003d \"2\") \u003d\u003e (((i.asChar)(3) \u003d \"3\") \u003d\u003e (((i.asChar)(4) \u003d \"4\") \u003d\u003e (((i.asChar)(5) \u003d \"5\") \u003d\u003e (((i.asChar)(6) \u003d \"6\") \u003d\u003e (((i.asChar)(7) \u003d \"7\") \u003d\u003e pre_((i.asChar)8)))))))))))))))))))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e (((i.asStringZ)(\"0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9999) \u003d \"-9999\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9) \u003d \"- 9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9999) \u003d \"9999\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9) \u003d \" 9\") \u003d\u003e (((i.asString)(0) \u003d \"0\") \u003d\u003e (((i.asChar)(0) \u003d \"0\") \u003d\u003e (((i.asChar)(1) \u003d \"1\") \u003d\u003e (((i.asChar)(2) \u003d \"2\") \u003d\u003e (((i.asChar)(3) \u003d \"3\") \u003d\u003e (((i.asChar)(4) \u003d \"4\") \u003d\u003e (((i.asChar)(5) \u003d \"5\") \u003d\u003e (((i.asChar)(6) \u003d \"6\") \u003d\u003e (((i.asChar)(7) \u003d \"7\") \u003d\u003e (((i.asChar)(8) \u003d \"8\") \u003d\u003e pre_((i.asChar)9))))))))))))))))))))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e (((i.asStringZ)(\"0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9999) \u003d \"-9999\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9) \u003d \"- 9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9999) \u003d \"9999\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9) \u003d \" 9\") \u003d\u003e (((i.asString)(0) \u003d \"0\") \u003d\u003e (((i.asChar)(0) \u003d \"0\") \u003d\u003e (((i.asChar)(1) \u003d \"1\") \u003d\u003e (((i.asChar)(2) \u003d \"2\") \u003d\u003e (((i.asChar)(3) \u003d \"3\") \u003d\u003e (((i.asChar)(4) \u003d \"4\") \u003d\u003e (((i.asChar)(5) \u003d \"5\") \u003d\u003e (((i.asChar)(6) \u003d \"6\") \u003d\u003e (((i.asChar)(7) \u003d \"7\") \u003d\u003e (((i.asChar)(8) \u003d \"8\") \u003d\u003e (((i.asChar)(9) \u003d \"9\") \u003d\u003e pre_((i.asChar)10)))))))))))))))))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((Sequence`fmap)[nat, nat](gcd)[36, 48, 16])","legal function application obligation:(((Sequence`fmap)[nat, nat](gcd)([36, 48, 16]) \u003d [12, 24, 8]) \u003d\u003e pre_((Sequence`fmap)[nat, nat](lcm)[3, 4, 5]))","type compatibility obligation:is_(RESULT, ())","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((Set`Combinations)[int](2){1, 2, 3})","legal function application obligation:(((Set`Combinations)[int](2)({1, 2, 3}) \u003d {{1, 2}, {1, 3}, {2, 3}}) \u003d\u003e pre_((Set`Combinations)[int](2){1, 2, 3, 4}))","legal function application obligation:(((Set`Combinations)[int](2)({1, 2, 3}) \u003d {{1, 2}, {1, 3}, {2, 3}}) \u003d\u003e (((Set`Combinations)[int](2)({1, 2, 3, 4}) \u003d {{1, 2}, {1, 3}, {1, 4}, {2, 3}, {2, 4}, {3, 4}}) \u003d\u003e pre_((Set`fmap)[set of (int), set of (set of (int))]((Set`Combinations)[int](2)){{1, 2, 3}, {1, 2, 3, 4}})))","legal function application obligation:(((Set`Combinations)[int](2)({1, 2, 3}) \u003d {{1, 2}, {1, 3}, {2, 3}}) \u003d\u003e (((Set`Combinations)[int](2)({1, 2, 3, 4}) \u003d {{1, 2}, {1, 3}, {1, 4}, {2, 3}, {2, 4}, {3, 4}}) \u003d\u003e (((Set`fmap)[set of (int), set of (set of (int))]((Set`Combinations)[int](2))({{1, 2, 3}, {1, 2, 3, 4}}) \u003d {{{1, 2}, {1, 3}, {2, 3}}, {{1, 2}, {1, 3}, {1, 4}, {2, 3}, {2, 4}, {3, 4}}}) \u003d\u003e pre_((Set`Combinations)[int](3){1, 2, 3, 4}))))","legal function application obligation:(((Set`Combinations)[int](2)({1, 2, 3}) \u003d {{1, 2}, {1, 3}, {2, 3}}) \u003d\u003e (((Set`Combinations)[int](2)({1, 2, 3, 4}) \u003d {{1, 2}, {1, 3}, {1, 4}, {2, 3}, {2, 4}, {3, 4}}) \u003d\u003e (((Set`fmap)[set of (int), set of (set of (int))]((Set`Combinations)[int](2))({{1, 2, 3}, {1, 2, 3, 4}}) \u003d {{{1, 2}, {1, 3}, {2, 3}}, {{1, 2}, {1, 3}, {1, 4}, {2, 3}, {2, 4}, {3, 4}}}) \u003d\u003e (((Set`Combinations)[int](3)({1, 2, 3, 4}) \u003d {{1, 2, 3}, {1, 2, 4}, {1, 3, 4}, {2, 3, 4}}) \u003d\u003e pre_((Set`Combinations)[seq of (char)](2){\"Sahara\", \"Sato\", \"Sakoh\", \"Yatsu\", \"Nishikawa\"})))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((Set`fmap)[int, int]((lambda [x:int] \u0026 (x mod 3))){1, 2, 3, 4, 5})","legal function application obligation:(((Set`fmap)[int, int]((lambda [x:int] \u0026 (x mod 3)))({1, 2, 3, 4, 5}) \u003d {0, 1, 2}) \u003d\u003e pre_((Set`fmap)[seq of (char), seq of (char)]((Sequence`take)[char](2)){\"Shin Sahara\", \"Hiroshi Sakoh\"}))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_Sum({1, ... ,10})","legal function application obligation:(((Set`Sum)[int]({1, ... ,10}) \u003d 55) \u003d\u003e pre_Sum({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}))","legal function application obligation:(((Set`Sum)[int]({1, ... ,10}) \u003d 55) \u003d\u003e (((Set`Sum)[int]({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}) \u003d 55) \u003d\u003e pre_Sum({0.1, 0.2, 0.3})))","legal function application obligation:(((Set`Sum)[int]({1, ... ,10}) \u003d 55) \u003d\u003e (((Set`Sum)[int]({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}) \u003d 55) \u003d\u003e (((abs ((Set`Sum)[real]({0.1, 0.2, 0.3}) - 0.6)) \u003c\u003d 1.0E-5) \u003d\u003e pre_Sum({1, 2, 3, 3}))))","type compatibility obligation:is_(RESULT, ())","type invariant satisfiable obligation:(exists -:Identifier \u0026 (forall s1, s2:seq of (char), id1, id2:Identifier \u0026 ((id1 \u003c\u003e id2) \u003d\u003e (s1 \u003c\u003e s2))))","type invariant satisfiable obligation:(exists p:Percent \u0026 ((0 \u003c\u003d p) and (p \u003c\u003d 100)))","legal function application obligation:(forall am:real \u0026 pre_((new Real().isNDigitsAfterTheDecimalPoint)am, 2))","type invariant satisfiable obligation:(exists am:AmountOfMoney2 \u0026 (new Real().isNDigitsAfterTheDecimalPoint)(am, 2))","legal function application obligation:pre_((Product`Curry)[seq of (char), seq of (char), bool](lt)(\"abc\")\"abcd\")","legal function application obligation:pre_((Product`Curry)[seq of (char), seq of (char), bool](lt)\"abc\")","legal function application obligation:((Product`Curry)[seq of (char), seq of (char), bool](lt)(\"abc\")(\"abcd\") \u003d\u003e pre_((Product`Curry)[seq of (char), seq of (char), bool](lt)(\"abcde\")\"abcd\"))","legal function application obligation:((Product`Curry)[seq of (char), seq of (char), bool](lt)(\"abc\")(\"abcd\") \u003d\u003e pre_((Product`Curry)[seq of (char), seq of (char), bool](lt)\"abcde\"))","legal function application obligation:((Product`Curry)[seq of (char), seq of (char), bool](lt)(\"abc\")(\"abcd\") \u003d\u003e (((Product`Curry)[seq of (char), seq of (char), bool](lt)(\"abcde\")(\"abcd\") \u003d false) \u003d\u003e pre_((Product`Curry)[int, int, bool](lt2)(3)4)))","legal function application obligation:((Product`Curry)[seq of (char), seq of (char), bool](lt)(\"abc\")(\"abcd\") \u003d\u003e (((Product`Curry)[seq of (char), seq of (char), bool](lt)(\"abcde\")(\"abcd\") \u003d false) \u003d\u003e pre_((Product`Curry)[int, int, bool](lt2)3)))","legal function application obligation:((Product`Curry)[seq of (char), seq of (char), bool](lt)(\"abc\")(\"abcd\") \u003d\u003e (((Product`Curry)[seq of (char), seq of (char), bool](lt)(\"abcde\")(\"abcd\") \u003d false) \u003d\u003e ((Product`Curry)[int, int, bool](lt2)(3)(4) \u003d\u003e pre_((Product`Uncurry)[seq of (char), seq of (char), bool](String`LT2)\"abc\", \"abcd\"))))","legal function application obligation:((Product`Curry)[seq of (char), seq of (char), bool](lt)(\"abc\")(\"abcd\") \u003d\u003e (((Product`Curry)[seq of (char), seq of (char), bool](lt)(\"abcde\")(\"abcd\") \u003d false) \u003d\u003e ((Product`Curry)[int, int, bool](lt2)(3)(4) \u003d\u003e ((Product`Uncurry)[seq of (char), seq of (char), bool](String`LT2)(\"abc\", \"abcd\") \u003d\u003e pre_((Product`Uncurry)[seq of (char), seq of (char), bool](String`LT2)\"abcde\", \"abcd\")))))","legal function application obligation:((Product`Curry)[seq of (char), seq of (char), bool](lt)(\"abc\")(\"abcd\") \u003d\u003e (((Product`Curry)[seq of (char), seq of (char), bool](lt)(\"abcde\")(\"abcd\") \u003d false) \u003d\u003e ((Product`Curry)[int, int, bool](lt2)(3)(4) \u003d\u003e ((Product`Uncurry)[seq of (char), seq of (char), bool](String`LT2)(\"abc\", \"abcd\") \u003d\u003e (((Product`Uncurry)[seq of (char), seq of (char), bool](String`LT2)(\"abcde\", \"abcd\") \u003d false) \u003d\u003e pre_((Product`Uncurry)[seq of (char), seq of (char), bool](String`LE2)\"3\", \"4\"))))))","type compatibility obligation:is_(RESULT, ())","enumeration map injectivity obligation:(forall m1, m2 in set {{1 |-\u003e \"Kei Sato\"}, {19 |-\u003e \"Shin Sahara\"}, {20 |-\u003e \"Hiroshi Sakoh\"}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","enumeration map injectivity obligation:(forall m1, m2 in set {{\"Kei Sato\" |-\u003e 1}, {\"Shin Sahara\" |-\u003e 19}, {\"Hiroshi Sakoh\" |-\u003e 20}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","legal function application obligation:pre_(get1(m1)19)","legal function application obligation:pre_(get1m1)","legal function application obligation:((get1(m1)(19) \u003d \"Shin Sahara\") \u003d\u003e pre_(get1(m1)2))","legal function application obligation:((get1(m1)(19) \u003d \"Shin Sahara\") \u003d\u003e pre_(get1m1))","legal function application obligation:((get1(m1)(19) \u003d \"Shin Sahara\") \u003d\u003e ((get1(m1)(2) \u003d nil) \u003d\u003e pre_(get2(m2)\"Shin Sahara\")))","legal function application obligation:((get1(m1)(19) \u003d \"Shin Sahara\") \u003d\u003e ((get1(m1)(2) \u003d nil) \u003d\u003e pre_(get2m2)))","legal function application obligation:((get1(m1)(19) \u003d \"Shin Sahara\") \u003d\u003e ((get1(m1)(2) \u003d nil) \u003d\u003e ((get2(m2)(\"Shin Sahara\") \u003d 19) \u003d\u003e pre_(get2(m2)\"Worst Prime Minister Koizumi\"))))","legal function application obligation:((get1(m1)(19) \u003d \"Shin Sahara\") \u003d\u003e ((get1(m1)(2) \u003d nil) \u003d\u003e ((get2(m2)(\"Shin Sahara\") \u003d 19) \u003d\u003e pre_(get2m2))))","type compatibility obligation:is_(RESULT, ())","enumeration map injectivity obligation:(forall m1, m2 in set {{1 |-\u003e \"Kei Sato\"}, {19 |-\u003e \"Shin Sahara\"}, {20 |-\u003e \"Hiroshi Sakoh\"}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","enumeration map injectivity obligation:(forall m1, m2 in set {{\"Kei Sato\" |-\u003e 1}, {\"Shin Sahara\" |-\u003e 19}, {\"Hiroshi Sakoh\" |-\u003e 20}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","legal function application obligation:pre_(c1(m1)\"Kei Sato\")","legal function application obligation:pre_(c1m1)","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e pre_(c1(m1)\"Shin Sahara\"))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e pre_(c1m1))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e pre_(c1(m1)\"Hiroshi Sakoh\")))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e pre_(c1m1)))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e pre_(c1(m1)\"Worst Prime Minister Koizumi\"))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e pre_(c1m1))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e pre_(k1(m1)1)))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e pre_(k1m1)))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e (k1(m1)(1) \u003d\u003e pre_(k1(m1)19))))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e (k1(m1)(1) \u003d\u003e pre_(k1m1))))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e (k1(m1)(1) \u003d\u003e (k1(m1)(19) \u003d\u003e pre_(k1(m1)20)))))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e (k1(m1)(1) \u003d\u003e (k1(m1)(19) \u003d\u003e pre_(k1m1)))))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e (k1(m1)(1) \u003d\u003e (k1(m1)(19) \u003d\u003e (k1(m1)(20) \u003d\u003e pre_(k1(m1)99))))))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e (k1(m1)(1) \u003d\u003e (k1(m1)(19) \u003d\u003e (k1(m1)(20) \u003d\u003e pre_(k1m1))))))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e (k1(m1)(1) \u003d\u003e (k1(m1)(19) \u003d\u003e (k1(m1)(20) \u003d\u003e ((not k1(m1)(99)) \u003d\u003e pre_(c2(m2)1)))))))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e (k1(m1)(1) \u003d\u003e (k1(m1)(19) \u003d\u003e (k1(m1)(20) \u003d\u003e ((not k1(m1)(99)) \u003d\u003e pre_(c2m2)))))))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e (k1(m1)(1) \u003d\u003e (k1(m1)(19) \u003d\u003e (k1(m1)(20) \u003d\u003e ((not k1(m1)(99)) \u003d\u003e (c2(m2)(1) \u003d\u003e pre_(c2(m2)19))))))))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e (k1(m1)(1) \u003d\u003e (k1(m1)(19) \u003d\u003e (k1(m1)(20) \u003d\u003e ((not k1(m1)(99)) \u003d\u003e (c2(m2)(1) \u003d\u003e pre_(c2m2))))))))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e (k1(m1)(1) \u003d\u003e (k1(m1)(19) \u003d\u003e (k1(m1)(20) \u003d\u003e ((not k1(m1)(99)) \u003d\u003e (c2(m2)(1) \u003d\u003e (c2(m2)(19) \u003d\u003e pre_(c2(m2)20)))))))))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e (k1(m1)(1) \u003d\u003e (k1(m1)(19) \u003d\u003e (k1(m1)(20) \u003d\u003e ((not k1(m1)(99)) \u003d\u003e (c2(m2)(1) \u003d\u003e (c2(m2)(19) \u003d\u003e pre_(c2m2)))))))))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e (k1(m1)(1) \u003d\u003e (k1(m1)(19) \u003d\u003e (k1(m1)(20) \u003d\u003e ((not k1(m1)(99)) \u003d\u003e (c2(m2)(1) \u003d\u003e (c2(m2)(19) \u003d\u003e (c2(m2)(20) \u003d\u003e pre_(c2(m2)30))))))))))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e (k1(m1)(1) \u003d\u003e (k1(m1)(19) \u003d\u003e (k1(m1)(20) \u003d\u003e ((not k1(m1)(99)) \u003d\u003e (c2(m2)(1) \u003d\u003e (c2(m2)(19) \u003d\u003e (c2(m2)(20) \u003d\u003e pre_(c2m2))))))))))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e (k1(m1)(1) \u003d\u003e (k1(m1)(19) \u003d\u003e (k1(m1)(20) \u003d\u003e ((not k1(m1)(99)) \u003d\u003e (c2(m2)(1) \u003d\u003e (c2(m2)(19) \u003d\u003e (c2(m2)(20) \u003d\u003e ((c2(m2)(30) \u003d false) \u003d\u003e pre_(k2(m2)\"Kei Sato\")))))))))))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e (k1(m1)(1) \u003d\u003e (k1(m1)(19) \u003d\u003e (k1(m1)(20) \u003d\u003e ((not k1(m1)(99)) \u003d\u003e (c2(m2)(1) \u003d\u003e (c2(m2)(19) \u003d\u003e (c2(m2)(20) \u003d\u003e ((c2(m2)(30) \u003d false) \u003d\u003e pre_(k2m2)))))))))))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e (k1(m1)(1) \u003d\u003e (k1(m1)(19) \u003d\u003e (k1(m1)(20) \u003d\u003e ((not k1(m1)(99)) \u003d\u003e (c2(m2)(1) \u003d\u003e (c2(m2)(19) \u003d\u003e (c2(m2)(20) \u003d\u003e ((c2(m2)(30) \u003d false) \u003d\u003e (k2(m2)(\"Kei Sato\") \u003d\u003e pre_(k2(m2)\"Shin Sahara\"))))))))))))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e (k1(m1)(1) \u003d\u003e (k1(m1)(19) \u003d\u003e (k1(m1)(20) \u003d\u003e ((not k1(m1)(99)) \u003d\u003e (c2(m2)(1) \u003d\u003e (c2(m2)(19) \u003d\u003e (c2(m2)(20) \u003d\u003e ((c2(m2)(30) \u003d false) \u003d\u003e (k2(m2)(\"Kei Sato\") \u003d\u003e pre_(k2m2))))))))))))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e (k1(m1)(1) \u003d\u003e (k1(m1)(19) \u003d\u003e (k1(m1)(20) \u003d\u003e ((not k1(m1)(99)) \u003d\u003e (c2(m2)(1) \u003d\u003e (c2(m2)(19) \u003d\u003e (c2(m2)(20) \u003d\u003e ((c2(m2)(30) \u003d false) \u003d\u003e (k2(m2)(\"Kei Sato\") \u003d\u003e (k2(m2)(\"Shin Sahara\") \u003d\u003e pre_(k2(m2)\"Hiroshi Sakoh\")))))))))))))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e (k1(m1)(1) \u003d\u003e (k1(m1)(19) \u003d\u003e (k1(m1)(20) \u003d\u003e ((not k1(m1)(99)) \u003d\u003e (c2(m2)(1) \u003d\u003e (c2(m2)(19) \u003d\u003e (c2(m2)(20) \u003d\u003e ((c2(m2)(30) \u003d false) \u003d\u003e (k2(m2)(\"Kei Sato\") \u003d\u003e (k2(m2)(\"Shin Sahara\") \u003d\u003e pre_(k2m2)))))))))))))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e (k1(m1)(1) \u003d\u003e (k1(m1)(19) \u003d\u003e (k1(m1)(20) \u003d\u003e ((not k1(m1)(99)) \u003d\u003e (c2(m2)(1) \u003d\u003e (c2(m2)(19) \u003d\u003e (c2(m2)(20) \u003d\u003e ((c2(m2)(30) \u003d false) \u003d\u003e (k2(m2)(\"Kei Sato\") \u003d\u003e (k2(m2)(\"Shin Sahara\") \u003d\u003e (k2(m2)(\"Hiroshi Sakoh\") \u003d\u003e pre_(k2(m2)\"Worst Prime Minister Koizumi\"))))))))))))))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e (k1(m1)(1) \u003d\u003e (k1(m1)(19) \u003d\u003e (k1(m1)(20) \u003d\u003e ((not k1(m1)(99)) \u003d\u003e (c2(m2)(1) \u003d\u003e (c2(m2)(19) \u003d\u003e (c2(m2)(20) \u003d\u003e ((c2(m2)(30) \u003d false) \u003d\u003e (k2(m2)(\"Kei Sato\") \u003d\u003e (k2(m2)(\"Shin Sahara\") \u003d\u003e (k2(m2)(\"Hiroshi Sakoh\") \u003d\u003e pre_(k2m2))))))))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:(forall i:int \u0026 let str:(int -\u003e seq1 of (char)) \u003d Integer`asString in ((i \u003e\u003d 10) \u003d\u003e pre_(stri)))","legal function application obligation:(forall i:int \u0026 let str:(int -\u003e seq1 of (char)) \u003d Integer`asString in ((not (i \u003e\u003d 10)) \u003d\u003e pre_(stri)))","legal function application obligation:(forall ADdate:Date \u0026 pre_((ADdate.Year)))","legal function application obligation:(forall ADdate:Date \u0026 (((ADdate.Year)() \u003e\u003d differenceBetweenADandJapaneseCal) \u003d\u003e pre_((ADdate.Year))))","legal function application obligation:(forall ADdate:Date \u0026 (((ADdate.Year)() \u003e\u003d differenceBetweenADandJapaneseCal) \u003d\u003e pre_((ADdate.Month))))","legal function application obligation:(forall ADdate:Date \u0026 (((ADdate.Year)() \u003e\u003d differenceBetweenADandJapaneseCal) \u003d\u003e pre_((ADdate.day))))","legal function application obligation:(forall ADdate:Date \u0026 (((ADdate.Year)() \u003e\u003d differenceBetweenADandJapaneseCal) \u003d\u003e pre_(asStringyearOfJapaneseCal)))","type compatibility obligation:(forall year:int \u0026 ((year \u003e\u003d 2000) \u003d\u003e ((year \u003e\u003d 2007) \u003d\u003e (forall d in set nationalHolidaySet \u0026 (isSunday(d) \u003d\u003e is_(nationalHolidaySet, set of (Date)))))))","type compatibility obligation:(forall year:int \u0026 ((year \u003e\u003d 2000) \u003d\u003e ((year \u003e\u003d 2007) \u003d\u003e (forall d in set nationalHolidaySet \u0026 (isSunday(d) \u003d\u003e is_(d, Date))))))","type compatibility obligation:(forall year:int \u0026 ((year \u003e\u003d 2000) \u003d\u003e ((year \u003e\u003d 2007) \u003d\u003e (forall d in set nationalHolidaySet \u0026 is_(d, Date)))))","type compatibility obligation:(forall year:int \u0026 ((year \u003e\u003d 2000) \u003d\u003e ((not (year \u003e\u003d 2007)) \u003d\u003e (forall d in set nationalHolidaySet \u0026 is_(d, Date)))))","map compatible obligation:(forall year:int \u0026 ((year \u003e\u003d 2000) \u003d\u003e (forall ldom1 in set (dom Year2Holidays), rdom2 in set (dom {year |-\u003e ((nationalHolidaySet union mondayMakeupHolidat) union weekdayBetweenDayOff)}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (Year2Holidays(ldom1) \u003d {year |-\u003e ((nationalHolidaySet union mondayMakeupHolidat) union weekdayBetweenDayOff)}(rdom2))))))","type compatibility obligation:(forall year:int \u0026 ((year \u003e\u003d 2000) \u003d\u003e is_((Year2Holidays munion {year |-\u003e ((nationalHolidaySet union mondayMakeupHolidat) union weekdayBetweenDayOff)}), map (int) to (set of (Date)))))","legal function application obligation:(forall aNationalHolidaySet:set of (Date) \u0026 (forall d in set aNationalHolidaySet \u0026 pre_(((d.minus)(1).Year))))","legal function application obligation:(forall aNationalHolidaySet:set of (Date) \u0026 (forall d in set aNationalHolidaySet \u0026 pre_((d.Year))))","legal function application obligation:(forall aNationalHolidaySet:set of (Date) \u0026 (forall d in set aNationalHolidaySet \u0026 ((((d.minus)(1).Year)() \u003d (d.Year)()) \u003d\u003e pre_(((d.plus)(1).Year)))))","legal function application obligation:(forall aNationalHolidaySet:set of (Date) \u0026 (forall d in set aNationalHolidaySet \u0026 ((((d.minus)(1).Year)() \u003d (d.Year)()) \u003d\u003e pre_((d.Year)))))","non-empty sequence obligation:(forall mk_(aHeads, aTails):(seq of (@T) * seq of (@T)) \u0026 ((not (exists [-] ^ aTailsOfHeads:seq of (@T) \u0026 (([any1] ^ aTailsOfHeads) \u003d aHeads))) \u003d\u003e (([] \u003d aHeads) \u003d\u003e ((not ([] \u003d aTails)) \u003d\u003e ((Sequence`freverse)[@T](aTails) \u003c\u003e [])))))","cases exhaustive obligation:(forall mk_(aHeads, aTails):(seq of (@T) * seq of (@T)) \u0026 ((exists [-] ^ aTailsOfHeads:seq of (@T) \u0026 (aHeads \u003d ([any1] ^ aTailsOfHeads))) or (aHeads \u003d [])))","non-empty sequence obligation:(forall mk_(aHeads, aTails):(seq of (@T) * seq of (@T)) \u0026 ((not (exists [h] ^ -:seq of (@T) \u0026 (([h] ^ any1) \u003d aHeads))) \u003d\u003e (([] \u003d aHeads) \u003d\u003e ((not ([] \u003d aTails)) \u003d\u003e ((Sequence`freverse)[@T](aTails) \u003c\u003e [])))))","cases exhaustive obligation:(forall mk_(aHeads, aTails):(seq of (@T) * seq of (@T)) \u0026 ((exists [h] ^ -:seq of (@T) \u0026 (aHeads \u003d ([h] ^ any1))) or (aHeads \u003d [])))","recursive function obligation:(forall aSeq:seq of (@T), aQueue:(seq of (@T) * seq of (@T)) \u0026 ((not ([] \u003d aSeq)) \u003d\u003e (exists [h] ^ aTailsOfSeq:seq of (@T) \u0026 ((([h] ^ aTailsOfSeq) \u003d aSeq) \u003d\u003e let [h] ^ aTailsOfSeq \u003d aSeq in ((fromListMeasure)[seq of (@T), (seq of (@T) * seq of (@T))](aSeq, aQueue) \u003e (fromListMeasure)[@T](aTailsOfSeq, (enQueue)[@T](h, aQueue)))))))","cases exhaustive obligation:(forall aSeq:seq of (@T), aQueue:(seq of (@T) * seq of (@T)) \u0026 ((aSeq \u003d []) or (exists [h] ^ aTailsOfSeq:seq of (@T) \u0026 (aSeq \u003d ([h] ^ aTailsOfSeq)))))","type compatibility obligation:(forall aaQueue:(seq of (@T) * seq of (@T)) \u0026 ((not (mk_([], []) \u003d aaQueue)) \u003d\u003e (exists aQueue:(seq of (@T) * seq of (@T)) \u0026 ((aQueue \u003d aaQueue) \u003d\u003e let aQueue \u003d aaQueue in is_((deQueue)[@T](aQueue), (seq of (@T) * seq of (@T)))))))","recursive function obligation:(forall aaQueue:(seq of (@T) * seq of (@T)) \u0026 ((not (mk_([], []) \u003d aaQueue)) \u003d\u003e (exists aQueue:(seq of (@T) * seq of (@T)) \u0026 ((aQueue \u003d aaQueue) \u003d\u003e let aQueue \u003d aaQueue in ((toListMeasure)[[(seq of (@T) * seq of (@T))]](aaQueue) \u003e (toListMeasure)[@T]((deQueue)[@T](aQueue)))))))","cases exhaustive obligation:(forall aaQueue:(seq of (@T) * seq of (@T)) \u0026 ((aaQueue \u003d mk_([], [])) or (exists aQueue:(seq of (@T) * seq of (@T)) \u0026 (aaQueue \u003d aQueue))))","legal function application obligation:(forall s:seq of (@T) \u0026 (is_(s, seq of (real)) \u003d\u003e pre_((SumAux)[@T](s)0)))","legal function application obligation:(forall s:seq of (@T), sum:@T \u0026 ((is_(s, seq of (real)) and is_(sum, real)) \u003d\u003e ((not (s \u003d [])) \u003d\u003e pre_((SumAux)[@T]((tl s))(sum + (hd s))))))","non-empty sequence obligation:(forall s:seq of (@T), sum:@T \u0026 ((is_(s, seq of (real)) and is_(sum, real)) \u003d\u003e ((not (s \u003d [])) \u003d\u003e (s \u003c\u003e []))))","non-empty sequence obligation:(forall s:seq of (@T), sum:@T \u0026 ((is_(s, seq of (real)) and is_(sum, real)) \u003d\u003e ((not (s \u003d [])) \u003d\u003e (s \u003c\u003e []))))","legal function application obligation:(forall s:seq of (@T) \u0026 (is_(s, seq of (real)) \u003d\u003e pre_((ProductAux)[@T](s)1)))","legal function application obligation:(forall s:seq of (@T), p:@T \u0026 ((is_(s, seq of (real)) and is_(p, real)) \u003d\u003e (exists [h] ^ tail:seq of (real) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in pre_((ProductAux)[@T](tail)(p * h))))))","cases exhaustive obligation:(forall s:seq of (@T), p:@T \u0026 ((is_(s, seq of (real)) and is_(p, real)) \u003d\u003e ((exists [h] ^ tail:seq of (real) \u0026 (s \u003d ([h] ^ tail))) or (s \u003d []))))","legal function application obligation:(forall s:seq of (@T) \u0026 ((not (s \u003d [])) \u003d\u003e pre_((GetAverageAux)[@T](s)(0)(len s))))","legal function application obligation:(forall s:seq of (@T) \u0026 ((not (s \u003d [])) \u003d\u003e pre_((GetAverageAux)[@T](s)0)))","legal function application obligation:(forall s:seq of (@T), sum:@T, numberOfElem:@T \u0026 ((is_(s, seq of (real)) and (is_(sum, real) and is_(numberOfElem, real))) \u003d\u003e (exists [h] ^ tail:seq of (real) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in pre_((GetAverageAux)[@T](tail)((sum + h))numberOfElem)))))","legal function application obligation:(forall s:seq of (@T), sum:@T, numberOfElem:@T \u0026 ((is_(s, seq of (real)) and (is_(sum, real) and is_(numberOfElem, real))) \u003d\u003e (exists [h] ^ tail:seq of (real) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in pre_((GetAverageAux)[@T](tail)(sum + h))))))","non-zero obligation:(forall s:seq of (@T), sum:@T, numberOfElem:@T \u0026 ((is_(s, seq of (real)) and (is_(sum, real) and is_(numberOfElem, real))) \u003d\u003e ((not (exists [h] ^ tail:seq of (real) \u0026 (([h] ^ tail) \u003d s))) \u003d\u003e (([] \u003d s) \u003d\u003e (numberOfElem \u003c\u003e 0)))))","cases exhaustive obligation:(forall s:seq of (@T), sum:@T, numberOfElem:@T \u0026 ((is_(s, seq of (real)) and (is_(sum, real) and is_(numberOfElem, real))) \u003d\u003e ((exists [h] ^ tail:seq of (real) \u0026 (s \u003d ([h] ^ tail))) or (s \u003d []))))","legal function application obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s:seq of (@T) \u0026 (forall i, j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e pre_(decideOrderFuncs(i), s(j)))))","legal sequence application obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s:seq of (@T) \u0026 (forall i, j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e (i in set (inds s)))))","legal sequence application obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s:seq of (@T) \u0026 (forall i, j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e (j in set (inds s)))))","legal sequence application obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s:seq of (@T) \u0026 (forall i, j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e ((not decideOrderFunc(s(i), s(j))) \u003d\u003e (i in set (inds s))))))","legal sequence application obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s:seq of (@T) \u0026 (forall i, j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e ((not decideOrderFunc(s(i), s(j))) \u003d\u003e (j in set (inds s))))))","legal function application obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s:seq of (@T) \u0026 (forall i, j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e pre_(decideOrderFuncs(j), s(i)))))","legal sequence application obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s:seq of (@T) \u0026 (forall i, j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e (j in set (inds s)))))","legal sequence application obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s:seq of (@T) \u0026 (forall i, j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e (i in set (inds s)))))","legal sequence application obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s:seq of (@T) \u0026 (forall i, j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e ((not decideOrderFunc(s(j), s(i))) \u003d\u003e (i in set (inds s))))))","legal sequence application obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s:seq of (@T) \u0026 (forall i, j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e ((not decideOrderFunc(s(j), s(i))) \u003d\u003e (j in set (inds s))))))","legal function application obligation:(forall s:seq of (@T) \u0026 pre_((isAscendingTotalOrder)[@T]((lambda [x:@T, y:@T] \u0026 (if (is_(x, real) and is_(y, real))\nthen (x \u003c y)\nelse (undefined))))s))","legal function application obligation:(forall s:seq of (@T) \u0026 pre_((isDescendingTotalOrder)[@T]((lambda [x:@T, y:@T] \u0026 (if (is_(x, real) and is_(y, real))\nthen (x \u003c y)\nelse (undefined))))s))","legal function application obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s:seq of (@T) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [h] ^ tail:seq of (@T) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in pre_((sort)[@T](decideOrderFunc)[tail(i) | i in set (inds tail) \u0026 decideOrderFunc(tail(i), h)])))))","legal sequence application obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s:seq of (@T) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [h] ^ tail:seq of (@T) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in (forall i in set (inds tail) \u0026 (decideOrderFunc(tail(i), h) \u003d\u003e (i in set (inds tail))))))))","legal function application obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s:seq of (@T) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [h] ^ tail:seq of (@T) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in (forall i in set (inds tail) \u0026 pre_(decideOrderFunctail(i), h))))))","legal sequence application obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s:seq of (@T) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [h] ^ tail:seq of (@T) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in (forall i in set (inds tail) \u0026 (i in set (inds tail)))))))","legal function application obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s:seq of (@T) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [h] ^ tail:seq of (@T) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in pre_((sort)[@T](decideOrderFunc)[tail(i) | i in set (inds tail) \u0026 (not decideOrderFunc(tail(i), h))])))))","legal sequence application obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s:seq of (@T) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [h] ^ tail:seq of (@T) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in (forall i in set (inds tail) \u0026 ((not decideOrderFunc(tail(i), h)) \u003d\u003e (i in set (inds tail))))))))","legal function application obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s:seq of (@T) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [h] ^ tail:seq of (@T) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in (forall i in set (inds tail) \u0026 pre_(decideOrderFunctail(i), h))))))","legal sequence application obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s:seq of (@T) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [h] ^ tail:seq of (@T) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in (forall i in set (inds tail) \u0026 (i in set (inds tail)))))))","cases exhaustive obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s:seq of (@T) \u0026 ((s \u003d []) or (exists [h] ^ tail:seq of (@T) \u0026 (s \u003d ([h] ^ tail)))))","legal function application obligation:(forall s:seq of (@T) \u0026 pre_((sort)[@T]((lambda [x:@T, y:@T] \u0026 (if (is_(x, real) and is_(y, real))\nthen (x \u003c y)\nelse (undefined))))s))","legal function application obligation:(forall s:seq of (@T) \u0026 pre_((sort)[@T]((lambda [x:@T, y:@T] \u0026 (if (is_(x, real) and is_(y, real))\nthen (x \u003e y)\nelse (undefined))))s))","legal function application obligation:(forall decideOrderFuncSeq:seq of ((@T * @T -\u003e bool)), s1:seq of (@T), s2:seq of (@T) \u0026 ((not (mk_([], []) \u003d mk_(s1, s2))) \u003d\u003e ((not (exists mk_([], -):(seq of (@T) * seq of (@T)) \u0026 (mk_([], any1) \u003d mk_(s1, s2)))) \u003d\u003e ((not (exists mk_(-, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(any1, []) \u003d mk_(s1, s2)))) \u003d\u003e (exists mk_([h1] ^ tail1, [h2] ^ tail2):(seq of (@T) * seq of (@T)) \u0026 ((mk_(([h1] ^ tail1), ([h2] ^ tail2)) \u003d mk_(s1, s2)) \u003d\u003e let mk_([h1] ^ tail1, [h2] ^ tail2) \u003d mk_(s1, s2) in pre_((hd decideOrderFuncSeq)h1, h2)))))))","non-empty sequence obligation:(forall decideOrderFuncSeq:seq of ((@T * @T -\u003e bool)), s1:seq of (@T), s2:seq of (@T) \u0026 ((not (mk_([], []) \u003d mk_(s1, s2))) \u003d\u003e ((not (exists mk_([], -):(seq of (@T) * seq of (@T)) \u0026 (mk_([], any1) \u003d mk_(s1, s2)))) \u003d\u003e ((not (exists mk_(-, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(any1, []) \u003d mk_(s1, s2)))) \u003d\u003e (exists mk_([h1] ^ tail1, [h2] ^ tail2):(seq of (@T) * seq of (@T)) \u0026 ((mk_(([h1] ^ tail1), ([h2] ^ tail2)) \u003d mk_(s1, s2)) \u003d\u003e let mk_([h1] ^ tail1, [h2] ^ tail2) \u003d mk_(s1, s2) in (decideOrderFuncSeq \u003c\u003e [])))))))","legal function application obligation:(forall decideOrderFuncSeq:seq of ((@T * @T -\u003e bool)), s1:seq of (@T), s2:seq of (@T) \u0026 ((not (mk_([], []) \u003d mk_(s1, s2))) \u003d\u003e ((not (exists mk_([], -):(seq of (@T) * seq of (@T)) \u0026 (mk_([], any1) \u003d mk_(s1, s2)))) \u003d\u003e ((not (exists mk_(-, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(any1, []) \u003d mk_(s1, s2)))) \u003d\u003e (exists mk_([h1] ^ tail1, [h2] ^ tail2):(seq of (@T) * seq of (@T)) \u0026 ((mk_(([h1] ^ tail1), ([h2] ^ tail2)) \u003d mk_(s1, s2)) \u003d\u003e let mk_([h1] ^ tail1, [h2] ^ tail2) \u003d mk_(s1, s2) in ((not (hd decideOrderFuncSeq)(h1, h2)) \u003d\u003e ((not (hd decideOrderFuncSeq)(h2, h1)) \u003d\u003e pre_((Sequence`isOrdered)[@T]((tl decideOrderFuncSeq))(tail1)tail2)))))))))","legal function application obligation:(forall decideOrderFuncSeq:seq of ((@T * @T -\u003e bool)), s1:seq of (@T), s2:seq of (@T) \u0026 ((not (mk_([], []) \u003d mk_(s1, s2))) \u003d\u003e ((not (exists mk_([], -):(seq of (@T) * seq of (@T)) \u0026 (mk_([], any1) \u003d mk_(s1, s2)))) \u003d\u003e ((not (exists mk_(-, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(any1, []) \u003d mk_(s1, s2)))) \u003d\u003e (exists mk_([h1] ^ tail1, [h2] ^ tail2):(seq of (@T) * seq of (@T)) \u0026 ((mk_(([h1] ^ tail1), ([h2] ^ tail2)) \u003d mk_(s1, s2)) \u003d\u003e let mk_([h1] ^ tail1, [h2] ^ tail2) \u003d mk_(s1, s2) in ((not (hd decideOrderFuncSeq)(h1, h2)) \u003d\u003e ((not (hd decideOrderFuncSeq)(h2, h1)) \u003d\u003e pre_((Sequence`isOrdered)[@T]((tl decideOrderFuncSeq))tail1)))))))))","non-empty sequence obligation:(forall decideOrderFuncSeq:seq of ((@T * @T -\u003e bool)), s1:seq of (@T), s2:seq of (@T) \u0026 ((not (mk_([], []) \u003d mk_(s1, s2))) \u003d\u003e ((not (exists mk_([], -):(seq of (@T) * seq of (@T)) \u0026 (mk_([], any1) \u003d mk_(s1, s2)))) \u003d\u003e ((not (exists mk_(-, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(any1, []) \u003d mk_(s1, s2)))) \u003d\u003e (exists mk_([h1] ^ tail1, [h2] ^ tail2):(seq of (@T) * seq of (@T)) \u0026 ((mk_(([h1] ^ tail1), ([h2] ^ tail2)) \u003d mk_(s1, s2)) \u003d\u003e let mk_([h1] ^ tail1, [h2] ^ tail2) \u003d mk_(s1, s2) in ((not (hd decideOrderFuncSeq)(h1, h2)) \u003d\u003e ((not (hd decideOrderFuncSeq)(h2, h1)) \u003d\u003e (decideOrderFuncSeq \u003c\u003e [])))))))))","cases exhaustive obligation:(forall decideOrderFuncSeq:seq of ((@T * @T -\u003e bool)), s1:seq of (@T), s2:seq of (@T) \u0026 ((((mk_(s1, s2) \u003d mk_([], [])) or (exists mk_([], -):(seq of (@T) * seq of (@T)) \u0026 (mk_(s1, s2) \u003d mk_([], any1)))) or (exists mk_(-, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(s1, s2) \u003d mk_(any1, [])))) or (exists mk_([h1] ^ tail1, [h2] ^ tail2):(seq of (@T) * seq of (@T)) \u0026 (mk_(s1, s2) \u003d mk_(([h1] ^ tail1), ([h2] ^ tail2))))))","legal function application obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s1:seq of (@T), s2:seq of (@T) \u0026 ((not (exists mk_([], y):(seq of (@T) * seq of (@T)) \u0026 (mk_([], y) \u003d mk_(s1, s2)))) \u003d\u003e ((not (exists mk_(x, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(x, []) \u003d mk_(s1, s2)))) \u003d\u003e (exists mk_([h1] ^ tail1, [h2] ^ tail2):(seq of (@T) * seq of (@T)) \u0026 ((mk_(([h1] ^ tail1), ([h2] ^ tail2)) \u003d mk_(s1, s2)) \u003d\u003e let mk_([h1] ^ tail1, [h2] ^ tail2) \u003d mk_(s1, s2) in pre_(decideOrderFunch1, h2))))))","legal function application obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s1:seq of (@T), s2:seq of (@T) \u0026 ((not (exists mk_([], y):(seq of (@T) * seq of (@T)) \u0026 (mk_([], y) \u003d mk_(s1, s2)))) \u003d\u003e ((not (exists mk_(x, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(x, []) \u003d mk_(s1, s2)))) \u003d\u003e (exists mk_([h1] ^ tail1, [h2] ^ tail2):(seq of (@T) * seq of (@T)) \u0026 ((mk_(([h1] ^ tail1), ([h2] ^ tail2)) \u003d mk_(s1, s2)) \u003d\u003e let mk_([h1] ^ tail1, [h2] ^ tail2) \u003d mk_(s1, s2) in (decideOrderFunc(h1, h2) \u003d\u003e pre_((Sequence`Merge)[@T](decideOrderFunc)(tail1)s2)))))))","legal function application obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s1:seq of (@T), s2:seq of (@T) \u0026 ((not (exists mk_([], y):(seq of (@T) * seq of (@T)) \u0026 (mk_([], y) \u003d mk_(s1, s2)))) \u003d\u003e ((not (exists mk_(x, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(x, []) \u003d mk_(s1, s2)))) \u003d\u003e (exists mk_([h1] ^ tail1, [h2] ^ tail2):(seq of (@T) * seq of (@T)) \u0026 ((mk_(([h1] ^ tail1), ([h2] ^ tail2)) \u003d mk_(s1, s2)) \u003d\u003e let mk_([h1] ^ tail1, [h2] ^ tail2) \u003d mk_(s1, s2) in (decideOrderFunc(h1, h2) \u003d\u003e pre_((Sequence`Merge)[@T](decideOrderFunc)tail1)))))))","legal function application obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s1:seq of (@T), s2:seq of (@T) \u0026 ((not (exists mk_([], y):(seq of (@T) * seq of (@T)) \u0026 (mk_([], y) \u003d mk_(s1, s2)))) \u003d\u003e ((not (exists mk_(x, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(x, []) \u003d mk_(s1, s2)))) \u003d\u003e (exists mk_([h1] ^ tail1, [h2] ^ tail2):(seq of (@T) * seq of (@T)) \u0026 ((mk_(([h1] ^ tail1), ([h2] ^ tail2)) \u003d mk_(s1, s2)) \u003d\u003e let mk_([h1] ^ tail1, [h2] ^ tail2) \u003d mk_(s1, s2) in ((not decideOrderFunc(h1, h2)) \u003d\u003e pre_((Sequence`Merge)[@T](decideOrderFunc)(s1)tail2)))))))","legal function application obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s1:seq of (@T), s2:seq of (@T) \u0026 ((not (exists mk_([], y):(seq of (@T) * seq of (@T)) \u0026 (mk_([], y) \u003d mk_(s1, s2)))) \u003d\u003e ((not (exists mk_(x, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(x, []) \u003d mk_(s1, s2)))) \u003d\u003e (exists mk_([h1] ^ tail1, [h2] ^ tail2):(seq of (@T) * seq of (@T)) \u0026 ((mk_(([h1] ^ tail1), ([h2] ^ tail2)) \u003d mk_(s1, s2)) \u003d\u003e let mk_([h1] ^ tail1, [h2] ^ tail2) \u003d mk_(s1, s2) in ((not decideOrderFunc(h1, h2)) \u003d\u003e pre_((Sequence`Merge)[@T](decideOrderFunc)s1)))))))","cases exhaustive obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s1:seq of (@T), s2:seq of (@T) \u0026 (((exists mk_([], y):(seq of (@T) * seq of (@T)) \u0026 (mk_(s1, s2) \u003d mk_([], y))) or (exists mk_(x, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(s1, s2) \u003d mk_(x, [])))) or (exists mk_([h1] ^ tail1, [h2] ^ tail2):(seq of (@T) * seq of (@T)) \u0026 (mk_(s1, s2) \u003d mk_(([h1] ^ tail1), ([h2] ^ tail2))))))","legal function application obligation:(forall position:nat1, e:@T, s:seq of (@T) \u0026 ((not (exists mk_(1, str):(nat1 * seq of (@T)) \u0026 (mk_(1, str) \u003d mk_(position, s)))) \u003d\u003e ((not (exists mk_(-, []):(nat1 * seq of (@T)) \u0026 (mk_(any1, []) \u003d mk_(position, s)))) \u003d\u003e (exists mk_(pos, [h] ^ tail):(nat1 * seq of (@T)) \u0026 ((mk_(pos, ([h] ^ tail)) \u003d mk_(position, s)) \u003d\u003e let mk_(pos, [h] ^ tail) \u003d mk_(position, s) in pre_((InsertAt)[@T]((pos - 1))(e)tail))))))","legal function application obligation:(forall position:nat1, e:@T, s:seq of (@T) \u0026 ((not (exists mk_(1, str):(nat1 * seq of (@T)) \u0026 (mk_(1, str) \u003d mk_(position, s)))) \u003d\u003e ((not (exists mk_(-, []):(nat1 * seq of (@T)) \u0026 (mk_(any1, []) \u003d mk_(position, s)))) \u003d\u003e (exists mk_(pos, [h] ^ tail):(nat1 * seq of (@T)) \u0026 ((mk_(pos, ([h] ^ tail)) \u003d mk_(position, s)) \u003d\u003e let mk_(pos, [h] ^ tail) \u003d mk_(position, s) in pre_((InsertAt)[@T]((pos - 1))e))))))","type compatibility obligation:(forall position:nat1, e:@T, s:seq of (@T) \u0026 ((not (exists mk_(1, str):(nat1 * seq of (@T)) \u0026 (mk_(1, str) \u003d mk_(position, s)))) \u003d\u003e ((not (exists mk_(-, []):(nat1 * seq of (@T)) \u0026 (mk_(any1, []) \u003d mk_(position, s)))) \u003d\u003e (exists mk_(pos, [h] ^ tail):(nat1 * seq of (@T)) \u0026 ((mk_(pos, ([h] ^ tail)) \u003d mk_(position, s)) \u003d\u003e let mk_(pos, [h] ^ tail) \u003d mk_(position, s) in ((pos - 1) \u003e 0))))))","cases exhaustive obligation:(forall position:nat1, e:@T, s:seq of (@T) \u0026 (((exists mk_(1, str):(nat1 * seq of (@T)) \u0026 (mk_(position, s) \u003d mk_(1, str))) or (exists mk_(-, []):(nat1 * seq of (@T)) \u0026 (mk_(position, s) \u003d mk_(any1, [])))) or (exists mk_(pos, [h] ^ tail):(nat1 * seq of (@T)) \u0026 (mk_(position, s) \u003d mk_(pos, ([h] ^ tail))))))","legal function application obligation:(forall position:nat1, s:seq of (@T) \u0026 ((not (exists mk_(1, [-] ^ tail):(nat1 * seq of (@T)) \u0026 (mk_(1, ([any1] ^ tail)) \u003d mk_(position, s)))) \u003d\u003e (exists mk_(pos, [h] ^ tail):(nat1 * seq of (@T)) \u0026 ((mk_(pos, ([h] ^ tail)) \u003d mk_(position, s)) \u003d\u003e let mk_(pos, [h] ^ tail) \u003d mk_(position, s) in pre_((RemoveAt)[@T]((pos - 1))tail)))))","type compatibility obligation:(forall position:nat1, s:seq of (@T) \u0026 ((not (exists mk_(1, [-] ^ tail):(nat1 * seq of (@T)) \u0026 (mk_(1, ([any1] ^ tail)) \u003d mk_(position, s)))) \u003d\u003e (exists mk_(pos, [h] ^ tail):(nat1 * seq of (@T)) \u0026 ((mk_(pos, ([h] ^ tail)) \u003d mk_(position, s)) \u003d\u003e let mk_(pos, [h] ^ tail) \u003d mk_(position, s) in ((pos - 1) \u003e 0)))))","cases exhaustive obligation:(forall position:nat1, s:seq of (@T) \u0026 (((exists mk_(1, [-] ^ tail):(nat1 * seq of (@T)) \u0026 (mk_(position, s) \u003d mk_(1, ([any1] ^ tail)))) or (exists mk_(pos, [h] ^ tail):(nat1 * seq of (@T)) \u0026 (mk_(position, s) \u003d mk_(pos, ([h] ^ tail))))) or (exists mk_(-, []):(nat1 * seq of (@T)) \u0026 (mk_(position, s) \u003d mk_(any1, [])))))","recursive function obligation:(forall s:seq of (@T) \u0026 (exists [h] ^ tail:seq of (@T) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in ((length_measure)[seq of (@T)](s) \u003e (length_measure)[@T]((filter)[@T]((lambda [x:@T] \u0026 (x \u003c\u003e h)))(tail))))))","legal function application obligation:(forall s:seq of (@T) \u0026 (exists [h] ^ tail:seq of (@T) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in pre_((filter)[@T]((lambda [x:@T] \u0026 (x \u003c\u003e h)))tail))))","cases exhaustive obligation:(forall s:seq of (@T) \u0026 ((exists [h] ^ tail:seq of (@T) \u0026 (s \u003d ([h] ^ tail))) or (s \u003d [])))","legal function application obligation:(forall e:@T, s:seq of (@T) \u0026 (exists [h] ^ tail:seq of (@T) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in ((not (e \u003d h)) \u003d\u003e pre_((RemoveMember)[@T](e)tail)))))","cases exhaustive obligation:(forall e:@T, s:seq of (@T) \u0026 ((exists [h] ^ tail:seq of (@T) \u0026 (s \u003d ([h] ^ tail))) or (s \u003d [])))","legal function application obligation:(forall elemSeq:seq of (@T), s:seq of (@T) \u0026 ((not ([] \u003d elemSeq)) \u003d\u003e (exists [h] ^ tail:seq of (@T) \u0026 ((([h] ^ tail) \u003d elemSeq) \u003d\u003e let [h] ^ tail \u003d elemSeq in pre_((RemoveMembers)[@T](tail)(RemoveMember)[@T](h)(s))))))","legal function application obligation:(forall elemSeq:seq of (@T), s:seq of (@T) \u0026 ((not ([] \u003d elemSeq)) \u003d\u003e (exists [h] ^ tail:seq of (@T) \u0026 ((([h] ^ tail) \u003d elemSeq) \u003d\u003e let [h] ^ tail \u003d elemSeq in pre_((RemoveMember)[@T](h)s)))))","cases exhaustive obligation:(forall elemSeq:seq of (@T), s:seq of (@T) \u0026 ((elemSeq \u003d []) or (exists [h] ^ tail:seq of (@T) \u0026 (elemSeq \u003d ([h] ^ tail)))))","legal function application obligation:(forall position:nat1, e:@T, s:seq of (@T) \u0026 ((not (exists mk_(-, []):(nat1 * seq of (@T)) \u0026 (mk_(any1, []) \u003d mk_(position, s)))) \u003d\u003e ((not (exists mk_(1, [-] ^ tail):(nat1 * seq of (@T)) \u0026 (mk_(1, ([any1] ^ tail)) \u003d mk_(position, s)))) \u003d\u003e (exists mk_(pos, [h] ^ tail):(nat1 * seq of (@T)) \u0026 ((mk_(pos, ([h] ^ tail)) \u003d mk_(position, s)) \u003d\u003e let mk_(pos, [h] ^ tail) \u003d mk_(position, s) in pre_((UpdateAt)[@T]((pos - 1))(e)tail))))))","legal function application obligation:(forall position:nat1, e:@T, s:seq of (@T) \u0026 ((not (exists mk_(-, []):(nat1 * seq of (@T)) \u0026 (mk_(any1, []) \u003d mk_(position, s)))) \u003d\u003e ((not (exists mk_(1, [-] ^ tail):(nat1 * seq of (@T)) \u0026 (mk_(1, ([any1] ^ tail)) \u003d mk_(position, s)))) \u003d\u003e (exists mk_(pos, [h] ^ tail):(nat1 * seq of (@T)) \u0026 ((mk_(pos, ([h] ^ tail)) \u003d mk_(position, s)) \u003d\u003e let mk_(pos, [h] ^ tail) \u003d mk_(position, s) in pre_((UpdateAt)[@T]((pos - 1))e))))))","type compatibility obligation:(forall position:nat1, e:@T, s:seq of (@T) \u0026 ((not (exists mk_(-, []):(nat1 * seq of (@T)) \u0026 (mk_(any1, []) \u003d mk_(position, s)))) \u003d\u003e ((not (exists mk_(1, [-] ^ tail):(nat1 * seq of (@T)) \u0026 (mk_(1, ([any1] ^ tail)) \u003d mk_(position, s)))) \u003d\u003e (exists mk_(pos, [h] ^ tail):(nat1 * seq of (@T)) \u0026 ((mk_(pos, ([h] ^ tail)) \u003d mk_(position, s)) \u003d\u003e let mk_(pos, [h] ^ tail) \u003d mk_(position, s) in ((pos - 1) \u003e 0))))))","cases exhaustive obligation:(forall position:nat1, e:@T, s:seq of (@T) \u0026 (((exists mk_(-, []):(nat1 * seq of (@T)) \u0026 (mk_(position, s) \u003d mk_(any1, []))) or (exists mk_(1, [-] ^ tail):(nat1 * seq of (@T)) \u0026 (mk_(position, s) \u003d mk_(1, ([any1] ^ tail))))) or (exists mk_(pos, [h] ^ tail):(nat1 * seq of (@T)) \u0026 (mk_(position, s) \u003d mk_(pos, ([h] ^ tail))))))","legal function application obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 (exists [h] ^ tail:seq of (@T) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in pre_(fh))))","legal function application obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 (exists [h] ^ tail:seq of (@T) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in (f(h) \u003d\u003e pre_((TakeWhile)[@T](f)tail)))))","cases exhaustive obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 ((exists [h] ^ tail:seq of (@T) \u0026 (s \u003d ([h] ^ tail))) or (s \u003d [])))","legal function application obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 (exists [h] ^ tail:seq of (@T) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in pre_(fh))))","legal function application obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 (exists [h] ^ tail:seq of (@T) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in (f(h) \u003d\u003e pre_((DropWhile)[@T](f)tail)))))","cases exhaustive obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 ((exists [h] ^ tail:seq of (@T) \u0026 (s \u003d ([h] ^ tail))) or (s \u003d [])))","legal function application obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 (exists [h] ^ tail:seq of (@T) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in pre_(fh))))","legal function application obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 (exists [h] ^ tail:seq of (@T) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in (f(h) \u003d\u003e pre_((Span)[@T](f)tail)))))","cases exhaustive obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 ((exists [h] ^ tail:seq of (@T) \u0026 (s \u003d ([h] ^ tail))) or (s \u003d [])))","legal sequence application obligation:(forall s:seq of (@T) \u0026 ((len s) in set (inds s)))","legal function application obligation:(forall f:(@T1 -\u003e @T2), s:seq of (@T1) \u0026 (forall i in set (inds s) \u0026 pre_(fs(i))))","legal sequence application obligation:(forall f:(@T1 -\u003e @T2), s:seq of (@T1) \u0026 (forall i in set (inds s) \u0026 (i in set (inds s))))","legal function application obligation:(forall f:(@elem -\u003e @elem), l:seq of (@elem) \u0026 ((not (l \u003d [])) \u003d\u003e pre_(f(hd l))))","non-empty sequence obligation:(forall f:(@elem -\u003e @elem), l:seq of (@elem) \u0026 ((not (l \u003d [])) \u003d\u003e (l \u003c\u003e [])))","legal function application obligation:(forall f:(@elem -\u003e @elem), l:seq of (@elem) \u0026 ((not (l \u003d [])) \u003d\u003e pre_((Fmap)[@elem](f)(tl l))))","non-empty sequence obligation:(forall f:(@elem -\u003e @elem), l:seq of (@elem) \u0026 ((not (l \u003d [])) \u003d\u003e (l \u003c\u003e [])))","legal sequence application obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 (forall i in set (inds s) \u0026 (f(s(i)) \u003d\u003e (i in set (inds s)))))","legal function application obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 (forall i in set (inds s) \u0026 pre_(fs(i))))","legal sequence application obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 (forall i in set (inds s) \u0026 (i in set (inds s))))","legal function application obligation:(forall f:(@T1 -\u003e (@T2 -\u003e @T1)), arg:@T1, s:seq of (@T2) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [h] ^ tail:seq of (@T2) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in pre_((Foldl)[@T1, @T2](f)(f(arg)(h))tail)))))","legal function application obligation:(forall f:(@T1 -\u003e (@T2 -\u003e @T1)), arg:@T1, s:seq of (@T2) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [h] ^ tail:seq of (@T2) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in pre_((Foldl)[@T1, @T2](f)f(arg)(h))))))","legal function application obligation:(forall f:(@T1 -\u003e (@T2 -\u003e @T1)), arg:@T1, s:seq of (@T2) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [h] ^ tail:seq of (@T2) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in pre_(f(arg)h)))))","legal function application obligation:(forall f:(@T1 -\u003e (@T2 -\u003e @T1)), arg:@T1, s:seq of (@T2) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [h] ^ tail:seq of (@T2) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in pre_(farg)))))","cases exhaustive obligation:(forall f:(@T1 -\u003e (@T2 -\u003e @T1)), arg:@T1, s:seq of (@T2) \u0026 ((s \u003d []) or (exists [h] ^ tail:seq of (@T2) \u0026 (s \u003d ([h] ^ tail)))))","legal function application obligation:(forall f:(@T1 -\u003e (@T2 -\u003e @T2)), arg:@T2, s:seq of (@T1) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [h] ^ tail:seq of (@T1) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in pre_(f(h)(Foldr)[@T1, @T2](f)(arg)(tail))))))","legal function application obligation:(forall f:(@T1 -\u003e (@T2 -\u003e @T2)), arg:@T2, s:seq of (@T1) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [h] ^ tail:seq of (@T1) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in pre_(fh)))))","legal function application obligation:(forall f:(@T1 -\u003e (@T2 -\u003e @T2)), arg:@T2, s:seq of (@T1) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [h] ^ tail:seq of (@T1) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in pre_((Foldr)[@T1, @T2](f)(arg)tail)))))","legal function application obligation:(forall f:(@T1 -\u003e (@T2 -\u003e @T2)), arg:@T2, s:seq of (@T1) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [h] ^ tail:seq of (@T1) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in pre_((Foldr)[@T1, @T2](f)arg)))))","cases exhaustive obligation:(forall f:(@T1 -\u003e (@T2 -\u003e @T2)), arg:@T2, s:seq of (@T1) \u0026 ((s \u003d []) or (exists [h] ^ tail:seq of (@T1) \u0026 (s \u003d ([h] ^ tail)))))","legal function application obligation:(forall e:@T, s:seq of (@T) \u0026 (exists [h] ^ tail:seq of (@T) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in ((not (e \u003d h)) \u003d\u003e pre_((isMember)[@T](e)tail)))))","cases exhaustive obligation:(forall e:@T, s:seq of (@T) \u0026 ((exists [h] ^ tail:seq of (@T) \u0026 (s \u003d ([h] ^ tail))) or (s \u003d [])))","legal function application obligation:(forall elemSeq:seq of (@T), s:seq of (@T) \u0026 (exists [h] ^ tail:seq of (@T) \u0026 ((([h] ^ tail) \u003d elemSeq) \u003d\u003e let [h] ^ tail \u003d elemSeq in pre_((isMember)[@T](h)s))))","legal function application obligation:(forall elemSeq:seq of (@T), s:seq of (@T) \u0026 (exists [h] ^ tail:seq of (@T) \u0026 ((([h] ^ tail) \u003d elemSeq) \u003d\u003e let [h] ^ tail \u003d elemSeq in ((not (isMember)[@T](h)(s)) \u003d\u003e pre_((isAnyMember)[@T](tail)s)))))","cases exhaustive obligation:(forall elemSeq:seq of (@T), s:seq of (@T) \u0026 ((exists [h] ^ tail:seq of (@T) \u0026 (elemSeq \u003d ([h] ^ tail))) or (elemSeq \u003d [])))","legal function application obligation:(forall e:@T, s:seq of (@T) \u0026 let i:nat \u003d 0 in pre_((IndexAux)[@T](e)(s)i))","legal function application obligation:(forall e:@T, s:seq of (@T) \u0026 let i:nat \u003d 0 in pre_((IndexAux)[@T](e)s))","legal function application obligation:(forall e:@T, s:seq of (@T), indx:int \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in ((not (x \u003d e)) \u003d\u003e pre_((IndexAux)[@T](e)(xs)(indx + 1)))))))","legal function application obligation:(forall e:@T, s:seq of (@T), indx:int \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in ((not (x \u003d e)) \u003d\u003e pre_((IndexAux)[@T](e)xs))))))","cases exhaustive obligation:(forall e:@T, s:seq of (@T), indx:int \u0026 ((s \u003d []) or (exists [x] ^ xs:seq of (@T) \u0026 (s \u003d ([x] ^ xs)))))","legal sequence application obligation:(forall e:@T, s:seq of (@T) \u0026 (forall i in set (inds s) \u0026 (i in set (inds s))))","legal sequence application obligation:(forall s:seq of ([@T]) \u0026 (forall i in set (inds s) \u0026 ((s(i) \u003c\u003e nil) \u003d\u003e (i in set (inds s)))))","legal sequence application obligation:(forall s:seq of ([@T]) \u0026 (forall i in set (inds s) \u0026 (i in set (inds s))))","legal sequence application obligation:(forall s:seq of (@T) \u0026 (forall i in set (inds s) \u0026 ((((len s) + 1) - i) in set (inds s))))","legal sequence application obligation:(forall s:seq of (@T) \u0026 ((not ([] \u003d s)) \u003d\u003e ((not (exists [-]:seq of (@T) \u0026 ([any1] \u003d s))) \u003d\u003e (forall i in set (inds s) \u0026 (forall j in set (Permutations)[@T]((RestSeq)[@T](s, i)) \u0026 (i in set (inds s)))))))","recursive function obligation:(forall s:seq of (@T) \u0026 ((not ([] \u003d s)) \u003d\u003e ((not (exists [-]:seq of (@T) \u0026 ([any1] \u003d s))) \u003d\u003e (forall i in set (inds s) \u0026 ((length_measure)[seq of (@T)](s) \u003e (length_measure)[@T]((RestSeq)[@T](s, i)))))))","legal sequence application obligation:(forall s:seq of (@T), i:nat \u0026 (forall j in set ((inds s) \\ {i}) \u0026 (j in set (inds s))))","recursive function obligation:(forall s:seq of ((@T1 * @T2)) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [mk_(x, y)] ^ tail:seq of ((@T1 * @T2)) \u0026 ((([mk_(x, y)] ^ tail) \u003d s) \u003d\u003e let [mk_(x, y)] ^ tail \u003d s in ((lengthUnzip)[seq of ((@T1 * @T2))](s) \u003e (lengthUnzip)[@T1, @T2](tail))))))","cases exhaustive obligation:(forall s:seq of ((@T1 * @T2)) \u0026 ((s \u003d []) or (exists [mk_(x, y)] ^ tail:seq of ((@T1 * @T2)) \u0026 (s \u003d ([mk_(x, y)] ^ tail)))))","legal function application obligation:(forall s1:seq of (@T1), s2:seq of (@T2) \u0026 pre_((Zip2)[@T1, @T2](s1)s2))","legal function application obligation:(forall s1:seq of (@T1), s2:seq of (@T2) \u0026 (exists mk_([h1] ^ tail1, [h2] ^ tail2):(seq of (@T1) * seq of (@T2)) \u0026 ((mk_(([h1] ^ tail1), ([h2] ^ tail2)) \u003d mk_(s1, s2)) \u003d\u003e let mk_([h1] ^ tail1, [h2] ^ tail2) \u003d mk_(s1, s2) in pre_((Zip2)[@T1, @T2](tail1)tail2))))","cases exhaustive obligation:(forall s1:seq of (@T1), s2:seq of (@T2) \u0026 ((exists mk_([h1] ^ tail1, [h2] ^ tail2):(seq of (@T1) * seq of (@T2)) \u0026 (mk_(s1, s2) \u003d mk_(([h1] ^ tail1), ([h2] ^ tail2)))) or (exists mk_(-, -):(seq of (@T1) * seq of (@T2)) \u0026 (mk_(s1, s2) \u003d mk_(any1, any1)))))","legal function application obligation:pre_((term1.isInThePeriod)t1, term1)","legal function application obligation:((not (term1.isInThePeriod)(t1, term1)) \u003d\u003e pre_((term1.isInThePeriod)t2, term1))","legal function application obligation:((not (term1.isInThePeriod)(t1, term1)) \u003d\u003e ((term1.isInThePeriod)(t2, term1) \u003d\u003e pre_((term1.isInThePeriod)t3, term1)))","legal function application obligation:((not (term1.isInThePeriod)(t1, term1)) \u003d\u003e ((term1.isInThePeriod)(t2, term1) \u003d\u003e ((term1.isInThePeriod)(t3, term1) \u003d\u003e pre_((term1.isInThePeriod)t4, term1))))","legal function application obligation:((not (term1.isInThePeriod)(t1, term1)) \u003d\u003e ((term1.isInThePeriod)(t2, term1) \u003d\u003e ((term1.isInThePeriod)(t3, term1) \u003d\u003e ((term1.isInThePeriod)(t4, term1) \u003d\u003e pre_((term1.isInThePeriod)t5, term1)))))","legal function application obligation:((not (term1.isInThePeriod)(t1, term1)) \u003d\u003e ((term1.isInThePeriod)(t2, term1) \u003d\u003e ((term1.isInThePeriod)(t3, term1) \u003d\u003e ((term1.isInThePeriod)(t4, term1) \u003d\u003e ((not (term1.isInThePeriod)(t5, term1)) \u003d\u003e pre_((term1.isInThePeriod)t6, term1))))))","legal function application obligation:((not (term1.isInThePeriod)(t1, term1)) \u003d\u003e ((term1.isInThePeriod)(t2, term1) \u003d\u003e ((term1.isInThePeriod)(t3, term1) \u003d\u003e ((term1.isInThePeriod)(t4, term1) \u003d\u003e ((not (term1.isInThePeriod)(t5, term1)) \u003d\u003e ((not (term1.isInThePeriod)(t6, term1)) \u003d\u003e pre_((term1.isInThePeriod)t7, term1)))))))","legal function application obligation:((not (term1.isInThePeriod)(t1, term1)) \u003d\u003e ((term1.isInThePeriod)(t2, term1) \u003d\u003e ((term1.isInThePeriod)(t3, term1) \u003d\u003e ((term1.isInThePeriod)(t4, term1) \u003d\u003e ((not (term1.isInThePeriod)(t5, term1)) \u003d\u003e ((not (term1.isInThePeriod)(t6, term1)) \u003d\u003e ((not (term1.isInThePeriod)(t7, term1)) \u003d\u003e pre_((term1.isInThePeriod)t8, term1))))))))","legal function application obligation:((not (term1.isInThePeriod)(t1, term1)) \u003d\u003e ((term1.isInThePeriod)(t2, term1) \u003d\u003e ((term1.isInThePeriod)(t3, term1) \u003d\u003e ((term1.isInThePeriod)(t4, term1) \u003d\u003e ((not (term1.isInThePeriod)(t5, term1)) \u003d\u003e ((not (term1.isInThePeriod)(t6, term1)) \u003d\u003e ((not (term1.isInThePeriod)(t7, term1)) \u003d\u003e ((not (term1.isInThePeriod)(t8, term1)) \u003d\u003e pre_((term1.isInThePeriod)t9, term1)))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aKey:@T1, aValue:@T2 \u0026 pre_(aHashCodeaKey))","legal map application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aKey:@T1, aValue:@T2 \u0026 let hashcode:@T1 \u003d aHashCode(aKey) in ((hashcode in set (dom aHashtable)) \u003d\u003e (hashcode in set (dom aHashtable))))","map compatible obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aKey:@T1, aValue:@T2 \u0026 let hashcode:@T1 \u003d aHashCode(aKey) in ((not (hashcode in set (dom aHashtable))) \u003d\u003e (forall ldom1 in set (dom aHashtable), rdom2 in set (dom {hashcode |-\u003e {aKey |-\u003e aValue}}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (aHashtable(ldom1) \u003d {hashcode |-\u003e {aKey |-\u003e aValue}}(rdom2))))))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aMap:map (@T1) to (@T2) \u0026 pre_((PutAllAux)[@T1, @T2](aHashtable)(aHashCode)(aMap)(dom aMap)))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aMap:map (@T1) to (@T2) \u0026 pre_((PutAllAux)[@T1, @T2](aHashtable)(aHashCode)aMap))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aMap:map (@T1) to (@T2) \u0026 pre_((PutAllAux)[@T1, @T2](aHashtable)aHashCode))","let be st existence obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aMap:map (@T1) to (@T2), aKeySet:set of (@T1) \u0026 ((not (aKeySet \u003d {})) \u003d\u003e (exists aKey in set aKeySet \u0026 true)))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aMap:map (@T1) to (@T2), aKeySet:set of (@T1) \u0026 ((not (aKeySet \u003d {})) \u003d\u003e (forall aKey in set aKeySet \u0026 pre_((Put)[@T1, @T2](aHashtable)(aHashCode)(aKey)aMap(aKey)))))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aMap:map (@T1) to (@T2), aKeySet:set of (@T1) \u0026 ((not (aKeySet \u003d {})) \u003d\u003e (forall aKey in set aKeySet \u0026 pre_((Put)[@T1, @T2](aHashtable)(aHashCode)aKey))))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aMap:map (@T1) to (@T2), aKeySet:set of (@T1) \u0026 ((not (aKeySet \u003d {})) \u003d\u003e (forall aKey in set aKeySet \u0026 pre_((Put)[@T1, @T2](aHashtable)aHashCode))))","legal map application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aMap:map (@T1) to (@T2), aKeySet:set of (@T1) \u0026 ((not (aKeySet \u003d {})) \u003d\u003e (forall aKey in set aKeySet \u0026 (aKey in set (dom aMap)))))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aMap:map (@T1) to (@T2), aKeySet:set of (@T1) \u0026 ((not (aKeySet \u003d {})) \u003d\u003e (forall aKey in set aKeySet \u0026 let newHashtable:map (@T1) to (map (@T1) to (@T2)) \u003d (Put)[@T1, @T2](aHashtable)(aHashCode)(aKey)(aMap(aKey)) in pre_((PutAllAux)[@T1, @T2](newHashtable)(aHashCode)(aMap)(aKeySet \\ {aKey})))))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aMap:map (@T1) to (@T2), aKeySet:set of (@T1) \u0026 ((not (aKeySet \u003d {})) \u003d\u003e (forall aKey in set aKeySet \u0026 let newHashtable:map (@T1) to (map (@T1) to (@T2)) \u003d (Put)[@T1, @T2](aHashtable)(aHashCode)(aKey)(aMap(aKey)) in pre_((PutAllAux)[@T1, @T2](newHashtable)(aHashCode)aMap))))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aMap:map (@T1) to (@T2), aKeySet:set of (@T1) \u0026 ((not (aKeySet \u003d {})) \u003d\u003e (forall aKey in set aKeySet \u0026 let newHashtable:map (@T1) to (map (@T1) to (@T2)) \u003d (Put)[@T1, @T2](aHashtable)(aHashCode)(aKey)(aMap(aKey)) in pre_((PutAllAux)[@T1, @T2](newHashtable)aHashCode))))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aKey:@T1 \u0026 pre_(aHashCodeaKey))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aKey:@T1 \u0026 let hashcode:@T1 \u003d aHashCode(aKey) in ((hashcode in set (dom aHashtable)) \u003d\u003e pre_((FMap`Get)[@T1, @T2](aHashtable(hashcode))aKey)))","legal map application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aKey:@T1 \u0026 let hashcode:@T1 \u003d aHashCode(aKey) in ((hashcode in set (dom aHashtable)) \u003d\u003e (hashcode in set (dom aHashtable))))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aKey:@T1 \u0026 pre_(aHashCodeaKey))","comprehension map injectivity obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aKey:@T1 \u0026 let hashcode:@T1 \u003d aHashCode(aKey) in (forall m1, m2 in set {{h |-\u003e ({aKey} \u003c-: aHashtable(hashcode))} | h in set {hashcode}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4))))))","legal map application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aKey:@T1 \u0026 let hashcode:@T1 \u003d aHashCode(aKey) in (forall h in set {hashcode} \u0026 (hashcode in set (dom aHashtable))))","map compatible obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aKey:@T1 \u0026 let hashcode:@T1 \u003d aHashCode(aKey) in (forall ldom1 in set (dom {h |-\u003e ({aKey} \u003c-: aHashtable(hashcode)) | h in set {hashcode}}), rdom2 in set (dom ({hashcode} \u003c-: aHashtable)) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e ({h |-\u003e ({aKey} \u003c-: aHashtable(hashcode)) | h in set {hashcode}}(ldom1) \u003d ({hashcode} \u003c-: aHashtable)(rdom2)))))","enumeration map injectivity obligation:(forall m1, m2 in set {{k1 |-\u003e new StringObj(\"Shin Sahara\")}, {k2 |-\u003e new StringObj(\"Kei Sato\")}, {k3 |-\u003e new StringObj(\"Hiroshi Sakoh\")}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","legal function application obligation:(((h1.getBuckets)() \u003d {|-\u003e}) \u003d\u003e pre_(((h2.get)(k1).equals)new StringObj(\"Shin Sahara\")))","legal function application obligation:(((h1.getBuckets)() \u003d {|-\u003e}) \u003d\u003e (((h2.get)(k1).equals)(new StringObj(\"Shin Sahara\")) \u003d\u003e pre_(((h2.get)(k2).equals)new StringObj(\"Kei Sato\"))))","legal function application obligation:(((h1.getBuckets)() \u003d {|-\u003e}) \u003d\u003e (((h2.get)(k1).equals)(new StringObj(\"Shin Sahara\")) \u003d\u003e (((h2.get)(k2).equals)(new StringObj(\"Kei Sato\")) \u003d\u003e pre_(((h2.get)(k3).equals)new StringObj(\"Hiroshi Sakoh\")))))","legal function application obligation:(((h1.getBuckets)() \u003d {|-\u003e}) \u003d\u003e (((h2.get)(k1).equals)(new StringObj(\"Shin Sahara\")) \u003d\u003e (((h2.get)(k2).equals)(new StringObj(\"Kei Sato\")) \u003d\u003e (((h2.get)(k3).equals)(new StringObj(\"Hiroshi Sakoh\")) \u003d\u003e pre_(((h2.get)(new IntObj(1)).equals)new StringObj(\"Shin Sahara\"))))))","legal function application obligation:(((h1.getBuckets)() \u003d {|-\u003e}) \u003d\u003e (((h2.get)(k1).equals)(new StringObj(\"Shin Sahara\")) \u003d\u003e (((h2.get)(k2).equals)(new StringObj(\"Kei Sato\")) \u003d\u003e (((h2.get)(k3).equals)(new StringObj(\"Hiroshi Sakoh\")) \u003d\u003e (((h2.get)(new IntObj(1)).equals)(new StringObj(\"Shin Sahara\")) \u003d\u003e pre_(((h2.get)(new IntObj(2)).equals)new StringObj(\"Kei Sato\")))))))","legal function application obligation:(((h1.getBuckets)() \u003d {|-\u003e}) \u003d\u003e (((h2.get)(k1).equals)(new StringObj(\"Shin Sahara\")) \u003d\u003e (((h2.get)(k2).equals)(new StringObj(\"Kei Sato\")) \u003d\u003e (((h2.get)(k3).equals)(new StringObj(\"Hiroshi Sakoh\")) \u003d\u003e (((h2.get)(new IntObj(1)).equals)(new StringObj(\"Shin Sahara\")) \u003d\u003e (((h2.get)(new IntObj(2)).equals)(new StringObj(\"Kei Sato\")) \u003d\u003e pre_(((h2.get)(new IntObj(3)).equals)new StringObj(\"Hiroshi Sakoh\"))))))))","type compatibility obligation:is_(RESULT, ())","enumeration map injectivity obligation:(forall m1, m2 in set {{new IntObj(1) |-\u003e new StringObj(\"Shin Sahara\")}, {new IntObj(2) |-\u003e new StringObj(\"Kei Sato\")}, {new IntObj(3) |-\u003e new StringObj(\"Hiroshi Sakoh\")}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","enumeration map injectivity obligation:(forall m1, m2 in set {{new StringObj(\"a\") |-\u003e new IntObj(1)}, {new StringObj(\"b\") |-\u003e new IntObj(2)}, {new StringObj(\"c\") |-\u003e new IntObj(3)}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","legal function application obligation:pre_((h1.contains)new StringObj(\"Shin Sahara\"))","legal function application obligation:((h1.contains)(new StringObj(\"Shin Sahara\")) \u003d\u003e pre_((h1.contains)new StringObj(\"Kei Sato\")))","legal function application obligation:((h1.contains)(new StringObj(\"Shin Sahara\")) \u003d\u003e ((h1.contains)(new StringObj(\"Kei Sato\")) \u003d\u003e pre_((h1.contains)new StringObj(\"Shin Sakoh\"))))","legal function application obligation:((h1.contains)(new StringObj(\"Shin Sahara\")) \u003d\u003e ((h1.contains)(new StringObj(\"Kei Sato\")) \u003d\u003e (((h1.contains)(new StringObj(\"Shin Sakoh\")) \u003d false) \u003d\u003e pre_((h1.containsKey)new IntObj(1)))))","legal function application obligation:((h1.contains)(new StringObj(\"Shin Sahara\")) \u003d\u003e ((h1.contains)(new StringObj(\"Kei Sato\")) \u003d\u003e (((h1.contains)(new StringObj(\"Shin Sakoh\")) \u003d false) \u003d\u003e ((h1.containsKey)(new IntObj(1)) \u003d\u003e pre_((h1.containsKey)new IntObj(4))))))","legal function application obligation:((h1.contains)(new StringObj(\"Shin Sahara\")) \u003d\u003e ((h1.contains)(new StringObj(\"Kei Sato\")) \u003d\u003e (((h1.contains)(new StringObj(\"Shin Sakoh\")) \u003d false) \u003d\u003e ((h1.containsKey)(new IntObj(1)) \u003d\u003e (((h1.containsKey)(new IntObj(4)) \u003d false) \u003d\u003e pre_((h2.contains)new IntObj(3)))))))","legal function application obligation:((h1.contains)(new StringObj(\"Shin Sahara\")) \u003d\u003e ((h1.contains)(new StringObj(\"Kei Sato\")) \u003d\u003e (((h1.contains)(new StringObj(\"Shin Sakoh\")) \u003d false) \u003d\u003e ((h1.containsKey)(new IntObj(1)) \u003d\u003e (((h1.containsKey)(new IntObj(4)) \u003d false) \u003d\u003e ((h2.contains)(new IntObj(3)) \u003d\u003e pre_((h2.contains)new IntObj(7))))))))","legal function application obligation:((h1.contains)(new StringObj(\"Shin Sahara\")) \u003d\u003e ((h1.contains)(new StringObj(\"Kei Sato\")) \u003d\u003e (((h1.contains)(new StringObj(\"Shin Sakoh\")) \u003d false) \u003d\u003e ((h1.containsKey)(new IntObj(1)) \u003d\u003e (((h1.containsKey)(new IntObj(4)) \u003d false) \u003d\u003e ((h2.contains)(new IntObj(3)) \u003d\u003e (((h2.contains)(new IntObj(7)) \u003d false) \u003d\u003e pre_((h2.containsKey)new StringObj(\"a\")))))))))","legal function application obligation:((h1.contains)(new StringObj(\"Shin Sahara\")) \u003d\u003e ((h1.contains)(new StringObj(\"Kei Sato\")) \u003d\u003e (((h1.contains)(new StringObj(\"Shin Sakoh\")) \u003d false) \u003d\u003e ((h1.containsKey)(new IntObj(1)) \u003d\u003e (((h1.containsKey)(new IntObj(4)) \u003d false) \u003d\u003e ((h2.contains)(new IntObj(3)) \u003d\u003e (((h2.contains)(new IntObj(7)) \u003d false) \u003d\u003e ((h2.containsKey)(new StringObj(\"a\")) \u003d\u003e pre_((h2.containsKey)new StringObj(\"d\"))))))))))","type compatibility obligation:is_(RESULT, ())","enumeration map injectivity obligation:(forall m1, m2 in set {{new IntObj(1) |-\u003e new StringObj(\"Shin Sahara\")}, {new IntObj(2) |-\u003e new StringObj(\"Kei Sato\")}, {new IntObj(3) |-\u003e new StringObj(\"Hiroshi Sakoh\")}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","enumeration map injectivity obligation:(forall m1, m2 in set {{new StringObj(\"a\") |-\u003e new IntObj(1)}, {new StringObj(\"b\") |-\u003e new IntObj(2)}, {new StringObj(\"c\") |-\u003e new IntObj(3)}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","legal function application obligation:(((h1.getBuckets)() \u003d {|-\u003e}) \u003d\u003e pre_((deleteObj.equals)new IntObj(2)))","legal function application obligation:(((h1.getBuckets)() \u003d {|-\u003e}) \u003d\u003e ((deleteObj.equals)(new IntObj(2)) \u003d\u003e (((h2.get)(new StringObj(\"b\")) \u003d nil) \u003d\u003e pre_((h2.contains)new IntObj(2)))))","legal function application obligation:(((h1.getBuckets)() \u003d {|-\u003e}) \u003d\u003e ((deleteObj.equals)(new IntObj(2)) \u003d\u003e (((h2.get)(new StringObj(\"b\")) \u003d nil) \u003d\u003e (((h2.contains)(new IntObj(2)) \u003d false) \u003d\u003e pre_((h2.containsKey)new StringObj(\"b\"))))))","type compatibility obligation:is_(RESULT, ())","enumeration map injectivity obligation:(forall m1, m2 in set {{new IntObj(1) |-\u003e new StringObj(\"Shin Sahara\")}, {new IntObj(2) |-\u003e new StringObj(\"Kei Sato\")}, {new IntObj(14) |-\u003e new StringObj(\"Hiroshi Sakoh\")}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","legal function application obligation:pre_(((h1.get)(new IntObj(1)).equals)new StringObj(\"Shin Sahara\"))","legal function application obligation:(((h1.get)(new IntObj(1)).equals)(new StringObj(\"Shin Sahara\")) \u003d\u003e pre_(((h1.get)(new IntObj(2)).equals)new StringObj(\"Kei Sato\")))","legal function application obligation:(((h1.get)(new IntObj(1)).equals)(new StringObj(\"Shin Sahara\")) \u003d\u003e (((h1.get)(new IntObj(2)).equals)(new StringObj(\"Kei Sato\")) \u003d\u003e pre_(((h1.get)(new IntObj(14)).equals)new StringObj(\"Hiroshi Sakoh\"))))","legal function application obligation:(((h1.get)(new IntObj(1)).equals)(new StringObj(\"Shin Sahara\")) \u003d\u003e (((h1.get)(new IntObj(2)).equals)(new StringObj(\"Kei Sato\")) \u003d\u003e (((h1.get)(new IntObj(14)).equals)(new StringObj(\"Hiroshi Sakoh\")) \u003d\u003e (((h1.get)(new IntObj(4)) \u003d nil) \u003d\u003e pre_(((h2.get)(new StringObj(\"a\")).equals)new IntObj(1))))))","legal function application obligation:(((h1.get)(new IntObj(1)).equals)(new StringObj(\"Shin Sahara\")) \u003d\u003e (((h1.get)(new IntObj(2)).equals)(new StringObj(\"Kei Sato\")) \u003d\u003e (((h1.get)(new IntObj(14)).equals)(new StringObj(\"Hiroshi Sakoh\")) \u003d\u003e (((h1.get)(new IntObj(4)) \u003d nil) \u003d\u003e (((h2.get)(new StringObj(\"a\")).equals)(new IntObj(1)) \u003d\u003e pre_(((h2.get)(new StringObj(\"b\")).equals)new IntObj(2)))))))","legal function application obligation:(((h1.get)(new IntObj(1)).equals)(new StringObj(\"Shin Sahara\")) \u003d\u003e (((h1.get)(new IntObj(2)).equals)(new StringObj(\"Kei Sato\")) \u003d\u003e (((h1.get)(new IntObj(14)).equals)(new StringObj(\"Hiroshi Sakoh\")) \u003d\u003e (((h1.get)(new IntObj(4)) \u003d nil) \u003d\u003e (((h2.get)(new StringObj(\"a\")).equals)(new IntObj(1)) \u003d\u003e (((h2.get)(new StringObj(\"b\")).equals)(new IntObj(2)) \u003d\u003e pre_(((h2.get)(new StringObj(\"c\")).equals)new IntObj(3))))))))","type compatibility obligation:is_(RESULT, ())","enumeration map injectivity obligation:(forall m1, m2 in set {{h1k1 |-\u003e h1v1}, {h1k2 |-\u003e h1v2}, {h1k3 |-\u003e h1v3}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","type compatibility obligation:is_(RESULT, ())","enumeration map injectivity obligation:(forall m1, m2 in set {{h1k1 |-\u003e h1v1}, {h1k2 |-\u003e h1v2}, {h1k3 |-\u003e h1v3}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","type compatibility obligation:is_(RESULT, ())","enumeration map injectivity obligation:(forall m1, m2 in set {{h1k1 |-\u003e h1v1}, {h1k2 |-\u003e h1v2}, {h1k3 |-\u003e h1v3}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","enumeration map injectivity obligation:(forall m1, m2 in set {{h1k1 |-\u003e h1v1}, {h1k2 |-\u003e h1v2}, {h1k3 |-\u003e h1v3}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","legal function application obligation:pre_((h1.isEmpty))","legal function application obligation:((h1.isEmpty)() \u003d\u003e pre_((h1.size)))","legal function application obligation:((h1.isEmpty)() \u003d\u003e (((h1.size)() \u003d 0) \u003d\u003e pre_((h2.isEmpty))))","legal function application obligation:((h1.isEmpty)() \u003d\u003e (((h1.size)() \u003d 0) \u003d\u003e (((h2.isEmpty)() \u003d false) \u003d\u003e pre_((h2.size)))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((Hashtable`PutAll)[int, seq of (char)]({|-\u003e})(aHashCode){1 |-\u003e \"Sahara\", 2 |-\u003e \"Sato\", 14 |-\u003e \"Sakoh\"})","legal function application obligation:pre_((Hashtable`PutAll)[int, seq of (char)]({|-\u003e})aHashCode)","enumeration map injectivity obligation:(forall m1, m2 in set {{1 |-\u003e \"Sahara\"}, {2 |-\u003e \"Sato\"}, {14 |-\u003e \"Sakoh\"}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","legal function application obligation:pre_(c1\"Sahara\")","legal function application obligation:(c1(\"Sahara\") \u003d\u003e pre_(c1\"Sato\"))","legal function application obligation:(c1(\"Sahara\") \u003d\u003e (c1(\"Sato\") \u003d\u003e pre_(c1\"Sakoh\")))","legal function application obligation:(c1(\"Sahara\") \u003d\u003e (c1(\"Sato\") \u003d\u003e (c1(\"Sakoh\") \u003d\u003e pre_(c1\"\"))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:(forall x:seq of (char) \u0026 ((not (x \u003d \"\")) \u003d\u003e pre_((Sequence`take)[char](1)x)))","legal function application obligation:pre_((Hashtable`PutAll)[int, seq of (char)]({|-\u003e})(aHashCode1){1 |-\u003e \"Shin Sahara\", 2 |-\u003e \"Kei Sato\", 14 |-\u003e \"Hiroshi Sakoh\"})","legal function application obligation:pre_((Hashtable`PutAll)[int, seq of (char)]({|-\u003e})aHashCode1)","enumeration map injectivity obligation:(forall m1, m2 in set {{1 |-\u003e \"Shin Sahara\"}, {2 |-\u003e \"Kei Sato\"}, {14 |-\u003e \"Hiroshi Sakoh\"}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","legal function application obligation:pre_((Hashtable`PutAll)[seq of (char), int]({|-\u003e})(aHashCode2){\"a\" |-\u003e 1, \"b\" |-\u003e 2, \"c\" |-\u003e 3})","legal function application obligation:pre_((Hashtable`PutAll)[seq of (char), int]({|-\u003e})aHashCode2)","enumeration map injectivity obligation:(forall m1, m2 in set {{\"a\" |-\u003e 1}, {\"b\" |-\u003e 2}, {\"c\" |-\u003e 3}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","legal function application obligation:pre_((Hashtable`Remove)[seq of (char), int](h2)(aHashCode2)\"b\")","legal function application obligation:pre_((Hashtable`Remove)[seq of (char), int](h2)aHashCode2)","legal function application obligation:((h3 \u003d {|-\u003e}) \u003d\u003e pre_((Hashtable`Get)[seq of (char), int](afterRemoveh2)(aHashCode2)\"b\"))","legal function application obligation:((h3 \u003d {|-\u003e}) \u003d\u003e pre_((Hashtable`Get)[seq of (char), int](afterRemoveh2)aHashCode2))","legal function application obligation:((h3 \u003d {|-\u003e}) \u003d\u003e (((Hashtable`Get)[seq of (char), int](afterRemoveh2)(aHashCode2)(\"b\") \u003d nil) \u003d\u003e pre_(c12)))","legal function application obligation:((h3 \u003d {|-\u003e}) \u003d\u003e (((Hashtable`Get)[seq of (char), int](afterRemoveh2)(aHashCode2)(\"b\") \u003d nil) \u003d\u003e ((c1(2) \u003d false) \u003d\u003e pre_(c11))))","legal function application obligation:((h3 \u003d {|-\u003e}) \u003d\u003e (((Hashtable`Get)[seq of (char), int](afterRemoveh2)(aHashCode2)(\"b\") \u003d nil) \u003d\u003e ((c1(2) \u003d false) \u003d\u003e (c1(1) \u003d\u003e pre_(c13)))))","legal function application obligation:((h3 \u003d {|-\u003e}) \u003d\u003e (((Hashtable`Get)[seq of (char), int](afterRemoveh2)(aHashCode2)(\"b\") \u003d nil) \u003d\u003e ((c1(2) \u003d false) \u003d\u003e (c1(1) \u003d\u003e (c1(3) \u003d\u003e pre_(ck1\"b\"))))))","legal function application obligation:((h3 \u003d {|-\u003e}) \u003d\u003e (((Hashtable`Get)[seq of (char), int](afterRemoveh2)(aHashCode2)(\"b\") \u003d nil) \u003d\u003e ((c1(2) \u003d false) \u003d\u003e (c1(1) \u003d\u003e (c1(3) \u003d\u003e ((ck1(\"b\") \u003d false) \u003d\u003e pre_(ck1\"a\")))))))","legal function application obligation:((h3 \u003d {|-\u003e}) \u003d\u003e (((Hashtable`Get)[seq of (char), int](afterRemoveh2)(aHashCode2)(\"b\") \u003d nil) \u003d\u003e ((c1(2) \u003d false) \u003d\u003e (c1(1) \u003d\u003e (c1(3) \u003d\u003e ((ck1(\"b\") \u003d false) \u003d\u003e (ck1(\"a\") \u003d\u003e pre_(ck1\"c\"))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(put({|-\u003e})(aHashCode)(1)\"Sahara\")","legal function application obligation:pre_(put({|-\u003e})(aHashCode)1)","legal function application obligation:pre_(put({|-\u003e})aHashCode)","legal function application obligation:pre_(put{|-\u003e})","legal function application obligation:pre_(put(p1)(aHashCode)(2)\"Bush\")","legal function application obligation:pre_(put(p1)(aHashCode)2)","legal function application obligation:pre_(put(p1)aHashCode)","legal function application obligation:pre_(putp1)","legal function application obligation:pre_(put(p2)(aHashCode)(2)\"Sato\")","legal function application obligation:pre_(put(p2)(aHashCode)2)","legal function application obligation:pre_(put(p2)aHashCode)","legal function application obligation:pre_(putp2)","legal function application obligation:pre_(put(p3)(aHashCode)(14)\"Sakoh\")","legal function application obligation:pre_(put(p3)(aHashCode)14)","legal function application obligation:pre_(put(p3)aHashCode)","legal function application obligation:pre_(putp3)","legal function application obligation:pre_(get(aHashCode)1)","legal function application obligation:pre_(getaHashCode)","legal function application obligation:((get(aHashCode)(1) \u003d \"Sahara\") \u003d\u003e pre_(get(aHashCode)2))","legal function application obligation:((get(aHashCode)(1) \u003d \"Sahara\") \u003d\u003e pre_(getaHashCode))","legal function application obligation:((get(aHashCode)(1) \u003d \"Sahara\") \u003d\u003e ((get(aHashCode)(2) \u003d \"Sato\") \u003d\u003e pre_(get(aHashCode)14)))","legal function application obligation:((get(aHashCode)(1) \u003d \"Sahara\") \u003d\u003e ((get(aHashCode)(2) \u003d \"Sato\") \u003d\u003e pre_(getaHashCode)))","legal function application obligation:((get(aHashCode)(1) \u003d \"Sahara\") \u003d\u003e ((get(aHashCode)(2) \u003d \"Sato\") \u003d\u003e ((get(aHashCode)(14) \u003d \"Sakoh\") \u003d\u003e pre_(get(aHashCode)99))))","legal function application obligation:((get(aHashCode)(1) \u003d \"Sahara\") \u003d\u003e ((get(aHashCode)(2) \u003d \"Sato\") \u003d\u003e ((get(aHashCode)(14) \u003d \"Sakoh\") \u003d\u003e pre_(getaHashCode))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(put({|-\u003e})(aHashCode)(1)\"Sahara\")","legal function application obligation:pre_(put({|-\u003e})(aHashCode)1)","legal function application obligation:pre_(put({|-\u003e})aHashCode)","legal function application obligation:pre_(put{|-\u003e})","legal function application obligation:pre_(put(p1)(aHashCode)(2)\"Bush\")","legal function application obligation:pre_(put(p1)(aHashCode)2)","legal function application obligation:pre_(put(p1)aHashCode)","legal function application obligation:pre_(putp1)","legal function application obligation:pre_(put(p2)(aHashCode)(2)\"Sato\")","legal function application obligation:pre_(put(p2)(aHashCode)2)","legal function application obligation:pre_(put(p2)aHashCode)","legal function application obligation:pre_(putp2)","legal function application obligation:pre_(put(p3)(aHashCode)(14)\"Sakoh\")","legal function application obligation:pre_(put(p3)(aHashCode)14)","legal function application obligation:pre_(put(p3)aHashCode)","legal function application obligation:pre_(putp3)","legal function application obligation:pre_(kp1)","legal function application obligation:((k(p1) \u003d {1}) \u003d\u003e pre_(vp1))","legal function application obligation:((k(p1) \u003d {1}) \u003d\u003e ((v(p1) \u003d {\"Sahara\"}) \u003d\u003e pre_(kp2)))","legal function application obligation:((k(p1) \u003d {1}) \u003d\u003e ((v(p1) \u003d {\"Sahara\"}) \u003d\u003e ((k(p2) \u003d {1, 2}) \u003d\u003e pre_(vp2))))","legal function application obligation:((k(p1) \u003d {1}) \u003d\u003e ((v(p1) \u003d {\"Sahara\"}) \u003d\u003e ((k(p2) \u003d {1, 2}) \u003d\u003e ((v(p2) \u003d {\"Sahara\", \"Bush\"}) \u003d\u003e pre_(kp4)))))","legal function application obligation:((k(p1) \u003d {1}) \u003d\u003e ((v(p1) \u003d {\"Sahara\"}) \u003d\u003e ((k(p2) \u003d {1, 2}) \u003d\u003e ((v(p2) \u003d {\"Sahara\", \"Bush\"}) \u003d\u003e ((k(p4) \u003d {1, 2, 14}) \u003d\u003e pre_(vp4))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((Hashtable`PutAll)[int, seq of (char)]({|-\u003e})(aHashCode1){1 |-\u003e \"Shin Sahara\", 2 |-\u003e \"Kei Sato\", 14 |-\u003e \"Hiroshi Sakoh\", 27 |-\u003e \"Nishikawa\"})","legal function application obligation:pre_((Hashtable`PutAll)[int, seq of (char)]({|-\u003e})aHashCode1)","enumeration map injectivity obligation:(forall m1, m2 in set {{1 |-\u003e \"Shin Sahara\"}, {2 |-\u003e \"Kei Sato\"}, {14 |-\u003e \"Hiroshi Sakoh\"}, {27 |-\u003e \"Nishikawa\"}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","legal function application obligation:pre_((Hashtable`Remove)[int, seq of (char)](h1)(aHashCode1)14)","legal function application obligation:pre_((Hashtable`Remove)[int, seq of (char)](h1)aHashCode1)","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((Hashtable`PutAll)[int, seq of (char)]({|-\u003e})(aHashCode1){1 |-\u003e \"Shin Sahara\", 2 |-\u003e \"Kei Sato\", 14 |-\u003e \"Hiroshi Sakoh\"})","legal function application obligation:pre_((Hashtable`PutAll)[int, seq of (char)]({|-\u003e})aHashCode1)","enumeration map injectivity obligation:(forall m1, m2 in set {{1 |-\u003e \"Shin Sahara\"}, {2 |-\u003e \"Kei Sato\"}, {14 |-\u003e \"Hiroshi Sakoh\"}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","legal function application obligation:pre_(remove(h1)(aHashCode1)1)","legal function application obligation:pre_(remove(h1)aHashCode1)","legal function application obligation:pre_(removeh1)","legal function application obligation:pre_(remove(h2)(aHashCode1)2)","legal function application obligation:pre_(remove(h2)aHashCode1)","legal function application obligation:pre_(removeh2)","legal function application obligation:pre_(remove(h3)(aHashCode1)14)","legal function application obligation:pre_(remove(h3)aHashCode1)","legal function application obligation:pre_(removeh3)","legal function application obligation:pre_(isemptyh4)","legal function application obligation:(isempty(h4) \u003d\u003e pre_(sizeh4))","legal function application obligation:(isempty(h4) \u003d\u003e ((size(h4) \u003d 0) \u003d\u003e pre_(isemptyh3)))","legal function application obligation:(isempty(h4) \u003d\u003e ((size(h4) \u003d 0) \u003d\u003e ((isempty(h3) \u003d false) \u003d\u003e pre_(sizeh3))))","legal function application obligation:(isempty(h4) \u003d\u003e ((size(h4) \u003d 0) \u003d\u003e ((isempty(h3) \u003d false) \u003d\u003e ((size(h3) \u003d 1) \u003d\u003e pre_(sizeh2)))))","legal function application obligation:(isempty(h4) \u003d\u003e ((size(h4) \u003d 0) \u003d\u003e ((isempty(h3) \u003d false) \u003d\u003e ((size(h3) \u003d 1) \u003d\u003e ((size(h2) \u003d 2) \u003d\u003e pre_(sizeh1))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:(((t1.getDate)().EQ)(d1) \u003d\u003e pre_((t1.Time2IntProduct)(t1.getTime)()))","legal function application obligation:(((t1.getDate)().EQ)(d1) \u003d\u003e (((t1.Time2IntProduct)((t1.getTime)()) \u003d mk_(14, 29, 30, 20)) \u003d\u003e ((mk_((t1.hour)(), (t1.minute)(), (t1.second)()) \u003d mk_(14, 29, 30)) \u003d\u003e pre_((t2.Year)))))","legal function application obligation:(((t1.getDate)().EQ)(d1) \u003d\u003e (((t1.Time2IntProduct)((t1.getTime)()) \u003d mk_(14, 29, 30, 20)) \u003d\u003e ((mk_((t1.hour)(), (t1.minute)(), (t1.second)()) \u003d mk_(14, 29, 30)) \u003d\u003e pre_((t2.Month)))))","legal function application obligation:(((t1.getDate)().EQ)(d1) \u003d\u003e (((t1.Time2IntProduct)((t1.getTime)()) \u003d mk_(14, 29, 30, 20)) \u003d\u003e ((mk_((t1.hour)(), (t1.minute)(), (t1.second)()) \u003d mk_(14, 29, 30)) \u003d\u003e pre_((t2.day)))))","legal function application obligation:(((t1.getDate)().EQ)(d1) \u003d\u003e (((t1.Time2IntProduct)((t1.getTime)()) \u003d mk_(14, 29, 30, 20)) \u003d\u003e ((mk_((t1.hour)(), (t1.minute)(), (t1.second)()) \u003d mk_(14, 29, 30)) \u003d\u003e ((mk_((t2.Year)(), (t2.Month)(), (t2.day)()) \u003d mk_(2003, 8, 1)) \u003d\u003e pre_((t2.IntProduct2TimeMillieSeconds)0, 0, 0, 0)))))","legal function application obligation:(((t1.getDate)().EQ)(d1) \u003d\u003e (((t1.Time2IntProduct)((t1.getTime)()) \u003d mk_(14, 29, 30, 20)) \u003d\u003e ((mk_((t1.hour)(), (t1.minute)(), (t1.second)()) \u003d mk_(14, 29, 30)) \u003d\u003e ((mk_((t2.Year)(), (t2.Month)(), (t2.day)()) \u003d mk_(2003, 8, 1)) \u003d\u003e (((t2.getTime)() \u003d (t2.IntProduct2TimeMillieSeconds)(0, 0, 0, 0)) \u003d\u003e (((t3.getDate)().EQ)(d3) \u003d\u003e pre_((t2.IntProduct2TimeMillieSeconds)0, 0, 0, 0)))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((t1.LT)t2)","legal function application obligation:((t1.LT)(t2) \u003d\u003e pre_((t1.LT)t4))","legal function application obligation:((t1.LT)(t2) \u003d\u003e ((t1.LT)(t4) \u003d\u003e pre_((t1.LE)t2)))","legal function application obligation:((t1.LT)(t2) \u003d\u003e ((t1.LT)(t4) \u003d\u003e ((t1.LE)(t2) \u003d\u003e pre_((t1.LE)t4))))","legal function application obligation:((t1.LT)(t2) \u003d\u003e ((t1.LT)(t4) \u003d\u003e ((t1.LE)(t2) \u003d\u003e ((t1.LE)(t4) \u003d\u003e pre_((t2.GT)t1)))))","legal function application obligation:((t1.LT)(t2) \u003d\u003e ((t1.LT)(t4) \u003d\u003e ((t1.LE)(t2) \u003d\u003e ((t1.LE)(t4) \u003d\u003e ((t2.GT)(t1) \u003d\u003e pre_((t4.GT)t1))))))","legal function application obligation:((t1.LT)(t2) \u003d\u003e ((t1.LT)(t4) \u003d\u003e ((t1.LE)(t2) \u003d\u003e ((t1.LE)(t4) \u003d\u003e ((t2.GT)(t1) \u003d\u003e ((t4.GT)(t1) \u003d\u003e pre_((t2.GE)t1)))))))","legal function application obligation:((t1.LT)(t2) \u003d\u003e ((t1.LT)(t4) \u003d\u003e ((t1.LE)(t2) \u003d\u003e ((t1.LE)(t4) \u003d\u003e ((t2.GT)(t1) \u003d\u003e ((t4.GT)(t1) \u003d\u003e ((t2.GE)(t1) \u003d\u003e pre_((t4.GE)t1))))))))","legal function application obligation:((t1.LT)(t2) \u003d\u003e ((t1.LT)(t4) \u003d\u003e ((t1.LE)(t2) \u003d\u003e ((t1.LE)(t4) \u003d\u003e ((t2.GT)(t1) \u003d\u003e ((t4.GT)(t1) \u003d\u003e ((t2.GE)(t1) \u003d\u003e ((t4.GE)(t1) \u003d\u003e pre_((t4.EQ)t5)))))))))","legal function application obligation:((t1.LT)(t2) \u003d\u003e ((t1.LT)(t4) \u003d\u003e ((t1.LE)(t2) \u003d\u003e ((t1.LE)(t4) \u003d\u003e ((t2.GT)(t1) \u003d\u003e ((t4.GT)(t1) \u003d\u003e ((t2.GE)(t1) \u003d\u003e ((t4.GE)(t1) \u003d\u003e ((t4.EQ)(t5) \u003d\u003e pre_((t4.NE)t1))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:(((t1.minute)() \u003d 29) \u003d\u003e (((t1.second)() \u003d 50) \u003d\u003e (((t2.minute)() \u003d 30) \u003d\u003e (((t2.second)() \u003d 0) \u003d\u003e (((t3.minute)() \u003d 30) \u003d\u003e (((t3.second)() \u003d 20) \u003d\u003e (((t4.minute)() \u003d 31) \u003d\u003e (((t4.second)() \u003d 0) \u003d\u003e (((t5.hour)() \u003d 14) \u003d\u003e (((t5.minute)() \u003d 32) \u003d\u003e (((t5.second)() \u003d 0) \u003d\u003e (((t6.hour)() \u003d 15) \u003d\u003e (((t6.minute)() \u003d 29) \u003d\u003e (((t6.second)() \u003d 30) \u003d\u003e (((t7.hour)() \u003d 14) \u003d\u003e (((t7.minute)() \u003d 59) \u003d\u003e (((t8.hour)() \u003d 15) \u003d\u003e (((t8.minute)() \u003d 0) \u003d\u003e (((t9.hour)() \u003d 15) \u003d\u003e (((t9.minute)() \u003d 9) \u003d\u003e (((t10.hour)() \u003d 16) \u003d\u003e (((t10.minute)() \u003d 0) \u003d\u003e (((t10.second)() \u003d 30) \u003d\u003e pre_((t11.Year)))))))))))))))))))))))))","legal function application obligation:(((t1.minute)() \u003d 29) \u003d\u003e (((t1.second)() \u003d 50) \u003d\u003e (((t2.minute)() \u003d 30) \u003d\u003e (((t2.second)() \u003d 0) \u003d\u003e (((t3.minute)() \u003d 30) \u003d\u003e (((t3.second)() \u003d 20) \u003d\u003e (((t4.minute)() \u003d 31) \u003d\u003e (((t4.second)() \u003d 0) \u003d\u003e (((t5.hour)() \u003d 14) \u003d\u003e (((t5.minute)() \u003d 32) \u003d\u003e (((t5.second)() \u003d 0) \u003d\u003e (((t6.hour)() \u003d 15) \u003d\u003e (((t6.minute)() \u003d 29) \u003d\u003e (((t6.second)() \u003d 30) \u003d\u003e (((t7.hour)() \u003d 14) \u003d\u003e (((t7.minute)() \u003d 59) \u003d\u003e (((t8.hour)() \u003d 15) \u003d\u003e (((t8.minute)() \u003d 0) \u003d\u003e (((t9.hour)() \u003d 15) \u003d\u003e (((t9.minute)() \u003d 9) \u003d\u003e (((t10.hour)() \u003d 16) \u003d\u003e (((t10.minute)() \u003d 0) \u003d\u003e (((t10.second)() \u003d 30) \u003d\u003e (((t11.Year)() \u003d 2003) \u003d\u003e pre_((t11.Month))))))))))))))))))))))))))","legal function application obligation:(((t1.minute)() \u003d 29) \u003d\u003e (((t1.second)() \u003d 50) \u003d\u003e (((t2.minute)() \u003d 30) \u003d\u003e (((t2.second)() \u003d 0) \u003d\u003e (((t3.minute)() \u003d 30) \u003d\u003e (((t3.second)() \u003d 20) \u003d\u003e (((t4.minute)() \u003d 31) \u003d\u003e (((t4.second)() \u003d 0) \u003d\u003e (((t5.hour)() \u003d 14) \u003d\u003e (((t5.minute)() \u003d 32) \u003d\u003e (((t5.second)() \u003d 0) \u003d\u003e (((t6.hour)() \u003d 15) \u003d\u003e (((t6.minute)() \u003d 29) \u003d\u003e (((t6.second)() \u003d 30) \u003d\u003e (((t7.hour)() \u003d 14) \u003d\u003e (((t7.minute)() \u003d 59) \u003d\u003e (((t8.hour)() \u003d 15) \u003d\u003e (((t8.minute)() \u003d 0) \u003d\u003e (((t9.hour)() \u003d 15) \u003d\u003e (((t9.minute)() \u003d 9) \u003d\u003e (((t10.hour)() \u003d 16) \u003d\u003e (((t10.minute)() \u003d 0) \u003d\u003e (((t10.second)() \u003d 30) \u003d\u003e (((t11.Year)() \u003d 2003) \u003d\u003e (((t11.Month)() \u003d 7) \u003d\u003e pre_((t11.day)))))))))))))))))))))))))))","legal function application obligation:(((t1.minute)() \u003d 29) \u003d\u003e (((t1.second)() \u003d 50) \u003d\u003e (((t2.minute)() \u003d 30) \u003d\u003e (((t2.second)() \u003d 0) \u003d\u003e (((t3.minute)() \u003d 30) \u003d\u003e (((t3.second)() \u003d 20) \u003d\u003e (((t4.minute)() \u003d 31) \u003d\u003e (((t4.second)() \u003d 0) \u003d\u003e (((t5.hour)() \u003d 14) \u003d\u003e (((t5.minute)() \u003d 32) \u003d\u003e (((t5.second)() \u003d 0) \u003d\u003e (((t6.hour)() \u003d 15) \u003d\u003e (((t6.minute)() \u003d 29) \u003d\u003e (((t6.second)() \u003d 30) \u003d\u003e (((t7.hour)() \u003d 14) \u003d\u003e (((t7.minute)() \u003d 59) \u003d\u003e (((t8.hour)() \u003d 15) \u003d\u003e (((t8.minute)() \u003d 0) \u003d\u003e (((t9.hour)() \u003d 15) \u003d\u003e (((t9.minute)() \u003d 9) \u003d\u003e (((t10.hour)() \u003d 16) \u003d\u003e (((t10.minute)() \u003d 0) \u003d\u003e (((t10.second)() \u003d 30) \u003d\u003e (((t11.Year)() \u003d 2003) \u003d\u003e (((t11.Month)() \u003d 7) \u003d\u003e (((t11.day)() \u003d 31) \u003d\u003e (((t11.hour)() \u003d 14) \u003d\u003e (((t11.minute)() \u003d 29) \u003d\u003e (((t11.second)() \u003d 30) \u003d\u003e pre_((t12.Year)))))))))))))))))))))))))))))))","legal function application obligation:(((t1.minute)() \u003d 29) \u003d\u003e (((t1.second)() \u003d 50) \u003d\u003e (((t2.minute)() \u003d 30) \u003d\u003e (((t2.second)() \u003d 0) \u003d\u003e (((t3.minute)() \u003d 30) \u003d\u003e (((t3.second)() \u003d 20) \u003d\u003e (((t4.minute)() \u003d 31) \u003d\u003e (((t4.second)() \u003d 0) \u003d\u003e (((t5.hour)() \u003d 14) \u003d\u003e (((t5.minute)() \u003d 32) \u003d\u003e (((t5.second)() \u003d 0) \u003d\u003e (((t6.hour)() \u003d 15) \u003d\u003e (((t6.minute)() \u003d 29) \u003d\u003e (((t6.second)() \u003d 30) \u003d\u003e (((t7.hour)() \u003d 14) \u003d\u003e (((t7.minute)() \u003d 59) \u003d\u003e (((t8.hour)() \u003d 15) \u003d\u003e (((t8.minute)() \u003d 0) \u003d\u003e (((t9.hour)() \u003d 15) \u003d\u003e (((t9.minute)() \u003d 9) \u003d\u003e (((t10.hour)() \u003d 16) \u003d\u003e (((t10.minute)() \u003d 0) \u003d\u003e (((t10.second)() \u003d 30) \u003d\u003e (((t11.Year)() \u003d 2003) \u003d\u003e (((t11.Month)() \u003d 7) \u003d\u003e (((t11.day)() \u003d 31) \u003d\u003e (((t11.hour)() \u003d 14) \u003d\u003e (((t11.minute)() \u003d 29) \u003d\u003e (((t11.second)() \u003d 30) \u003d\u003e (((t12.Year)() \u003d 2003) \u003d\u003e pre_((t12.Month))))))))))))))))))))))))))))))))","legal function application obligation:(((t1.minute)() \u003d 29) \u003d\u003e (((t1.second)() \u003d 50) \u003d\u003e (((t2.minute)() \u003d 30) \u003d\u003e (((t2.second)() \u003d 0) \u003d\u003e (((t3.minute)() \u003d 30) \u003d\u003e (((t3.second)() \u003d 20) \u003d\u003e (((t4.minute)() \u003d 31) \u003d\u003e (((t4.second)() \u003d 0) \u003d\u003e (((t5.hour)() \u003d 14) \u003d\u003e (((t5.minute)() \u003d 32) \u003d\u003e (((t5.second)() \u003d 0) \u003d\u003e (((t6.hour)() \u003d 15) \u003d\u003e (((t6.minute)() \u003d 29) \u003d\u003e (((t6.second)() \u003d 30) \u003d\u003e (((t7.hour)() \u003d 14) \u003d\u003e (((t7.minute)() \u003d 59) \u003d\u003e (((t8.hour)() \u003d 15) \u003d\u003e (((t8.minute)() \u003d 0) \u003d\u003e (((t9.hour)() \u003d 15) \u003d\u003e (((t9.minute)() \u003d 9) \u003d\u003e (((t10.hour)() \u003d 16) \u003d\u003e (((t10.minute)() \u003d 0) \u003d\u003e (((t10.second)() \u003d 30) \u003d\u003e (((t11.Year)() \u003d 2003) \u003d\u003e (((t11.Month)() \u003d 7) \u003d\u003e (((t11.day)() \u003d 31) \u003d\u003e (((t11.hour)() \u003d 14) \u003d\u003e (((t11.minute)() \u003d 29) \u003d\u003e (((t11.second)() \u003d 30) \u003d\u003e (((t12.Year)() \u003d 2003) \u003d\u003e (((t12.Month)() \u003d 7) \u003d\u003e pre_((t12.day)))))))))))))))))))))))))))))))))","legal function application obligation:(((t1.minute)() \u003d 29) \u003d\u003e (((t1.second)() \u003d 50) \u003d\u003e (((t2.minute)() \u003d 30) \u003d\u003e (((t2.second)() \u003d 0) \u003d\u003e (((t3.minute)() \u003d 30) \u003d\u003e (((t3.second)() \u003d 20) \u003d\u003e (((t4.minute)() \u003d 31) \u003d\u003e (((t4.second)() \u003d 0) \u003d\u003e (((t5.hour)() \u003d 14) \u003d\u003e (((t5.minute)() \u003d 32) \u003d\u003e (((t5.second)() \u003d 0) \u003d\u003e (((t6.hour)() \u003d 15) \u003d\u003e (((t6.minute)() \u003d 29) \u003d\u003e (((t6.second)() \u003d 30) \u003d\u003e (((t7.hour)() \u003d 14) \u003d\u003e (((t7.minute)() \u003d 59) \u003d\u003e (((t8.hour)() \u003d 15) \u003d\u003e (((t8.minute)() \u003d 0) \u003d\u003e (((t9.hour)() \u003d 15) \u003d\u003e (((t9.minute)() \u003d 9) \u003d\u003e (((t10.hour)() \u003d 16) \u003d\u003e (((t10.minute)() \u003d 0) \u003d\u003e (((t10.second)() \u003d 30) \u003d\u003e (((t11.Year)() \u003d 2003) \u003d\u003e (((t11.Month)() \u003d 7) \u003d\u003e (((t11.day)() \u003d 31) \u003d\u003e (((t11.hour)() \u003d 14) \u003d\u003e (((t11.minute)() \u003d 29) \u003d\u003e (((t11.second)() \u003d 30) \u003d\u003e (((t12.Year)() \u003d 2003) \u003d\u003e (((t12.Month)() \u003d 7) \u003d\u003e (((t12.day)() \u003d 31) \u003d\u003e (((t12.hour)() \u003d 0) \u003d\u003e (((t12.minute)() \u003d 0) \u003d\u003e (((t12.second)() \u003d 0) \u003d\u003e (((t12.milliSecond)() \u003d 123) \u003d\u003e pre_((t13.Year))))))))))))))))))))))))))))))))))))))","legal function application obligation:(((t1.minute)() \u003d 29) \u003d\u003e (((t1.second)() \u003d 50) \u003d\u003e (((t2.minute)() \u003d 30) \u003d\u003e (((t2.second)() \u003d 0) \u003d\u003e (((t3.minute)() \u003d 30) \u003d\u003e (((t3.second)() \u003d 20) \u003d\u003e (((t4.minute)() \u003d 31) \u003d\u003e (((t4.second)() \u003d 0) \u003d\u003e (((t5.hour)() \u003d 14) \u003d\u003e (((t5.minute)() \u003d 32) \u003d\u003e (((t5.second)() \u003d 0) \u003d\u003e (((t6.hour)() \u003d 15) \u003d\u003e (((t6.minute)() \u003d 29) \u003d\u003e (((t6.second)() \u003d 30) \u003d\u003e (((t7.hour)() \u003d 14) \u003d\u003e (((t7.minute)() \u003d 59) \u003d\u003e (((t8.hour)() \u003d 15) \u003d\u003e (((t8.minute)() \u003d 0) \u003d\u003e (((t9.hour)() \u003d 15) \u003d\u003e (((t9.minute)() \u003d 9) \u003d\u003e (((t10.hour)() \u003d 16) \u003d\u003e (((t10.minute)() \u003d 0) \u003d\u003e (((t10.second)() \u003d 30) \u003d\u003e (((t11.Year)() \u003d 2003) \u003d\u003e (((t11.Month)() \u003d 7) \u003d\u003e (((t11.day)() \u003d 31) \u003d\u003e (((t11.hour)() \u003d 14) \u003d\u003e (((t11.minute)() \u003d 29) \u003d\u003e (((t11.second)() \u003d 30) \u003d\u003e (((t12.Year)() \u003d 2003) \u003d\u003e (((t12.Month)() \u003d 7) \u003d\u003e (((t12.day)() \u003d 31) \u003d\u003e (((t12.hour)() \u003d 0) \u003d\u003e (((t12.minute)() \u003d 0) \u003d\u003e (((t12.second)() \u003d 0) \u003d\u003e (((t12.milliSecond)() \u003d 123) \u003d\u003e (((t13.Year)() \u003d 2003) \u003d\u003e pre_((t13.Month)))))))))))))))))))))))))))))))))))))))","legal function application obligation:(((t1.minute)() \u003d 29) \u003d\u003e (((t1.second)() \u003d 50) \u003d\u003e (((t2.minute)() \u003d 30) \u003d\u003e (((t2.second)() \u003d 0) \u003d\u003e (((t3.minute)() \u003d 30) \u003d\u003e (((t3.second)() \u003d 20) \u003d\u003e (((t4.minute)() \u003d 31) \u003d\u003e (((t4.second)() \u003d 0) \u003d\u003e (((t5.hour)() \u003d 14) \u003d\u003e (((t5.minute)() \u003d 32) \u003d\u003e (((t5.second)() \u003d 0) \u003d\u003e (((t6.hour)() \u003d 15) \u003d\u003e (((t6.minute)() \u003d 29) \u003d\u003e (((t6.second)() \u003d 30) \u003d\u003e (((t7.hour)() \u003d 14) \u003d\u003e (((t7.minute)() \u003d 59) \u003d\u003e (((t8.hour)() \u003d 15) \u003d\u003e (((t8.minute)() \u003d 0) \u003d\u003e (((t9.hour)() \u003d 15) \u003d\u003e (((t9.minute)() \u003d 9) \u003d\u003e (((t10.hour)() \u003d 16) \u003d\u003e (((t10.minute)() \u003d 0) \u003d\u003e (((t10.second)() \u003d 30) \u003d\u003e (((t11.Year)() \u003d 2003) \u003d\u003e (((t11.Month)() \u003d 7) \u003d\u003e (((t11.day)() \u003d 31) \u003d\u003e (((t11.hour)() \u003d 14) \u003d\u003e (((t11.minute)() \u003d 29) \u003d\u003e (((t11.second)() \u003d 30) \u003d\u003e (((t12.Year)() \u003d 2003) \u003d\u003e (((t12.Month)() \u003d 7) \u003d\u003e (((t12.day)() \u003d 31) \u003d\u003e (((t12.hour)() \u003d 0) \u003d\u003e (((t12.minute)() \u003d 0) \u003d\u003e (((t12.second)() \u003d 0) \u003d\u003e (((t12.milliSecond)() \u003d 123) \u003d\u003e (((t13.Year)() \u003d 2003) \u003d\u003e (((t13.Month)() \u003d 8) \u003d\u003e pre_((t13.day))))))))))))))))))))))))))))))))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((t1.Time2IntProduct)(t1.getTime)())","legal function application obligation:(((t1.Time2IntProduct)((t1.getTime)()) \u003d mk_(23, 59, 0, 0)) \u003d\u003e pre_(((t1.getDate)().date2Str)))","legal function application obligation:(((t1.Time2IntProduct)((t1.getTime)()) \u003d mk_(23, 59, 0, 0)) \u003d\u003e ((((t1.getDate)().date2Str)() \u003d \"20030729\") \u003d\u003e pre_((t2.Time2IntProduct)(t2.getTime)())))","legal function application obligation:(((t1.Time2IntProduct)((t1.getTime)()) \u003d mk_(23, 59, 0, 0)) \u003d\u003e ((((t1.getDate)().date2Str)() \u003d \"20030729\") \u003d\u003e (((t2.Time2IntProduct)((t2.getTime)()) \u003d mk_(23, 59, 0, 0)) \u003d\u003e pre_(((t2.getDate)().date2Str)))))","legal function application obligation:(((t1.Time2IntProduct)((t1.getTime)()) \u003d mk_(23, 59, 0, 0)) \u003d\u003e ((((t1.getDate)().date2Str)() \u003d \"20030729\") \u003d\u003e (((t2.Time2IntProduct)((t2.getTime)()) \u003d mk_(23, 59, 0, 0)) \u003d\u003e ((((t2.getDate)().date2Str)() \u003d \"20030728\") \u003d\u003e pre_((t3.Time2IntProduct)(t3.getTime)())))))","legal function application obligation:(((t1.Time2IntProduct)((t1.getTime)()) \u003d mk_(23, 59, 0, 0)) \u003d\u003e ((((t1.getDate)().date2Str)() \u003d \"20030729\") \u003d\u003e (((t2.Time2IntProduct)((t2.getTime)()) \u003d mk_(23, 59, 0, 0)) \u003d\u003e ((((t2.getDate)().date2Str)() \u003d \"20030728\") \u003d\u003e (((t3.Time2IntProduct)((t3.getTime)()) \u003d mk_(23, 59, 0, 0)) \u003d\u003e pre_(((t3.getDate)().date2Str)))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((t1.Time2IntProduct)(t1.getTime)())","legal function application obligation:(((t1.Time2IntProduct)((t1.getTime)()) \u003d mk_(15, 29, 30, 0)) \u003d\u003e pre_((t2.Time2IntProduct)(t2.getTime)()))","legal function application obligation:(((t1.Time2IntProduct)((t1.getTime)()) \u003d mk_(15, 29, 30, 0)) \u003d\u003e (((t2.Time2IntProduct)((t2.getTime)()) \u003d mk_(14, 19, 30, 0)) \u003d\u003e pre_((t3.Time2IntProduct)(t3.getTime)())))","legal function application obligation:(((t1.Time2IntProduct)((t1.getTime)()) \u003d mk_(15, 29, 30, 0)) \u003d\u003e (((t2.Time2IntProduct)((t2.getTime)()) \u003d mk_(14, 19, 30, 0)) \u003d\u003e (((t3.Time2IntProduct)((t3.getTime)()) \u003d mk_(14, 29, 47, 0)) \u003d\u003e pre_((t4.Time2IntProduct)(t4.getTime)()))))","legal function application obligation:(((t1.Time2IntProduct)((t1.getTime)()) \u003d mk_(15, 29, 30, 0)) \u003d\u003e (((t2.Time2IntProduct)((t2.getTime)()) \u003d mk_(14, 19, 30, 0)) \u003d\u003e (((t3.Time2IntProduct)((t3.getTime)()) \u003d mk_(14, 29, 47, 0)) \u003d\u003e (((t4.Time2IntProduct)((t4.getTime)()) \u003d mk_(14, 29, 30, 789)) \u003d\u003e pre_(((t4.getDate)().date2Str))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((new Time(cal).EQ)new Time(cal, 2001, 3, 1, 10, 11, 23, 456))","legal function application obligation:((new Time(cal).EQ)(new Time(cal, 2001, 3, 1, 10, 11, 23, 456)) \u003d\u003e pre_((new Time((homedir ^ \"/temp/BaseDay.txt\"), (homedir ^ \"/temp/Now2.txt\"), cal).EQ)new Time(cal, 2003, 10, 24, 12, 34, 56, 789)))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:((((jc.getDateFrom_yyyy_mm_dd)(2003, 3, 0).asString)() \u003d \"20030228\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2003, 2, 29).asString)() \u003d \"20030301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 0).asString)() \u003d \"20040229\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 30).asString)() \u003d \"20040301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 60).asString)() \u003d \"20040229\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 61).asString)() \u003d \"20040301\") \u003d\u003e pre_(((jc.getDateFrom_yyyy_mm_dd)(2001, 5, 1).get_yyyy_mm_dd))))))))","legal function application obligation:((((jc.getDateFrom_yyyy_mm_dd)(2003, 3, 0).asString)() \u003d \"20030228\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2003, 2, 29).asString)() \u003d \"20030301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 0).asString)() \u003d \"20040229\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 30).asString)() \u003d \"20040301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 60).asString)() \u003d \"20040229\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 61).asString)() \u003d \"20040301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2001, 5, 1).get_yyyy_mm_dd)() \u003d mk_(2001, 5, 1)) \u003d\u003e pre_((jc.getYyyymmdd)(jc.today)()))))))))","legal function application obligation:((((jc.getDateFrom_yyyy_mm_dd)(2003, 3, 0).asString)() \u003d \"20030228\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2003, 2, 29).asString)() \u003d \"20030301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 0).asString)() \u003d \"20040229\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 30).asString)() \u003d \"20040301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 60).asString)() \u003d \"20040229\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 61).asString)() \u003d \"20040301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2001, 5, 1).get_yyyy_mm_dd)() \u003d mk_(2001, 5, 1)) \u003d\u003e (((jc.getYyyymmdd)((jc.today)()) \u003d mk_(2001, 9, 12)) \u003d\u003e pre_(((jc.modifiedJulianDate2Date)((jc.julianDate2ModifiedJulianDate)(2299160)).get_yyyy_mm_dd))))))))))","legal function application obligation:((((jc.getDateFrom_yyyy_mm_dd)(2003, 3, 0).asString)() \u003d \"20030228\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2003, 2, 29).asString)() \u003d \"20030301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 0).asString)() \u003d \"20040229\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 30).asString)() \u003d \"20040301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 60).asString)() \u003d \"20040229\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 61).asString)() \u003d \"20040301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2001, 5, 1).get_yyyy_mm_dd)() \u003d mk_(2001, 5, 1)) \u003d\u003e (((jc.getYyyymmdd)((jc.today)()) \u003d mk_(2001, 9, 12)) \u003d\u003e pre_((jc.julianDate2ModifiedJulianDate)2299160)))))))))","legal function application obligation:((((jc.getDateFrom_yyyy_mm_dd)(2003, 3, 0).asString)() \u003d \"20030228\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2003, 2, 29).asString)() \u003d \"20030301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 0).asString)() \u003d \"20040229\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 30).asString)() \u003d \"20040301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 60).asString)() \u003d \"20040229\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 61).asString)() \u003d \"20040301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2001, 5, 1).get_yyyy_mm_dd)() \u003d mk_(2001, 5, 1)) \u003d\u003e (((jc.getYyyymmdd)((jc.today)()) \u003d mk_(2001, 9, 12)) \u003d\u003e ((((jc.modifiedJulianDate2Date)((jc.julianDate2ModifiedJulianDate)(2299160)).get_yyyy_mm_dd)() \u003d mk_(1582, 10, 4)) \u003d\u003e pre_((((jc.modifiedJulianDate2Date)((jc.julianDate2ModifiedJulianDate)(2299160)).plus)(1).get_yyyy_mm_dd)))))))))))","legal function application obligation:((((jc.getDateFrom_yyyy_mm_dd)(2003, 3, 0).asString)() \u003d \"20030228\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2003, 2, 29).asString)() \u003d \"20030301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 0).asString)() \u003d \"20040229\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 30).asString)() \u003d \"20040301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 60).asString)() \u003d \"20040229\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 61).asString)() \u003d \"20040301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2001, 5, 1).get_yyyy_mm_dd)() \u003d mk_(2001, 5, 1)) \u003d\u003e (((jc.getYyyymmdd)((jc.today)()) \u003d mk_(2001, 9, 12)) \u003d\u003e ((((jc.modifiedJulianDate2Date)((jc.julianDate2ModifiedJulianDate)(2299160)).get_yyyy_mm_dd)() \u003d mk_(1582, 10, 4)) \u003d\u003e pre_((jc.julianDate2ModifiedJulianDate)2299160))))))))))","legal function application obligation:((((jc.getDateFrom_yyyy_mm_dd)(2003, 3, 0).asString)() \u003d \"20030228\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2003, 2, 29).asString)() \u003d \"20030301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 0).asString)() \u003d \"20040229\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 30).asString)() \u003d \"20040301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 60).asString)() \u003d \"20040229\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 61).asString)() \u003d \"20040301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2001, 5, 1).get_yyyy_mm_dd)() \u003d mk_(2001, 5, 1)) \u003d\u003e (((jc.getYyyymmdd)((jc.today)()) \u003d mk_(2001, 9, 12)) \u003d\u003e ((((jc.modifiedJulianDate2Date)((jc.julianDate2ModifiedJulianDate)(2299160)).get_yyyy_mm_dd)() \u003d mk_(1582, 10, 4)) \u003d\u003e (((((jc.modifiedJulianDate2Date)((jc.julianDate2ModifiedJulianDate)(2299160)).plus)(1).get_yyyy_mm_dd)() \u003d mk_(1582, 10, 15)) \u003d\u003e pre_((jc.date2Str)(jc.getDateFromString)(\"20010711\"))))))))))))","type compatibility obligation:((((jc.getDateFrom_yyyy_mm_dd)(2003, 3, 0).asString)() \u003d \"20030228\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2003, 2, 29).asString)() \u003d \"20030301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 0).asString)() \u003d \"20040229\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 30).asString)() \u003d \"20040301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 60).asString)() \u003d \"20040229\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 61).asString)() \u003d \"20040301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2001, 5, 1).get_yyyy_mm_dd)() \u003d mk_(2001, 5, 1)) \u003d\u003e (((jc.getYyyymmdd)((jc.today)()) \u003d mk_(2001, 9, 12)) \u003d\u003e ((((jc.modifiedJulianDate2Date)((jc.julianDate2ModifiedJulianDate)(2299160)).get_yyyy_mm_dd)() \u003d mk_(1582, 10, 4)) \u003d\u003e (((((jc.modifiedJulianDate2Date)((jc.julianDate2ModifiedJulianDate)(2299160)).plus)(1).get_yyyy_mm_dd)() \u003d mk_(1582, 10, 15)) \u003d\u003e is_((jc.getDateFromString)(\"20010711\"), Date)))))))))))","legal function application obligation:((((jc.getDateFrom_yyyy_mm_dd)(2003, 3, 0).asString)() \u003d \"20030228\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2003, 2, 29).asString)() \u003d \"20030301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 0).asString)() \u003d \"20040229\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 30).asString)() \u003d \"20040301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 60).asString)() \u003d \"20040229\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 61).asString)() \u003d \"20040301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2001, 5, 1).get_yyyy_mm_dd)() \u003d mk_(2001, 5, 1)) \u003d\u003e (((jc.getYyyymmdd)((jc.today)()) \u003d mk_(2001, 9, 12)) \u003d\u003e ((((jc.modifiedJulianDate2Date)((jc.julianDate2ModifiedJulianDate)(2299160)).get_yyyy_mm_dd)() \u003d mk_(1582, 10, 4)) \u003d\u003e (((((jc.modifiedJulianDate2Date)((jc.julianDate2ModifiedJulianDate)(2299160)).plus)(1).get_yyyy_mm_dd)() \u003d mk_(1582, 10, 15)) \u003d\u003e (((jc.date2Str)((jc.getDateFromString)(\"20010711\")) \u003d \"20010711\") \u003d\u003e pre_((jc.convertDateFromString)\"saharashin\"))))))))))))","legal function application obligation:((((jc.getDateFrom_yyyy_mm_dd)(2003, 3, 0).asString)() \u003d \"20030228\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2003, 2, 29).asString)() \u003d \"20030301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 0).asString)() \u003d \"20040229\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 30).asString)() \u003d \"20040301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 60).asString)() \u003d \"20040229\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 61).asString)() \u003d \"20040301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2001, 5, 1).get_yyyy_mm_dd)() \u003d mk_(2001, 5, 1)) \u003d\u003e (((jc.getYyyymmdd)((jc.today)()) \u003d mk_(2001, 9, 12)) \u003d\u003e ((((jc.modifiedJulianDate2Date)((jc.julianDate2ModifiedJulianDate)(2299160)).get_yyyy_mm_dd)() \u003d mk_(1582, 10, 4)) \u003d\u003e (((((jc.modifiedJulianDate2Date)((jc.julianDate2ModifiedJulianDate)(2299160)).plus)(1).get_yyyy_mm_dd)() \u003d mk_(1582, 10, 15)) \u003d\u003e (((jc.date2Str)((jc.getDateFromString)(\"20010711\")) \u003d \"20010711\") \u003d\u003e (((jc.convertDateFromString)(\"saharashin\") \u003d nil) \u003d\u003e pre_getJapaneseDateStr((jc.getDateFrom_yyyy_mm_dd)(2001, 5, 1))))))))))))))","legal function application obligation:((((jc.getDateFrom_yyyy_mm_dd)(2003, 3, 0).asString)() \u003d \"20030228\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2003, 2, 29).asString)() \u003d \"20030301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 0).asString)() \u003d \"20040229\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 30).asString)() \u003d \"20040301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 60).asString)() \u003d \"20040229\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 61).asString)() \u003d \"20040301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2001, 5, 1).get_yyyy_mm_dd)() \u003d mk_(2001, 5, 1)) \u003d\u003e (((jc.getYyyymmdd)((jc.today)()) \u003d mk_(2001, 9, 12)) \u003d\u003e ((((jc.modifiedJulianDate2Date)((jc.julianDate2ModifiedJulianDate)(2299160)).get_yyyy_mm_dd)() \u003d mk_(1582, 10, 4)) \u003d\u003e (((((jc.modifiedJulianDate2Date)((jc.julianDate2ModifiedJulianDate)(2299160)).plus)(1).get_yyyy_mm_dd)() \u003d mk_(1582, 10, 15)) \u003d\u003e (((jc.date2Str)((jc.getDateFromString)(\"20010711\")) \u003d \"20010711\") \u003d\u003e (((jc.convertDateFromString)(\"saharashin\") \u003d nil) \u003d\u003e ((JapaneseCalendar`getJapaneseDateStr((jc.getDateFrom_yyyy_mm_dd)(2001, 5, 1)) \u003d \"13 5 1\") \u003d\u003e pre_((jc.getAutumnalEquinox)2001))))))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(((jc.dateAdding)((jc.getDateFrom_yyyy_mm_dd)(2001, 5, 1), 3).date2Str))","legal function application obligation:pre_((jc.dateAdding)(jc.getDateFrom_yyyy_mm_dd)(2001, 5, 1), 3)","legal function application obligation:((((jc.dateAdding)((jc.getDateFrom_yyyy_mm_dd)(2001, 5, 1), 3).date2Str)() \u003d \"20010504\") \u003d\u003e pre_((jc.diffOfDates)(jc.getDateFrom_yyyy_mm_dd)(2001, 5, 8), (jc.getDateFrom_yyyy_mm_dd)(2001, 5, 1)))","legal function application obligation:((((jc.dateAdding)((jc.getDateFrom_yyyy_mm_dd)(2001, 5, 1), 3).date2Str)() \u003d \"20010504\") \u003d\u003e (((jc.diffOfDates)((jc.getDateFrom_yyyy_mm_dd)(2001, 5, 8), (jc.getDateFrom_yyyy_mm_dd)(2001, 5, 1)) \u003d 7) \u003d\u003e pre_(((jc.dateSubtracting)((jc.getDateFrom_yyyy_mm_dd)(2001, 5, 1), 1).get_yyyy_mm_dd))))","legal function application obligation:((((jc.dateAdding)((jc.getDateFrom_yyyy_mm_dd)(2001, 5, 1), 3).date2Str)() \u003d \"20010504\") \u003d\u003e (((jc.diffOfDates)((jc.getDateFrom_yyyy_mm_dd)(2001, 5, 8), (jc.getDateFrom_yyyy_mm_dd)(2001, 5, 1)) \u003d 7) \u003d\u003e pre_((jc.dateSubtracting)(jc.getDateFrom_yyyy_mm_dd)(2001, 5, 1), 1)))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(((jc.getVernalEquinox)(2001).date2Str))","legal function application obligation:pre_((jc.getVernalEquinox)2001)","legal function application obligation:((((jc.getVernalEquinox)(2001).date2Str)() \u003d \"20010320\") \u003d\u003e pre_(((jc.getSummerSolstice)(2001).date2Str)))","legal function application obligation:((((jc.getVernalEquinox)(2001).date2Str)() \u003d \"20010320\") \u003d\u003e pre_((jc.getSummerSolstice)2001))","legal function application obligation:((((jc.getVernalEquinox)(2001).date2Str)() \u003d \"20010320\") \u003d\u003e ((((jc.getSummerSolstice)(2001).date2Str)() \u003d \"20010621\") \u003d\u003e pre_(((jc.getAutumnalEquinox)(2001).date2Str))))","legal function application obligation:((((jc.getVernalEquinox)(2001).date2Str)() \u003d \"20010320\") \u003d\u003e ((((jc.getSummerSolstice)(2001).date2Str)() \u003d \"20010621\") \u003d\u003e pre_((jc.getAutumnalEquinox)2001)))","legal function application obligation:((((jc.getVernalEquinox)(2001).date2Str)() \u003d \"20010320\") \u003d\u003e ((((jc.getSummerSolstice)(2001).date2Str)() \u003d \"20010621\") \u003d\u003e ((((jc.getAutumnalEquinox)(2001).date2Str)() \u003d \"20010923\") \u003d\u003e pre_(((jc.getWinterSolstice)(2001).date2Str)))))","legal function application obligation:((((jc.getVernalEquinox)(2001).date2Str)() \u003d \"20010320\") \u003d\u003e ((((jc.getSummerSolstice)(2001).date2Str)() \u003d \"20010621\") \u003d\u003e ((((jc.getAutumnalEquinox)(2001).date2Str)() \u003d \"20010923\") \u003d\u003e pre_((jc.getWinterSolstice)2001))))","legal function application obligation:((((jc.getVernalEquinox)(2001).date2Str)() \u003d \"20010320\") \u003d\u003e ((((jc.getSummerSolstice)(2001).date2Str)() \u003d \"20010621\") \u003d\u003e ((((jc.getAutumnalEquinox)(2001).date2Str)() \u003d \"20010923\") \u003d\u003e ((((jc.getWinterSolstice)(2001).date2Str)() \u003d \"20011222\") \u003d\u003e pre_(((jc.getVernalEquinox)(2999).date2Str))))))","legal function application obligation:((((jc.getVernalEquinox)(2001).date2Str)() \u003d \"20010320\") \u003d\u003e ((((jc.getSummerSolstice)(2001).date2Str)() \u003d \"20010621\") \u003d\u003e ((((jc.getAutumnalEquinox)(2001).date2Str)() \u003d \"20010923\") \u003d\u003e ((((jc.getWinterSolstice)(2001).date2Str)() \u003d \"20011222\") \u003d\u003e pre_((jc.getVernalEquinox)2999)))))","legal function application obligation:((((jc.getVernalEquinox)(2001).date2Str)() \u003d \"20010320\") \u003d\u003e ((((jc.getSummerSolstice)(2001).date2Str)() \u003d \"20010621\") \u003d\u003e ((((jc.getAutumnalEquinox)(2001).date2Str)() \u003d \"20010923\") \u003d\u003e ((((jc.getWinterSolstice)(2001).date2Str)() \u003d \"20011222\") \u003d\u003e ((((jc.getVernalEquinox)(2999).date2Str)() \u003d \"29990320\") \u003d\u003e pre_(((jc.getSummerSolstice)(2999).date2Str)))))))","legal function application obligation:((((jc.getVernalEquinox)(2001).date2Str)() \u003d \"20010320\") \u003d\u003e ((((jc.getSummerSolstice)(2001).date2Str)() \u003d \"20010621\") \u003d\u003e ((((jc.getAutumnalEquinox)(2001).date2Str)() \u003d \"20010923\") \u003d\u003e ((((jc.getWinterSolstice)(2001).date2Str)() \u003d \"20011222\") \u003d\u003e ((((jc.getVernalEquinox)(2999).date2Str)() \u003d \"29990320\") \u003d\u003e pre_((jc.getSummerSolstice)2999))))))","legal function application obligation:((((jc.getVernalEquinox)(2001).date2Str)() \u003d \"20010320\") \u003d\u003e ((((jc.getSummerSolstice)(2001).date2Str)() \u003d \"20010621\") \u003d\u003e ((((jc.getAutumnalEquinox)(2001).date2Str)() \u003d \"20010923\") \u003d\u003e ((((jc.getWinterSolstice)(2001).date2Str)() \u003d \"20011222\") \u003d\u003e ((((jc.getVernalEquinox)(2999).date2Str)() \u003d \"29990320\") \u003d\u003e ((((jc.getSummerSolstice)(2999).date2Str)() \u003d \"29990620\") \u003d\u003e pre_(((jc.getAutumnalEquinox)(2999).date2Str))))))))","legal function application obligation:((((jc.getVernalEquinox)(2001).date2Str)() \u003d \"20010320\") \u003d\u003e ((((jc.getSummerSolstice)(2001).date2Str)() \u003d \"20010621\") \u003d\u003e ((((jc.getAutumnalEquinox)(2001).date2Str)() \u003d \"20010923\") \u003d\u003e ((((jc.getWinterSolstice)(2001).date2Str)() \u003d \"20011222\") \u003d\u003e ((((jc.getVernalEquinox)(2999).date2Str)() \u003d \"29990320\") \u003d\u003e ((((jc.getSummerSolstice)(2999).date2Str)() \u003d \"29990620\") \u003d\u003e pre_((jc.getAutumnalEquinox)2999)))))))","legal function application obligation:((((jc.getVernalEquinox)(2001).date2Str)() \u003d \"20010320\") \u003d\u003e ((((jc.getSummerSolstice)(2001).date2Str)() \u003d \"20010621\") \u003d\u003e ((((jc.getAutumnalEquinox)(2001).date2Str)() \u003d \"20010923\") \u003d\u003e ((((jc.getWinterSolstice)(2001).date2Str)() \u003d \"20011222\") \u003d\u003e ((((jc.getVernalEquinox)(2999).date2Str)() \u003d \"29990320\") \u003d\u003e ((((jc.getSummerSolstice)(2999).date2Str)() \u003d \"29990620\") \u003d\u003e ((((jc.getAutumnalEquinox)(2999).date2Str)() \u003d \"29990922\") \u003d\u003e pre_(((jc.getWinterSolstice)(2999).date2Str)))))))))","legal function application obligation:((((jc.getVernalEquinox)(2001).date2Str)() \u003d \"20010320\") \u003d\u003e ((((jc.getSummerSolstice)(2001).date2Str)() \u003d \"20010621\") \u003d\u003e ((((jc.getAutumnalEquinox)(2001).date2Str)() \u003d \"20010923\") \u003d\u003e ((((jc.getWinterSolstice)(2001).date2Str)() \u003d \"20011222\") \u003d\u003e ((((jc.getVernalEquinox)(2999).date2Str)() \u003d \"29990320\") \u003d\u003e ((((jc.getSummerSolstice)(2999).date2Str)() \u003d \"29990620\") \u003d\u003e ((((jc.getAutumnalEquinox)(2999).date2Str)() \u003d \"29990922\") \u003d\u003e pre_((jc.getWinterSolstice)2999))))))))","legal function application obligation:((((jc.getVernalEquinox)(2001).date2Str)() \u003d \"20010320\") \u003d\u003e ((((jc.getSummerSolstice)(2001).date2Str)() \u003d \"20010621\") \u003d\u003e ((((jc.getAutumnalEquinox)(2001).date2Str)() \u003d \"20010923\") \u003d\u003e ((((jc.getWinterSolstice)(2001).date2Str)() \u003d \"20011222\") \u003d\u003e ((((jc.getVernalEquinox)(2999).date2Str)() \u003d \"29990320\") \u003d\u003e ((((jc.getSummerSolstice)(2999).date2Str)() \u003d \"29990620\") \u003d\u003e ((((jc.getAutumnalEquinox)(2999).date2Str)() \u003d \"29990922\") \u003d\u003e ((((jc.getWinterSolstice)(2999).date2Str)() \u003d \"29991222\") \u003d\u003e pre_(((jc.getWinterSolstice)(2007).date2Str))))))))))","legal function application obligation:((((jc.getVernalEquinox)(2001).date2Str)() \u003d \"20010320\") \u003d\u003e ((((jc.getSummerSolstice)(2001).date2Str)() \u003d \"20010621\") \u003d\u003e ((((jc.getAutumnalEquinox)(2001).date2Str)() \u003d \"20010923\") \u003d\u003e ((((jc.getWinterSolstice)(2001).date2Str)() \u003d \"20011222\") \u003d\u003e ((((jc.getVernalEquinox)(2999).date2Str)() \u003d \"29990320\") \u003d\u003e ((((jc.getSummerSolstice)(2999).date2Str)() \u003d \"29990620\") \u003d\u003e ((((jc.getAutumnalEquinox)(2999).date2Str)() \u003d \"29990922\") \u003d\u003e ((((jc.getWinterSolstice)(2999).date2Str)() \u003d \"29991222\") \u003d\u003e pre_((jc.getWinterSolstice)2007)))))))))","legal function application obligation:((((jc.getVernalEquinox)(2001).date2Str)() \u003d \"20010320\") \u003d\u003e ((((jc.getSummerSolstice)(2001).date2Str)() \u003d \"20010621\") \u003d\u003e ((((jc.getAutumnalEquinox)(2001).date2Str)() \u003d \"20010923\") \u003d\u003e ((((jc.getWinterSolstice)(2001).date2Str)() \u003d \"20011222\") \u003d\u003e ((((jc.getVernalEquinox)(2999).date2Str)() \u003d \"29990320\") \u003d\u003e ((((jc.getSummerSolstice)(2999).date2Str)() \u003d \"29990620\") \u003d\u003e ((((jc.getAutumnalEquinox)(2999).date2Str)() \u003d \"29990922\") \u003d\u003e ((((jc.getWinterSolstice)(2999).date2Str)() \u003d \"29991222\") \u003d\u003e ((((jc.getWinterSolstice)(2007).date2Str)() \u003d \"20071222\") \u003d\u003e pre_(((jc.getWinterSolstice)(2012).date2Str)))))))))))","legal function application obligation:((((jc.getVernalEquinox)(2001).date2Str)() \u003d \"20010320\") \u003d\u003e ((((jc.getSummerSolstice)(2001).date2Str)() \u003d \"20010621\") \u003d\u003e ((((jc.getAutumnalEquinox)(2001).date2Str)() \u003d \"20010923\") \u003d\u003e ((((jc.getWinterSolstice)(2001).date2Str)() \u003d \"20011222\") \u003d\u003e ((((jc.getVernalEquinox)(2999).date2Str)() \u003d \"29990320\") \u003d\u003e ((((jc.getSummerSolstice)(2999).date2Str)() \u003d \"29990620\") \u003d\u003e ((((jc.getAutumnalEquinox)(2999).date2Str)() \u003d \"29990922\") \u003d\u003e ((((jc.getWinterSolstice)(2999).date2Str)() \u003d \"29991222\") \u003d\u003e ((((jc.getWinterSolstice)(2007).date2Str)() \u003d \"20071222\") \u003d\u003e pre_((jc.getWinterSolstice)2012))))))))))","legal function application obligation:((((jc.getVernalEquinox)(2001).date2Str)() \u003d \"20010320\") \u003d\u003e ((((jc.getSummerSolstice)(2001).date2Str)() \u003d \"20010621\") \u003d\u003e ((((jc.getAutumnalEquinox)(2001).date2Str)() \u003d \"20010923\") \u003d\u003e ((((jc.getWinterSolstice)(2001).date2Str)() \u003d \"20011222\") \u003d\u003e ((((jc.getVernalEquinox)(2999).date2Str)() \u003d \"29990320\") \u003d\u003e ((((jc.getSummerSolstice)(2999).date2Str)() \u003d \"29990620\") \u003d\u003e ((((jc.getAutumnalEquinox)(2999).date2Str)() \u003d \"29990922\") \u003d\u003e ((((jc.getWinterSolstice)(2999).date2Str)() \u003d \"29991222\") \u003d\u003e ((((jc.getWinterSolstice)(2007).date2Str)() \u003d \"20071222\") \u003d\u003e ((((jc.getWinterSolstice)(2012).date2Str)() \u003d \"20121221\") \u003d\u003e pre_(((jc.getWinterSolstice)(2016).date2Str))))))))))))","legal function application obligation:((((jc.getVernalEquinox)(2001).date2Str)() \u003d \"20010320\") \u003d\u003e ((((jc.getSummerSolstice)(2001).date2Str)() \u003d \"20010621\") \u003d\u003e ((((jc.getAutumnalEquinox)(2001).date2Str)() \u003d \"20010923\") \u003d\u003e ((((jc.getWinterSolstice)(2001).date2Str)() \u003d \"20011222\") \u003d\u003e ((((jc.getVernalEquinox)(2999).date2Str)() \u003d \"29990320\") \u003d\u003e ((((jc.getSummerSolstice)(2999).date2Str)() \u003d \"29990620\") \u003d\u003e ((((jc.getAutumnalEquinox)(2999).date2Str)() \u003d \"29990922\") \u003d\u003e ((((jc.getWinterSolstice)(2999).date2Str)() \u003d \"29991222\") \u003d\u003e ((((jc.getWinterSolstice)(2007).date2Str)() \u003d \"20071222\") \u003d\u003e ((((jc.getWinterSolstice)(2012).date2Str)() \u003d \"20121221\") \u003d\u003e pre_((jc.getWinterSolstice)2016)))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:(forall dayOff in set setOfDayOff \u0026 pre_((jc.getYyyymmdd)dayOff))","legal function application obligation:(forall dayOff in set setOfDayOff2003 \u0026 pre_((jc.getYyyymmdd)dayOff))","legal function application obligation:(forall dayOff in set setOfDayOffIn2009 \u0026 pre_((jc.getYyyymmdd)dayOff))","legal function application obligation:((setOfDayOffBy_yyyy_mm_dd \u003d {mk_(2001, 1, 1), mk_(2001, 1, 8), mk_(2001, 2, 11), mk_(2001, 2, 12), mk_(2001, 3, 20), mk_(2001, 4, 29), mk_(2001, 4, 30), mk_(2001, 5, 3), mk_(2001, 5, 4), mk_(2001, 5, 5), mk_(2001, 7, 20), mk_(2001, 9, 15), mk_(2001, 9, 23), mk_(2001, 9, 24), mk_(2001, 10, 8), mk_(2001, 11, 3), mk_(2001, 11, 23), mk_(2001, 12, 23), mk_(2001, 12, 24)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_dd2003 \u003d {mk_(2003, 1, 1), mk_(2003, 1, 13), mk_(2003, 2, 11), mk_(2003, 3, 21), mk_(2003, 4, 29), mk_(2003, 5, 3), mk_(2003, 5, 4), mk_(2003, 5, 5), mk_(2003, 7, 21), mk_(2003, 9, 15), mk_(2003, 9, 23), mk_(2003, 10, 13), mk_(2003, 11, 3), mk_(2003, 11, 23), mk_(2003, 11, 24), mk_(2003, 12, 23)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_ddIn2009 \u003d {mk_(2009, 1, 1), mk_(2009, 1, 12), mk_(2009, 2, 11), mk_(2009, 3, 20), mk_(2009, 4, 29), mk_(2009, 5, 3), mk_(2009, 5, 4), mk_(2009, 5, 5), mk_(2009, 5, 6), mk_(2009, 7, 20), mk_(2009, 9, 21), mk_(2009, 9, 22), mk_(2009, 9, 23), mk_(2009, 10, 12), mk_(2009, 11, 3), mk_(2009, 11, 23), mk_(2009, 12, 23)}) \u003d\u003e pre_((jc.getDayOffsExceptSunday)d0401, d0430))))","type compatibility obligation:((setOfDayOffBy_yyyy_mm_dd \u003d {mk_(2001, 1, 1), mk_(2001, 1, 8), mk_(2001, 2, 11), mk_(2001, 2, 12), mk_(2001, 3, 20), mk_(2001, 4, 29), mk_(2001, 4, 30), mk_(2001, 5, 3), mk_(2001, 5, 4), mk_(2001, 5, 5), mk_(2001, 7, 20), mk_(2001, 9, 15), mk_(2001, 9, 23), mk_(2001, 9, 24), mk_(2001, 10, 8), mk_(2001, 11, 3), mk_(2001, 11, 23), mk_(2001, 12, 23), mk_(2001, 12, 24)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_dd2003 \u003d {mk_(2003, 1, 1), mk_(2003, 1, 13), mk_(2003, 2, 11), mk_(2003, 3, 21), mk_(2003, 4, 29), mk_(2003, 5, 3), mk_(2003, 5, 4), mk_(2003, 5, 5), mk_(2003, 7, 21), mk_(2003, 9, 15), mk_(2003, 9, 23), mk_(2003, 10, 13), mk_(2003, 11, 3), mk_(2003, 11, 23), mk_(2003, 11, 24), mk_(2003, 12, 23)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_ddIn2009 \u003d {mk_(2009, 1, 1), mk_(2009, 1, 12), mk_(2009, 2, 11), mk_(2009, 3, 20), mk_(2009, 4, 29), mk_(2009, 5, 3), mk_(2009, 5, 4), mk_(2009, 5, 5), mk_(2009, 5, 6), mk_(2009, 7, 20), mk_(2009, 9, 21), mk_(2009, 9, 22), mk_(2009, 9, 23), mk_(2009, 10, 12), mk_(2009, 11, 3), mk_(2009, 11, 23), mk_(2009, 12, 23)}) \u003d\u003e is_(d0401, Date))))","type compatibility obligation:((setOfDayOffBy_yyyy_mm_dd \u003d {mk_(2001, 1, 1), mk_(2001, 1, 8), mk_(2001, 2, 11), mk_(2001, 2, 12), mk_(2001, 3, 20), mk_(2001, 4, 29), mk_(2001, 4, 30), mk_(2001, 5, 3), mk_(2001, 5, 4), mk_(2001, 5, 5), mk_(2001, 7, 20), mk_(2001, 9, 15), mk_(2001, 9, 23), mk_(2001, 9, 24), mk_(2001, 10, 8), mk_(2001, 11, 3), mk_(2001, 11, 23), mk_(2001, 12, 23), mk_(2001, 12, 24)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_dd2003 \u003d {mk_(2003, 1, 1), mk_(2003, 1, 13), mk_(2003, 2, 11), mk_(2003, 3, 21), mk_(2003, 4, 29), mk_(2003, 5, 3), mk_(2003, 5, 4), mk_(2003, 5, 5), mk_(2003, 7, 21), mk_(2003, 9, 15), mk_(2003, 9, 23), mk_(2003, 10, 13), mk_(2003, 11, 3), mk_(2003, 11, 23), mk_(2003, 11, 24), mk_(2003, 12, 23)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_ddIn2009 \u003d {mk_(2009, 1, 1), mk_(2009, 1, 12), mk_(2009, 2, 11), mk_(2009, 3, 20), mk_(2009, 4, 29), mk_(2009, 5, 3), mk_(2009, 5, 4), mk_(2009, 5, 5), mk_(2009, 5, 6), mk_(2009, 7, 20), mk_(2009, 9, 21), mk_(2009, 9, 22), mk_(2009, 9, 23), mk_(2009, 10, 12), mk_(2009, 11, 3), mk_(2009, 11, 23), mk_(2009, 12, 23)}) \u003d\u003e is_(d0430, Date))))","legal function application obligation:((setOfDayOffBy_yyyy_mm_dd \u003d {mk_(2001, 1, 1), mk_(2001, 1, 8), mk_(2001, 2, 11), mk_(2001, 2, 12), mk_(2001, 3, 20), mk_(2001, 4, 29), mk_(2001, 4, 30), mk_(2001, 5, 3), mk_(2001, 5, 4), mk_(2001, 5, 5), mk_(2001, 7, 20), mk_(2001, 9, 15), mk_(2001, 9, 23), mk_(2001, 9, 24), mk_(2001, 10, 8), mk_(2001, 11, 3), mk_(2001, 11, 23), mk_(2001, 12, 23), mk_(2001, 12, 24)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_dd2003 \u003d {mk_(2003, 1, 1), mk_(2003, 1, 13), mk_(2003, 2, 11), mk_(2003, 3, 21), mk_(2003, 4, 29), mk_(2003, 5, 3), mk_(2003, 5, 4), mk_(2003, 5, 5), mk_(2003, 7, 21), mk_(2003, 9, 15), mk_(2003, 9, 23), mk_(2003, 10, 13), mk_(2003, 11, 3), mk_(2003, 11, 23), mk_(2003, 11, 24), mk_(2003, 12, 23)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_ddIn2009 \u003d {mk_(2009, 1, 1), mk_(2009, 1, 12), mk_(2009, 2, 11), mk_(2009, 3, 20), mk_(2009, 4, 29), mk_(2009, 5, 3), mk_(2009, 5, 4), mk_(2009, 5, 5), mk_(2009, 5, 6), mk_(2009, 7, 20), mk_(2009, 9, 21), mk_(2009, 9, 22), mk_(2009, 9, 23), mk_(2009, 10, 12), mk_(2009, 11, 3), mk_(2009, 11, 23), mk_(2009, 12, 23)}) \u003d\u003e (((jc.getDayOffsExceptSunday)(d0401, d0430) \u003d 2) \u003d\u003e pre_((jc.getDayOffsAndSunday)d0401, d0430)))))","type compatibility obligation:((setOfDayOffBy_yyyy_mm_dd \u003d {mk_(2001, 1, 1), mk_(2001, 1, 8), mk_(2001, 2, 11), mk_(2001, 2, 12), mk_(2001, 3, 20), mk_(2001, 4, 29), mk_(2001, 4, 30), mk_(2001, 5, 3), mk_(2001, 5, 4), mk_(2001, 5, 5), mk_(2001, 7, 20), mk_(2001, 9, 15), mk_(2001, 9, 23), mk_(2001, 9, 24), mk_(2001, 10, 8), mk_(2001, 11, 3), mk_(2001, 11, 23), mk_(2001, 12, 23), mk_(2001, 12, 24)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_dd2003 \u003d {mk_(2003, 1, 1), mk_(2003, 1, 13), mk_(2003, 2, 11), mk_(2003, 3, 21), mk_(2003, 4, 29), mk_(2003, 5, 3), mk_(2003, 5, 4), mk_(2003, 5, 5), mk_(2003, 7, 21), mk_(2003, 9, 15), mk_(2003, 9, 23), mk_(2003, 10, 13), mk_(2003, 11, 3), mk_(2003, 11, 23), mk_(2003, 11, 24), mk_(2003, 12, 23)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_ddIn2009 \u003d {mk_(2009, 1, 1), mk_(2009, 1, 12), mk_(2009, 2, 11), mk_(2009, 3, 20), mk_(2009, 4, 29), mk_(2009, 5, 3), mk_(2009, 5, 4), mk_(2009, 5, 5), mk_(2009, 5, 6), mk_(2009, 7, 20), mk_(2009, 9, 21), mk_(2009, 9, 22), mk_(2009, 9, 23), mk_(2009, 10, 12), mk_(2009, 11, 3), mk_(2009, 11, 23), mk_(2009, 12, 23)}) \u003d\u003e (((jc.getDayOffsExceptSunday)(d0401, d0430) \u003d 2) \u003d\u003e is_(d0401, Date)))))","type compatibility obligation:((setOfDayOffBy_yyyy_mm_dd \u003d {mk_(2001, 1, 1), mk_(2001, 1, 8), mk_(2001, 2, 11), mk_(2001, 2, 12), mk_(2001, 3, 20), mk_(2001, 4, 29), mk_(2001, 4, 30), mk_(2001, 5, 3), mk_(2001, 5, 4), mk_(2001, 5, 5), mk_(2001, 7, 20), mk_(2001, 9, 15), mk_(2001, 9, 23), mk_(2001, 9, 24), mk_(2001, 10, 8), mk_(2001, 11, 3), mk_(2001, 11, 23), mk_(2001, 12, 23), mk_(2001, 12, 24)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_dd2003 \u003d {mk_(2003, 1, 1), mk_(2003, 1, 13), mk_(2003, 2, 11), mk_(2003, 3, 21), mk_(2003, 4, 29), mk_(2003, 5, 3), mk_(2003, 5, 4), mk_(2003, 5, 5), mk_(2003, 7, 21), mk_(2003, 9, 15), mk_(2003, 9, 23), mk_(2003, 10, 13), mk_(2003, 11, 3), mk_(2003, 11, 23), mk_(2003, 11, 24), mk_(2003, 12, 23)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_ddIn2009 \u003d {mk_(2009, 1, 1), mk_(2009, 1, 12), mk_(2009, 2, 11), mk_(2009, 3, 20), mk_(2009, 4, 29), mk_(2009, 5, 3), mk_(2009, 5, 4), mk_(2009, 5, 5), mk_(2009, 5, 6), mk_(2009, 7, 20), mk_(2009, 9, 21), mk_(2009, 9, 22), mk_(2009, 9, 23), mk_(2009, 10, 12), mk_(2009, 11, 3), mk_(2009, 11, 23), mk_(2009, 12, 23)}) \u003d\u003e (((jc.getDayOffsExceptSunday)(d0401, d0430) \u003d 2) \u003d\u003e is_(d0430, Date)))))","legal function application obligation:((setOfDayOffBy_yyyy_mm_dd \u003d {mk_(2001, 1, 1), mk_(2001, 1, 8), mk_(2001, 2, 11), mk_(2001, 2, 12), mk_(2001, 3, 20), mk_(2001, 4, 29), mk_(2001, 4, 30), mk_(2001, 5, 3), mk_(2001, 5, 4), mk_(2001, 5, 5), mk_(2001, 7, 20), mk_(2001, 9, 15), mk_(2001, 9, 23), mk_(2001, 9, 24), mk_(2001, 10, 8), mk_(2001, 11, 3), mk_(2001, 11, 23), mk_(2001, 12, 23), mk_(2001, 12, 24)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_dd2003 \u003d {mk_(2003, 1, 1), mk_(2003, 1, 13), mk_(2003, 2, 11), mk_(2003, 3, 21), mk_(2003, 4, 29), mk_(2003, 5, 3), mk_(2003, 5, 4), mk_(2003, 5, 5), mk_(2003, 7, 21), mk_(2003, 9, 15), mk_(2003, 9, 23), mk_(2003, 10, 13), mk_(2003, 11, 3), mk_(2003, 11, 23), mk_(2003, 11, 24), mk_(2003, 12, 23)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_ddIn2009 \u003d {mk_(2009, 1, 1), mk_(2009, 1, 12), mk_(2009, 2, 11), mk_(2009, 3, 20), mk_(2009, 4, 29), mk_(2009, 5, 3), mk_(2009, 5, 4), mk_(2009, 5, 5), mk_(2009, 5, 6), mk_(2009, 7, 20), mk_(2009, 9, 21), mk_(2009, 9, 22), mk_(2009, 9, 23), mk_(2009, 10, 12), mk_(2009, 11, 3), mk_(2009, 11, 23), mk_(2009, 12, 23)}) \u003d\u003e (((jc.getDayOffsExceptSunday)(d0401, d0430) \u003d 2) \u003d\u003e (((card (jc.getDayOffsAndSunday)(d0401, d0430)) \u003d 1) \u003d\u003e pre_((jc.getDayOffsAndSunday)d0401, d0408))))))","type compatibility obligation:((setOfDayOffBy_yyyy_mm_dd \u003d {mk_(2001, 1, 1), mk_(2001, 1, 8), mk_(2001, 2, 11), mk_(2001, 2, 12), mk_(2001, 3, 20), mk_(2001, 4, 29), mk_(2001, 4, 30), mk_(2001, 5, 3), mk_(2001, 5, 4), mk_(2001, 5, 5), mk_(2001, 7, 20), mk_(2001, 9, 15), mk_(2001, 9, 23), mk_(2001, 9, 24), mk_(2001, 10, 8), mk_(2001, 11, 3), mk_(2001, 11, 23), mk_(2001, 12, 23), mk_(2001, 12, 24)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_dd2003 \u003d {mk_(2003, 1, 1), mk_(2003, 1, 13), mk_(2003, 2, 11), mk_(2003, 3, 21), mk_(2003, 4, 29), mk_(2003, 5, 3), mk_(2003, 5, 4), mk_(2003, 5, 5), mk_(2003, 7, 21), mk_(2003, 9, 15), mk_(2003, 9, 23), mk_(2003, 10, 13), mk_(2003, 11, 3), mk_(2003, 11, 23), mk_(2003, 11, 24), mk_(2003, 12, 23)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_ddIn2009 \u003d {mk_(2009, 1, 1), mk_(2009, 1, 12), mk_(2009, 2, 11), mk_(2009, 3, 20), mk_(2009, 4, 29), mk_(2009, 5, 3), mk_(2009, 5, 4), mk_(2009, 5, 5), mk_(2009, 5, 6), mk_(2009, 7, 20), mk_(2009, 9, 21), mk_(2009, 9, 22), mk_(2009, 9, 23), mk_(2009, 10, 12), mk_(2009, 11, 3), mk_(2009, 11, 23), mk_(2009, 12, 23)}) \u003d\u003e (((jc.getDayOffsExceptSunday)(d0401, d0430) \u003d 2) \u003d\u003e (((card (jc.getDayOffsAndSunday)(d0401, d0430)) \u003d 1) \u003d\u003e is_(d0401, Date))))))","type compatibility obligation:((setOfDayOffBy_yyyy_mm_dd \u003d {mk_(2001, 1, 1), mk_(2001, 1, 8), mk_(2001, 2, 11), mk_(2001, 2, 12), mk_(2001, 3, 20), mk_(2001, 4, 29), mk_(2001, 4, 30), mk_(2001, 5, 3), mk_(2001, 5, 4), mk_(2001, 5, 5), mk_(2001, 7, 20), mk_(2001, 9, 15), mk_(2001, 9, 23), mk_(2001, 9, 24), mk_(2001, 10, 8), mk_(2001, 11, 3), mk_(2001, 11, 23), mk_(2001, 12, 23), mk_(2001, 12, 24)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_dd2003 \u003d {mk_(2003, 1, 1), mk_(2003, 1, 13), mk_(2003, 2, 11), mk_(2003, 3, 21), mk_(2003, 4, 29), mk_(2003, 5, 3), mk_(2003, 5, 4), mk_(2003, 5, 5), mk_(2003, 7, 21), mk_(2003, 9, 15), mk_(2003, 9, 23), mk_(2003, 10, 13), mk_(2003, 11, 3), mk_(2003, 11, 23), mk_(2003, 11, 24), mk_(2003, 12, 23)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_ddIn2009 \u003d {mk_(2009, 1, 1), mk_(2009, 1, 12), mk_(2009, 2, 11), mk_(2009, 3, 20), mk_(2009, 4, 29), mk_(2009, 5, 3), mk_(2009, 5, 4), mk_(2009, 5, 5), mk_(2009, 5, 6), mk_(2009, 7, 20), mk_(2009, 9, 21), mk_(2009, 9, 22), mk_(2009, 9, 23), mk_(2009, 10, 12), mk_(2009, 11, 3), mk_(2009, 11, 23), mk_(2009, 12, 23)}) \u003d\u003e (((jc.getDayOffsExceptSunday)(d0401, d0430) \u003d 2) \u003d\u003e (((card (jc.getDayOffsAndSunday)(d0401, d0430)) \u003d 1) \u003d\u003e is_(d0408, Date))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e pre_((jc.EQ)d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)))","type compatibility obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e is_(d0711, Date))","legal function application obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e pre_((jc.LT)d0301, d0711))))","type compatibility obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e is_(d0711, Date))))","legal function application obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e pre_((jc.GT)d0711, d0301))))))","type compatibility obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e is_(d0711, Date))))))","legal function application obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e ((jc.GT)(d0711, d0301) \u003d\u003e ((d0711.GE)(d0711) \u003d\u003e ((d0711.GE)(d0301) \u003d\u003e pre_((jc.GE)d0711, d0711)))))))))","type compatibility obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e ((jc.GT)(d0711, d0301) \u003d\u003e ((d0711.GE)(d0711) \u003d\u003e ((d0711.GE)(d0301) \u003d\u003e is_(d0711, Date)))))))))","type compatibility obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e ((jc.GT)(d0711, d0301) \u003d\u003e ((d0711.GE)(d0711) \u003d\u003e ((d0711.GE)(d0301) \u003d\u003e is_(d0711, Date)))))))))","legal function application obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e ((jc.GT)(d0711, d0301) \u003d\u003e ((d0711.GE)(d0711) \u003d\u003e ((d0711.GE)(d0301) \u003d\u003e ((jc.GE)(d0711, d0711) \u003d\u003e pre_((jc.GE)d0711, d0301))))))))))","type compatibility obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e ((jc.GT)(d0711, d0301) \u003d\u003e ((d0711.GE)(d0711) \u003d\u003e ((d0711.GE)(d0301) \u003d\u003e ((jc.GE)(d0711, d0711) \u003d\u003e is_(d0711, Date))))))))))","legal function application obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e ((jc.GT)(d0711, d0301) \u003d\u003e ((d0711.GE)(d0711) \u003d\u003e ((d0711.GE)(d0301) \u003d\u003e ((jc.GE)(d0711, d0711) \u003d\u003e ((jc.GE)(d0711, d0301) \u003d\u003e ((d0711.LE)(d0711) \u003d\u003e ((d0301.LE)(d0711) \u003d\u003e pre_((jc.LE)d0711, d0711)))))))))))))","type compatibility obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e ((jc.GT)(d0711, d0301) \u003d\u003e ((d0711.GE)(d0711) \u003d\u003e ((d0711.GE)(d0301) \u003d\u003e ((jc.GE)(d0711, d0711) \u003d\u003e ((jc.GE)(d0711, d0301) \u003d\u003e ((d0711.LE)(d0711) \u003d\u003e ((d0301.LE)(d0711) \u003d\u003e is_(d0711, Date)))))))))))))","type compatibility obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e ((jc.GT)(d0711, d0301) \u003d\u003e ((d0711.GE)(d0711) \u003d\u003e ((d0711.GE)(d0301) \u003d\u003e ((jc.GE)(d0711, d0711) \u003d\u003e ((jc.GE)(d0711, d0301) \u003d\u003e ((d0711.LE)(d0711) \u003d\u003e ((d0301.LE)(d0711) \u003d\u003e is_(d0711, Date)))))))))))))","legal function application obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e ((jc.GT)(d0711, d0301) \u003d\u003e ((d0711.GE)(d0711) \u003d\u003e ((d0711.GE)(d0301) \u003d\u003e ((jc.GE)(d0711, d0711) \u003d\u003e ((jc.GE)(d0711, d0301) \u003d\u003e ((d0711.LE)(d0711) \u003d\u003e ((d0301.LE)(d0711) \u003d\u003e ((jc.LE)(d0711, d0711) \u003d\u003e pre_((jc.LE)d0301, d0711))))))))))))))","type compatibility obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e ((jc.GT)(d0711, d0301) \u003d\u003e ((d0711.GE)(d0711) \u003d\u003e ((d0711.GE)(d0301) \u003d\u003e ((jc.GE)(d0711, d0711) \u003d\u003e ((jc.GE)(d0711, d0301) \u003d\u003e ((d0711.LE)(d0711) \u003d\u003e ((d0301.LE)(d0711) \u003d\u003e ((jc.LE)(d0711, d0711) \u003d\u003e is_(d0711, Date))))))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd))","legal function application obligation:pre_((jc.firstDayOfTheWeekInMonth)2000, 3, \u003cWed\u003e)","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e pre_(((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e pre_((jc.firstDayOfTheWeekInMonth)2001, 7, \u003cSun\u003e))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e pre_(((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd))))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e pre_((jc.lastDayOfTheWeekInMonth)2000, 2, \u003cTue\u003e)))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e pre_(((jc.lastDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)))))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e pre_((jc.lastDayOfTheWeekInMonth)2001, 7, \u003cSun\u003e))))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e pre_(((jc.getNthDayOfTheWeek)(2001, 7, 5, \u003cSun\u003e).get_yyyy_mm_dd))))))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e pre_((jc.getNthDayOfTheWeek)2001, 7, 5, \u003cSun\u003e)))))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e ((((jc.getNthDayOfTheWeek)(2001, 7, 5, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e pre_((jc.getNthDayOfTheWeek)2001, 7, 6, \u003cSun\u003e))))))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e ((((jc.getNthDayOfTheWeek)(2001, 7, 5, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e (((jc.getNthDayOfTheWeek)(2001, 7, 6, \u003cSun\u003e) \u003d false) \u003d\u003e pre_((jc.getNumberOfTheDayOfWeek)d0711, d0301, \u003cSun\u003e)))))))","type compatibility obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e ((((jc.getNthDayOfTheWeek)(2001, 7, 5, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e (((jc.getNthDayOfTheWeek)(2001, 7, 6, \u003cSun\u003e) \u003d false) \u003d\u003e is_(d0711, Date)))))))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e ((((jc.getNthDayOfTheWeek)(2001, 7, 5, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e (((jc.getNthDayOfTheWeek)(2001, 7, 6, \u003cSun\u003e) \u003d false) \u003d\u003e (((jc.getNumberOfTheDayOfWeek)(d0711, d0301, \u003cSun\u003e) \u003d 19) \u003d\u003e pre_((jc.getNumberOfTheDayOfWeek)d0711, d10010301, \u003cSun\u003e))))))))","type compatibility obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e ((((jc.getNthDayOfTheWeek)(2001, 7, 5, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e (((jc.getNthDayOfTheWeek)(2001, 7, 6, \u003cSun\u003e) \u003d false) \u003d\u003e (((jc.getNumberOfTheDayOfWeek)(d0711, d0301, \u003cSun\u003e) \u003d 19) \u003d\u003e is_(d0711, Date))))))))","type compatibility obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e ((((jc.getNthDayOfTheWeek)(2001, 7, 5, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e (((jc.getNthDayOfTheWeek)(2001, 7, 6, \u003cSun\u003e) \u003d false) \u003d\u003e (((jc.getNumberOfTheDayOfWeek)(d0711, d0301, \u003cSun\u003e) \u003d 19) \u003d\u003e is_(d10010301, Date))))))))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e ((((jc.getNthDayOfTheWeek)(2001, 7, 5, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e (((jc.getNthDayOfTheWeek)(2001, 7, 6, \u003cSun\u003e) \u003d false) \u003d\u003e (((jc.getNumberOfTheDayOfWeek)(d0711, d0301, \u003cSun\u003e) \u003d 19) \u003d\u003e (((jc.getNumberOfTheDayOfWeek)(d0711, d10010301, \u003cSun\u003e) \u003d 52196) \u003d\u003e pre_((jc.getNumberOfDayOfTheWeekFromName)\u003cThu\u003e)))))))))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e ((((jc.getNthDayOfTheWeek)(2001, 7, 5, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e (((jc.getNthDayOfTheWeek)(2001, 7, 6, \u003cSun\u003e) \u003d false) \u003d\u003e (((jc.getNumberOfTheDayOfWeek)(d0711, d0301, \u003cSun\u003e) \u003d 19) \u003d\u003e (((jc.getNumberOfTheDayOfWeek)(d0711, d10010301, \u003cSun\u003e) \u003d 52196) \u003d\u003e (((jc.getNumberOfDayOfTheWeekFromName)(\u003cThu\u003e) \u003d 4) \u003d\u003e pre_((jc.getNumberOfDayOfTheWeekFromName)\u003cFri\u003e))))))))))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e ((((jc.getNthDayOfTheWeek)(2001, 7, 5, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e (((jc.getNthDayOfTheWeek)(2001, 7, 6, \u003cSun\u003e) \u003d false) \u003d\u003e (((jc.getNumberOfTheDayOfWeek)(d0711, d0301, \u003cSun\u003e) \u003d 19) \u003d\u003e (((jc.getNumberOfTheDayOfWeek)(d0711, d10010301, \u003cSun\u003e) \u003d 52196) \u003d\u003e (((jc.getNumberOfDayOfTheWeekFromName)(\u003cThu\u003e) \u003d 4) \u003d\u003e (((jc.getNumberOfDayOfTheWeekFromName)(\u003cFri\u003e) \u003d 5) \u003d\u003e pre_((jc.getNumberOfDayOfTheWeekFromName)\u003cSat\u003e)))))))))))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e ((((jc.getNthDayOfTheWeek)(2001, 7, 5, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e (((jc.getNthDayOfTheWeek)(2001, 7, 6, \u003cSun\u003e) \u003d false) \u003d\u003e (((jc.getNumberOfTheDayOfWeek)(d0711, d0301, \u003cSun\u003e) \u003d 19) \u003d\u003e (((jc.getNumberOfTheDayOfWeek)(d0711, d10010301, \u003cSun\u003e) \u003d 52196) \u003d\u003e (((jc.getNumberOfDayOfTheWeekFromName)(\u003cThu\u003e) \u003d 4) \u003d\u003e (((jc.getNumberOfDayOfTheWeekFromName)(\u003cFri\u003e) \u003d 5) \u003d\u003e (((jc.getNumberOfDayOfTheWeekFromName)(\u003cSat\u003e) \u003d 6) \u003d\u003e pre_((jc.getNumberOfDayOfTheWeekFromName)\u003cSun\u003e))))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:(((jc.getDateFromString)(\"sahara\") \u003d false) \u003d\u003e (((jc.getDateFromString)(\"20011232\") \u003d false) \u003d\u003e pre_(((jc.getDateFromString)(\"20011231\").date2Str))))","type compatibility obligation:is_(RESULT, ())","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((jc.getLastDayOfMonth)2004, 1)","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e pre_((jc.getLastDayOfMonth)2004, 2))","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 2).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e pre_((jc.getLastDayOfMonth)2004, 3)))","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 2).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 3).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e pre_((jc.getLastDayOfMonth)2004, 4))))","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 2).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 3).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 4).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e pre_((jc.getLastDayOfMonth)2004, 5)))))","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 2).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 3).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 4).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 5).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e pre_((jc.getLastDayOfMonth)2004, 6))))))","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 2).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 3).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 4).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 5).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 6).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e pre_((jc.getLastDayOfMonth)2004, 7)))))))","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 2).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 3).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 4).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 5).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 6).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 7).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e pre_((jc.getLastDayOfMonth)2004, 8))))))))","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 2).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 3).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 4).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 5).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 6).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 7).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 8).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 8, 31)) \u003d\u003e pre_((jc.getLastDayOfMonth)2004, 9)))))))))","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 2).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 3).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 4).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 5).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 6).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 7).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 8).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 8, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 9).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e pre_((jc.getLastDayOfMonth)2004, 10))))))))))","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 2).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 3).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 4).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 5).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 6).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 7).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 8).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 8, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 9).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 10).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 10, 31)) \u003d\u003e pre_((jc.getLastDayOfMonth)2004, 11)))))))))))","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 2).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 3).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 4).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 5).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 6).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 7).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 8).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 8, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 9).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 10).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 10, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 11).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 11, 30)) \u003d\u003e pre_((jc.getLastDayOfMonth)2004, 12))))))))))))","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 2).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 3).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 4).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 5).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 6).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 7).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 8).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 8, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 9).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 10).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 10, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 11).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 11, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 12).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 12, 31)) \u003d\u003e pre_((jc.getLastDayOfMonth)2003, 13)))))))))))))","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 2).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 3).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 4).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 5).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 6).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 7).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 8).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 8, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 9).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 10).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 10, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 11).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 11, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 12).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 12, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 13).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e pre_((jc.getLastDayOfMonth)2003, (8 + 6)))))))))))))))","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 2).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 3).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 4).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 5).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 6).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 7).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 8).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 8, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 9).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 10).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 10, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 11).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 11, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 12).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 12, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 13).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, (8 + 6)).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e pre_((jc.getLastDayOfMonth)2003, 15)))))))))))))))","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 2).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 3).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 4).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 5).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 6).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 7).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 8).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 8, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 9).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 10).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 10, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 11).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 11, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 12).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 12, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 13).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, (8 + 6)).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 15).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e pre_((jc.getLastDayOfMonth)2003, 16))))))))))))))))","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 2).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 3).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 4).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 5).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 6).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 7).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 8).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 8, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 9).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 10).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 10, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 11).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 11, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 12).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 12, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 13).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, (8 + 6)).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 15).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 16).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e pre_((jc.getLastDayOfMonth)2003, 17)))))))))))))))))","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 2).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 3).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 4).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 5).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 6).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 7).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 8).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 8, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 9).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 10).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 10, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 11).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 11, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 12).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 12, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 13).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, (8 + 6)).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 15).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 16).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 17).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e pre_((jc.getLastDayOfMonth)2003, 18))))))))))))))))))","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 2).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 3).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 4).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 5).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 6).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 7).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 8).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 8, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 9).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 10).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 10, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 11).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 11, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 12).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 12, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 13).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, (8 + 6)).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 15).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 16).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 17).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 18).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e pre_((jc.getLastDayOfMonth)2003, 19)))))))))))))))))))","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 2).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 3).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 4).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 5).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 6).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 7).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 8).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 8, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 9).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 10).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 10, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 11).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 11, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 12).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 12, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 13).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, (8 + 6)).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 15).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 16).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 17).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 18).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 19).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e pre_((jc.getLastDayOfMonth)2003, 20))))))))))))))))))))","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 2).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 3).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 4).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 5).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 6).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 7).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 8).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 8, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 9).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 10).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 10, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 11).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 11, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 12).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 12, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 13).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, (8 + 6)).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 15).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 16).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 17).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 18).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 19).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 20).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 8, 31)) \u003d\u003e pre_((jc.getLastDayOfMonth)2003, 21)))))))))))))))))))))","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 2).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 3).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 4).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 5).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 6).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 7).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 8).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 8, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 9).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 10).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 10, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 11).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 11, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 12).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 12, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 13).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, (8 + 6)).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 15).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 16).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 17).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 18).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 19).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 20).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 8, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 21).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e pre_((jc.getLastDayOfMonth)2003, 22))))))))))))))))))))))","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 2).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 3).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 4).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 5).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 6).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 7).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 8).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 8, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 9).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 10).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 10, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 11).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 11, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 12).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 12, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 13).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, (8 + 6)).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 15).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 16).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 17).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 18).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 19).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 20).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 8, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 21).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 22).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 10, 31)) \u003d\u003e pre_((jc.getLastDayOfMonth)2003, 23)))))))))))))))))))))))","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 2).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 3).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 4).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 5).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 6).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 7).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 8).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 8, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 9).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 10).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 10, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 11).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 11, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 12).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 12, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 13).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, (8 + 6)).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 15).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 16).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 17).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 18).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 19).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 20).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 8, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 21).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 22).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 10, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 23).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 11, 30)) \u003d\u003e pre_((jc.getLastDayOfMonth)2003, 24))))))))))))))))))))))))","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 2).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 3).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 4).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 5).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 6).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 7).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 8).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 8, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 9).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 10).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 10, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 11).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 11, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 12).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 12, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 13).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, (8 + 6)).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 15).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 16).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 17).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 18).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 19).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 20).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 8, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 21).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 22).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 10, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 23).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 11, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 24).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 12, 31)) \u003d\u003e pre_((jc.getLastDayOfMonth)2005, 2)))))))))))))))))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((jc.getRegularDate)2004, 1, 1)","legal function application obligation:(((jc.getRegularDate)(2004, 1, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e pre_((jc.getRegularDate)2003, 12, 32))","legal function application obligation:(((jc.getRegularDate)(2004, 1, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 12, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e pre_((jc.getRegularDate)2003, 24, 32)))","legal function application obligation:(((jc.getRegularDate)(2004, 1, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 12, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 24, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2005, 1, 1)) \u003d\u003e pre_((jc.getRegularDate)2003, 13, 1))))","legal function application obligation:(((jc.getRegularDate)(2004, 1, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 12, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 24, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2005, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 13, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e pre_((jc.getRegularDate)2004, 1, 32)))))","legal function application obligation:(((jc.getRegularDate)(2004, 1, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 12, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 24, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2005, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 13, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 1, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 1)) \u003d\u003e pre_((jc.getRegularDate)2004, 2, 0))))))","legal function application obligation:(((jc.getRegularDate)(2004, 1, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 12, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 24, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2005, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 13, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 1, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 0).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e pre_((jc.getRegularDate)2004, 2, 28)))))))","legal function application obligation:(((jc.getRegularDate)(2004, 1, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 12, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 24, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2005, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 13, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 1, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 0).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 28).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 28)) \u003d\u003e pre_((jc.getRegularDate)2004, 2, 29))))))))","legal function application obligation:(((jc.getRegularDate)(2004, 1, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 12, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 24, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2005, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 13, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 1, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 0).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 28).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 28)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 29).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e pre_((jc.getRegularDate)2004, 3, 0)))))))))","legal function application obligation:(((jc.getRegularDate)(2004, 1, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 12, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 24, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2005, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 13, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 1, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 0).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 28).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 28)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 29).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getRegularDate)(2004, 3, 0).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e pre_((jc.getRegularDate)2004, 3, -1))))))))))","legal function application obligation:(((jc.getRegularDate)(2004, 1, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 12, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 24, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2005, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 13, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 1, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 0).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 28).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 28)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 29).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getRegularDate)(2004, 3, 0).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getRegularDate)(2004, 3, -1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 28)) \u003d\u003e pre_((jc.getRegularDate)2003, 2, 29)))))))))))","legal function application obligation:(((jc.getRegularDate)(2004, 1, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 12, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 24, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2005, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 13, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 1, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 0).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 28).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 28)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 29).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getRegularDate)(2004, 3, 0).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getRegularDate)(2004, 3, -1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 28)) \u003d\u003e (((jc.getRegularDate)(2003, 2, 29).EQ)((jc.getDateFrom_yyyy_mm_dd)(2003, 3, 1)) \u003d\u003e pre_((jc.getRegularDate)2004, 4, 1))))))))))))","legal function application obligation:(((jc.getRegularDate)(2004, 1, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 12, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 24, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2005, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 13, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 1, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 0).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 28).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 28)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 29).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getRegularDate)(2004, 3, 0).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getRegularDate)(2004, 3, -1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 28)) \u003d\u003e (((jc.getRegularDate)(2003, 2, 29).EQ)((jc.getDateFrom_yyyy_mm_dd)(2003, 3, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 4, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 1)) \u003d\u003e pre_((jc.getRegularDate)2004, 0, 1)))))))))))))","legal function application obligation:(((jc.getRegularDate)(2004, 1, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 12, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 24, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2005, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 13, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 1, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 0).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 28).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 28)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 29).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getRegularDate)(2004, 3, 0).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getRegularDate)(2004, 3, -1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 28)) \u003d\u003e (((jc.getRegularDate)(2003, 2, 29).EQ)((jc.getDateFrom_yyyy_mm_dd)(2003, 3, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 4, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 0, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2003, 12, 1)) \u003d\u003e pre_((jc.getRegularDate)2004, -1, 1))))))))))))))","legal function application obligation:(((jc.getRegularDate)(2004, 1, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 12, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 24, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2005, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 13, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 1, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 0).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 28).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 28)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 29).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getRegularDate)(2004, 3, 0).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getRegularDate)(2004, 3, -1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 28)) \u003d\u003e (((jc.getRegularDate)(2003, 2, 29).EQ)((jc.getDateFrom_yyyy_mm_dd)(2003, 3, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 4, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 0, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2003, 12, 1)) \u003d\u003e (((jc.getRegularDate)(2004, -1, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2003, 11, 1)) \u003d\u003e pre_((jc.getRegularDate)2004, -10, 29)))))))))))))))","legal function application obligation:(((jc.getRegularDate)(2004, 1, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 12, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 24, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2005, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 13, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 1, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 0).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 28).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 28)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 29).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getRegularDate)(2004, 3, 0).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getRegularDate)(2004, 3, -1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 28)) \u003d\u003e (((jc.getRegularDate)(2003, 2, 29).EQ)((jc.getDateFrom_yyyy_mm_dd)(2003, 3, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 4, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 0, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2003, 12, 1)) \u003d\u003e (((jc.getRegularDate)(2004, -1, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2003, 11, 1)) \u003d\u003e (((jc.getRegularDate)(2004, -10, 29).EQ)((jc.getDateFrom_yyyy_mm_dd)(2003, 3, 1)) \u003d\u003e pre_((jc.getRegularDate)2004, -10, 28))))))))))))))))","legal function application obligation:(((jc.getRegularDate)(2004, 1, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 12, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 24, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2005, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 13, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 1, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 0).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 28).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 28)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 29).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getRegularDate)(2004, 3, 0).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getRegularDate)(2004, 3, -1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 28)) \u003d\u003e (((jc.getRegularDate)(2003, 2, 29).EQ)((jc.getDateFrom_yyyy_mm_dd)(2003, 3, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 4, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 0, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2003, 12, 1)) \u003d\u003e (((jc.getRegularDate)(2004, -1, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2003, 11, 1)) \u003d\u003e (((jc.getRegularDate)(2004, -10, 29).EQ)((jc.getDateFrom_yyyy_mm_dd)(2003, 3, 1)) \u003d\u003e (((jc.getRegularDate)(2004, -10, 28).EQ)((jc.getDateFrom_yyyy_mm_dd)(2003, 2, 28)) \u003d\u003e pre_((jc.getRegularDate)2004, -11, 1)))))))))))))))))","legal function application obligation:(((jc.getRegularDate)(2004, 1, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 12, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 24, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2005, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 13, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 1, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 0).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 28).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 28)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 29).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getRegularDate)(2004, 3, 0).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getRegularDate)(2004, 3, -1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 28)) \u003d\u003e (((jc.getRegularDate)(2003, 2, 29).EQ)((jc.getDateFrom_yyyy_mm_dd)(2003, 3, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 4, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 0, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2003, 12, 1)) \u003d\u003e (((jc.getRegularDate)(2004, -1, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2003, 11, 1)) \u003d\u003e (((jc.getRegularDate)(2004, -10, 29).EQ)((jc.getDateFrom_yyyy_mm_dd)(2003, 3, 1)) \u003d\u003e (((jc.getRegularDate)(2004, -10, 28).EQ)((jc.getDateFrom_yyyy_mm_dd)(2003, 2, 28)) \u003d\u003e (((jc.getRegularDate)(2004, -11, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2003, 1, 1)) \u003d\u003e pre_((jc.getRegularDate)2004, -12, 1))))))))))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((jc.getRegularMonth)2004, 1)","legal function application obligation:(((jc.getRegularMonth)(2004, 1) \u003d mk_(2004, 1)) \u003d\u003e pre_((jc.getRegularMonth)2004, 2))","legal function application obligation:(((jc.getRegularMonth)(2004, 1) \u003d mk_(2004, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 2) \u003d mk_(2004, 2)) \u003d\u003e pre_((jc.getRegularMonth)2004, 3)))","legal function application obligation:(((jc.getRegularMonth)(2004, 1) \u003d mk_(2004, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 2) \u003d mk_(2004, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 3) \u003d mk_(2004, 3)) \u003d\u003e pre_((jc.getRegularMonth)2004, 4))))","legal function application obligation:(((jc.getRegularMonth)(2004, 1) \u003d mk_(2004, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 2) \u003d mk_(2004, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 3) \u003d mk_(2004, 3)) \u003d\u003e (((jc.getRegularMonth)(2004, 4) \u003d mk_(2004, 4)) \u003d\u003e pre_((jc.getRegularMonth)2004, 5)))))","legal function application obligation:(((jc.getRegularMonth)(2004, 1) \u003d mk_(2004, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 2) \u003d mk_(2004, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 3) \u003d mk_(2004, 3)) \u003d\u003e (((jc.getRegularMonth)(2004, 4) \u003d mk_(2004, 4)) \u003d\u003e (((jc.getRegularMonth)(2004, 5) \u003d mk_(2004, 5)) \u003d\u003e pre_((jc.getRegularMonth)2004, 6))))))","legal function application obligation:(((jc.getRegularMonth)(2004, 1) \u003d mk_(2004, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 2) \u003d mk_(2004, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 3) \u003d mk_(2004, 3)) \u003d\u003e (((jc.getRegularMonth)(2004, 4) \u003d mk_(2004, 4)) \u003d\u003e (((jc.getRegularMonth)(2004, 5) \u003d mk_(2004, 5)) \u003d\u003e (((jc.getRegularMonth)(2004, 6) \u003d mk_(2004, 6)) \u003d\u003e pre_((jc.getRegularMonth)2004, 7)))))))","legal function application obligation:(((jc.getRegularMonth)(2004, 1) \u003d mk_(2004, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 2) \u003d mk_(2004, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 3) \u003d mk_(2004, 3)) \u003d\u003e (((jc.getRegularMonth)(2004, 4) \u003d mk_(2004, 4)) \u003d\u003e (((jc.getRegularMonth)(2004, 5) \u003d mk_(2004, 5)) \u003d\u003e (((jc.getRegularMonth)(2004, 6) \u003d mk_(2004, 6)) \u003d\u003e (((jc.getRegularMonth)(2004, 7) \u003d mk_(2004, 7)) \u003d\u003e pre_((jc.getRegularMonth)2004, 8))))))))","legal function application obligation:(((jc.getRegularMonth)(2004, 1) \u003d mk_(2004, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 2) \u003d mk_(2004, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 3) \u003d mk_(2004, 3)) \u003d\u003e (((jc.getRegularMonth)(2004, 4) \u003d mk_(2004, 4)) \u003d\u003e (((jc.getRegularMonth)(2004, 5) \u003d mk_(2004, 5)) \u003d\u003e (((jc.getRegularMonth)(2004, 6) \u003d mk_(2004, 6)) \u003d\u003e (((jc.getRegularMonth)(2004, 7) \u003d mk_(2004, 7)) \u003d\u003e (((jc.getRegularMonth)(2004, 8) \u003d mk_(2004, 8)) \u003d\u003e pre_((jc.getRegularMonth)2004, 9)))))))))","legal function application obligation:(((jc.getRegularMonth)(2004, 1) \u003d mk_(2004, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 2) \u003d mk_(2004, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 3) \u003d mk_(2004, 3)) \u003d\u003e (((jc.getRegularMonth)(2004, 4) \u003d mk_(2004, 4)) \u003d\u003e (((jc.getRegularMonth)(2004, 5) \u003d mk_(2004, 5)) \u003d\u003e (((jc.getRegularMonth)(2004, 6) \u003d mk_(2004, 6)) \u003d\u003e (((jc.getRegularMonth)(2004, 7) \u003d mk_(2004, 7)) \u003d\u003e (((jc.getRegularMonth)(2004, 8) \u003d mk_(2004, 8)) \u003d\u003e (((jc.getRegularMonth)(2004, 9) \u003d mk_(2004, 9)) \u003d\u003e pre_((jc.getRegularMonth)2004, 10))))))))))","legal function application obligation:(((jc.getRegularMonth)(2004, 1) \u003d mk_(2004, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 2) \u003d mk_(2004, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 3) \u003d mk_(2004, 3)) \u003d\u003e (((jc.getRegularMonth)(2004, 4) \u003d mk_(2004, 4)) \u003d\u003e (((jc.getRegularMonth)(2004, 5) \u003d mk_(2004, 5)) \u003d\u003e (((jc.getRegularMonth)(2004, 6) \u003d mk_(2004, 6)) \u003d\u003e (((jc.getRegularMonth)(2004, 7) \u003d mk_(2004, 7)) \u003d\u003e (((jc.getRegularMonth)(2004, 8) \u003d mk_(2004, 8)) \u003d\u003e (((jc.getRegularMonth)(2004, 9) \u003d mk_(2004, 9)) \u003d\u003e (((jc.getRegularMonth)(2004, 10) \u003d mk_(2004, 10)) \u003d\u003e pre_((jc.getRegularMonth)2004, 11)))))))))))","legal function application obligation:(((jc.getRegularMonth)(2004, 1) \u003d mk_(2004, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 2) \u003d mk_(2004, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 3) \u003d mk_(2004, 3)) \u003d\u003e (((jc.getRegularMonth)(2004, 4) \u003d mk_(2004, 4)) \u003d\u003e (((jc.getRegularMonth)(2004, 5) \u003d mk_(2004, 5)) \u003d\u003e (((jc.getRegularMonth)(2004, 6) \u003d mk_(2004, 6)) \u003d\u003e (((jc.getRegularMonth)(2004, 7) \u003d mk_(2004, 7)) \u003d\u003e (((jc.getRegularMonth)(2004, 8) \u003d mk_(2004, 8)) \u003d\u003e (((jc.getRegularMonth)(2004, 9) \u003d mk_(2004, 9)) \u003d\u003e (((jc.getRegularMonth)(2004, 10) \u003d mk_(2004, 10)) \u003d\u003e (((jc.getRegularMonth)(2004, 11) \u003d mk_(2004, 11)) \u003d\u003e pre_((jc.getRegularMonth)2004, 12))))))))))))","legal function application obligation:(((jc.getRegularMonth)(2004, 1) \u003d mk_(2004, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 2) \u003d mk_(2004, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 3) \u003d mk_(2004, 3)) \u003d\u003e (((jc.getRegularMonth)(2004, 4) \u003d mk_(2004, 4)) \u003d\u003e (((jc.getRegularMonth)(2004, 5) \u003d mk_(2004, 5)) \u003d\u003e (((jc.getRegularMonth)(2004, 6) \u003d mk_(2004, 6)) \u003d\u003e (((jc.getRegularMonth)(2004, 7) \u003d mk_(2004, 7)) \u003d\u003e (((jc.getRegularMonth)(2004, 8) \u003d mk_(2004, 8)) \u003d\u003e (((jc.getRegularMonth)(2004, 9) \u003d mk_(2004, 9)) \u003d\u003e (((jc.getRegularMonth)(2004, 10) \u003d mk_(2004, 10)) \u003d\u003e (((jc.getRegularMonth)(2004, 11) \u003d mk_(2004, 11)) \u003d\u003e (((jc.getRegularMonth)(2004, 12) \u003d mk_(2004, 12)) \u003d\u003e pre_((jc.getRegularMonth)2004, 13)))))))))))))","legal function application obligation:(((jc.getRegularMonth)(2004, 1) \u003d mk_(2004, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 2) \u003d mk_(2004, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 3) \u003d mk_(2004, 3)) \u003d\u003e (((jc.getRegularMonth)(2004, 4) \u003d mk_(2004, 4)) \u003d\u003e (((jc.getRegularMonth)(2004, 5) \u003d mk_(2004, 5)) \u003d\u003e (((jc.getRegularMonth)(2004, 6) \u003d mk_(2004, 6)) \u003d\u003e (((jc.getRegularMonth)(2004, 7) \u003d mk_(2004, 7)) \u003d\u003e (((jc.getRegularMonth)(2004, 8) \u003d mk_(2004, 8)) \u003d\u003e (((jc.getRegularMonth)(2004, 9) \u003d mk_(2004, 9)) \u003d\u003e (((jc.getRegularMonth)(2004, 10) \u003d mk_(2004, 10)) \u003d\u003e (((jc.getRegularMonth)(2004, 11) \u003d mk_(2004, 11)) \u003d\u003e (((jc.getRegularMonth)(2004, 12) \u003d mk_(2004, 12)) \u003d\u003e (((jc.getRegularMonth)(2004, 13) \u003d mk_(2005, 1)) \u003d\u003e pre_((jc.getRegularMonth)2004, 14))))))))))))))","legal function application obligation:(((jc.getRegularMonth)(2004, 1) \u003d mk_(2004, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 2) \u003d mk_(2004, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 3) \u003d mk_(2004, 3)) \u003d\u003e (((jc.getRegularMonth)(2004, 4) \u003d mk_(2004, 4)) \u003d\u003e (((jc.getRegularMonth)(2004, 5) \u003d mk_(2004, 5)) \u003d\u003e (((jc.getRegularMonth)(2004, 6) \u003d mk_(2004, 6)) \u003d\u003e (((jc.getRegularMonth)(2004, 7) \u003d mk_(2004, 7)) \u003d\u003e (((jc.getRegularMonth)(2004, 8) \u003d mk_(2004, 8)) \u003d\u003e (((jc.getRegularMonth)(2004, 9) \u003d mk_(2004, 9)) \u003d\u003e (((jc.getRegularMonth)(2004, 10) \u003d mk_(2004, 10)) \u003d\u003e (((jc.getRegularMonth)(2004, 11) \u003d mk_(2004, 11)) \u003d\u003e (((jc.getRegularMonth)(2004, 12) \u003d mk_(2004, 12)) \u003d\u003e (((jc.getRegularMonth)(2004, 13) \u003d mk_(2005, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 14) \u003d mk_(2005, 2)) \u003d\u003e pre_((jc.getRegularMonth)2004, 24)))))))))))))))","legal function application obligation:(((jc.getRegularMonth)(2004, 1) \u003d mk_(2004, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 2) \u003d mk_(2004, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 3) \u003d mk_(2004, 3)) \u003d\u003e (((jc.getRegularMonth)(2004, 4) \u003d mk_(2004, 4)) \u003d\u003e (((jc.getRegularMonth)(2004, 5) \u003d mk_(2004, 5)) \u003d\u003e (((jc.getRegularMonth)(2004, 6) \u003d mk_(2004, 6)) \u003d\u003e (((jc.getRegularMonth)(2004, 7) \u003d mk_(2004, 7)) \u003d\u003e (((jc.getRegularMonth)(2004, 8) \u003d mk_(2004, 8)) \u003d\u003e (((jc.getRegularMonth)(2004, 9) \u003d mk_(2004, 9)) \u003d\u003e (((jc.getRegularMonth)(2004, 10) \u003d mk_(2004, 10)) \u003d\u003e (((jc.getRegularMonth)(2004, 11) \u003d mk_(2004, 11)) \u003d\u003e (((jc.getRegularMonth)(2004, 12) \u003d mk_(2004, 12)) \u003d\u003e (((jc.getRegularMonth)(2004, 13) \u003d mk_(2005, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 14) \u003d mk_(2005, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 24) \u003d mk_(2005, 12)) \u003d\u003e pre_((jc.getRegularMonth)2004, 25))))))))))))))))","legal function application obligation:(((jc.getRegularMonth)(2004, 1) \u003d mk_(2004, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 2) \u003d mk_(2004, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 3) \u003d mk_(2004, 3)) \u003d\u003e (((jc.getRegularMonth)(2004, 4) \u003d mk_(2004, 4)) \u003d\u003e (((jc.getRegularMonth)(2004, 5) \u003d mk_(2004, 5)) \u003d\u003e (((jc.getRegularMonth)(2004, 6) \u003d mk_(2004, 6)) \u003d\u003e (((jc.getRegularMonth)(2004, 7) \u003d mk_(2004, 7)) \u003d\u003e (((jc.getRegularMonth)(2004, 8) \u003d mk_(2004, 8)) \u003d\u003e (((jc.getRegularMonth)(2004, 9) \u003d mk_(2004, 9)) \u003d\u003e (((jc.getRegularMonth)(2004, 10) \u003d mk_(2004, 10)) \u003d\u003e (((jc.getRegularMonth)(2004, 11) \u003d mk_(2004, 11)) \u003d\u003e (((jc.getRegularMonth)(2004, 12) \u003d mk_(2004, 12)) \u003d\u003e (((jc.getRegularMonth)(2004, 13) \u003d mk_(2005, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 14) \u003d mk_(2005, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 24) \u003d mk_(2005, 12)) \u003d\u003e (((jc.getRegularMonth)(2004, 25) \u003d mk_(2006, 1)) \u003d\u003e pre_((jc.getRegularMonth)2004, 0)))))))))))))))))","legal function application obligation:(((jc.getRegularMonth)(2004, 1) \u003d mk_(2004, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 2) \u003d mk_(2004, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 3) \u003d mk_(2004, 3)) \u003d\u003e (((jc.getRegularMonth)(2004, 4) \u003d mk_(2004, 4)) \u003d\u003e (((jc.getRegularMonth)(2004, 5) \u003d mk_(2004, 5)) \u003d\u003e (((jc.getRegularMonth)(2004, 6) \u003d mk_(2004, 6)) \u003d\u003e (((jc.getRegularMonth)(2004, 7) \u003d mk_(2004, 7)) \u003d\u003e (((jc.getRegularMonth)(2004, 8) \u003d mk_(2004, 8)) \u003d\u003e (((jc.getRegularMonth)(2004, 9) \u003d mk_(2004, 9)) \u003d\u003e (((jc.getRegularMonth)(2004, 10) \u003d mk_(2004, 10)) \u003d\u003e (((jc.getRegularMonth)(2004, 11) \u003d mk_(2004, 11)) \u003d\u003e (((jc.getRegularMonth)(2004, 12) \u003d mk_(2004, 12)) \u003d\u003e (((jc.getRegularMonth)(2004, 13) \u003d mk_(2005, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 14) \u003d mk_(2005, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 24) \u003d mk_(2005, 12)) \u003d\u003e (((jc.getRegularMonth)(2004, 25) \u003d mk_(2006, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 0) \u003d mk_(2003, 12)) \u003d\u003e pre_((jc.getRegularMonth)2004, -1))))))))))))))))))","legal function application obligation:(((jc.getRegularMonth)(2004, 1) \u003d mk_(2004, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 2) \u003d mk_(2004, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 3) \u003d mk_(2004, 3)) \u003d\u003e (((jc.getRegularMonth)(2004, 4) \u003d mk_(2004, 4)) \u003d\u003e (((jc.getRegularMonth)(2004, 5) \u003d mk_(2004, 5)) \u003d\u003e (((jc.getRegularMonth)(2004, 6) \u003d mk_(2004, 6)) \u003d\u003e (((jc.getRegularMonth)(2004, 7) \u003d mk_(2004, 7)) \u003d\u003e (((jc.getRegularMonth)(2004, 8) \u003d mk_(2004, 8)) \u003d\u003e (((jc.getRegularMonth)(2004, 9) \u003d mk_(2004, 9)) \u003d\u003e (((jc.getRegularMonth)(2004, 10) \u003d mk_(2004, 10)) \u003d\u003e (((jc.getRegularMonth)(2004, 11) \u003d mk_(2004, 11)) \u003d\u003e (((jc.getRegularMonth)(2004, 12) \u003d mk_(2004, 12)) \u003d\u003e (((jc.getRegularMonth)(2004, 13) \u003d mk_(2005, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 14) \u003d mk_(2005, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 24) \u003d mk_(2005, 12)) \u003d\u003e (((jc.getRegularMonth)(2004, 25) \u003d mk_(2006, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 0) \u003d mk_(2003, 12)) \u003d\u003e (((jc.getRegularMonth)(2004, -1) \u003d mk_(2003, 11)) \u003d\u003e pre_((jc.getRegularMonth)2004, -10)))))))))))))))))))","legal function application obligation:(((jc.getRegularMonth)(2004, 1) \u003d mk_(2004, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 2) \u003d mk_(2004, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 3) \u003d mk_(2004, 3)) \u003d\u003e (((jc.getRegularMonth)(2004, 4) \u003d mk_(2004, 4)) \u003d\u003e (((jc.getRegularMonth)(2004, 5) \u003d mk_(2004, 5)) \u003d\u003e (((jc.getRegularMonth)(2004, 6) \u003d mk_(2004, 6)) \u003d\u003e (((jc.getRegularMonth)(2004, 7) \u003d mk_(2004, 7)) \u003d\u003e (((jc.getRegularMonth)(2004, 8) \u003d mk_(2004, 8)) \u003d\u003e (((jc.getRegularMonth)(2004, 9) \u003d mk_(2004, 9)) \u003d\u003e (((jc.getRegularMonth)(2004, 10) \u003d mk_(2004, 10)) \u003d\u003e (((jc.getRegularMonth)(2004, 11) \u003d mk_(2004, 11)) \u003d\u003e (((jc.getRegularMonth)(2004, 12) \u003d mk_(2004, 12)) \u003d\u003e (((jc.getRegularMonth)(2004, 13) \u003d mk_(2005, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 14) \u003d mk_(2005, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 24) \u003d mk_(2005, 12)) \u003d\u003e (((jc.getRegularMonth)(2004, 25) \u003d mk_(2006, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 0) \u003d mk_(2003, 12)) \u003d\u003e (((jc.getRegularMonth)(2004, -1) \u003d mk_(2003, 11)) \u003d\u003e (((jc.getRegularMonth)(2004, -10) \u003d mk_(2003, 2)) \u003d\u003e pre_((jc.getRegularMonth)2004, -11))))))))))))))))))))","legal function application obligation:(((jc.getRegularMonth)(2004, 1) \u003d mk_(2004, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 2) \u003d mk_(2004, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 3) \u003d mk_(2004, 3)) \u003d\u003e (((jc.getRegularMonth)(2004, 4) \u003d mk_(2004, 4)) \u003d\u003e (((jc.getRegularMonth)(2004, 5) \u003d mk_(2004, 5)) \u003d\u003e (((jc.getRegularMonth)(2004, 6) \u003d mk_(2004, 6)) \u003d\u003e (((jc.getRegularMonth)(2004, 7) \u003d mk_(2004, 7)) \u003d\u003e (((jc.getRegularMonth)(2004, 8) \u003d mk_(2004, 8)) \u003d\u003e (((jc.getRegularMonth)(2004, 9) \u003d mk_(2004, 9)) \u003d\u003e (((jc.getRegularMonth)(2004, 10) \u003d mk_(2004, 10)) \u003d\u003e (((jc.getRegularMonth)(2004, 11) \u003d mk_(2004, 11)) \u003d\u003e (((jc.getRegularMonth)(2004, 12) \u003d mk_(2004, 12)) \u003d\u003e (((jc.getRegularMonth)(2004, 13) \u003d mk_(2005, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 14) \u003d mk_(2005, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 24) \u003d mk_(2005, 12)) \u003d\u003e (((jc.getRegularMonth)(2004, 25) \u003d mk_(2006, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 0) \u003d mk_(2003, 12)) \u003d\u003e (((jc.getRegularMonth)(2004, -1) \u003d mk_(2003, 11)) \u003d\u003e (((jc.getRegularMonth)(2004, -10) \u003d mk_(2003, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, -11) \u003d mk_(2003, 1)) \u003d\u003e pre_((jc.getRegularMonth)2004, -12)))))))))))))))))))))","legal function application obligation:(((jc.getRegularMonth)(2004, 1) \u003d mk_(2004, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 2) \u003d mk_(2004, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 3) \u003d mk_(2004, 3)) \u003d\u003e (((jc.getRegularMonth)(2004, 4) \u003d mk_(2004, 4)) \u003d\u003e (((jc.getRegularMonth)(2004, 5) \u003d mk_(2004, 5)) \u003d\u003e (((jc.getRegularMonth)(2004, 6) \u003d mk_(2004, 6)) \u003d\u003e (((jc.getRegularMonth)(2004, 7) \u003d mk_(2004, 7)) \u003d\u003e (((jc.getRegularMonth)(2004, 8) \u003d mk_(2004, 8)) \u003d\u003e (((jc.getRegularMonth)(2004, 9) \u003d mk_(2004, 9)) \u003d\u003e (((jc.getRegularMonth)(2004, 10) \u003d mk_(2004, 10)) \u003d\u003e (((jc.getRegularMonth)(2004, 11) \u003d mk_(2004, 11)) \u003d\u003e (((jc.getRegularMonth)(2004, 12) \u003d mk_(2004, 12)) \u003d\u003e (((jc.getRegularMonth)(2004, 13) \u003d mk_(2005, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 14) \u003d mk_(2005, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 24) \u003d mk_(2005, 12)) \u003d\u003e (((jc.getRegularMonth)(2004, 25) \u003d mk_(2006, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 0) \u003d mk_(2003, 12)) \u003d\u003e (((jc.getRegularMonth)(2004, -1) \u003d mk_(2003, 11)) \u003d\u003e (((jc.getRegularMonth)(2004, -10) \u003d mk_(2003, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, -11) \u003d mk_(2003, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, -12) \u003d mk_(2002, 12)) \u003d\u003e pre_((jc.getRegularMonth)2004, -13))))))))))))))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:(forall aContractMonth:seq of (char) \u0026 (isCorrectContractMonth(aContractMonth) \u003d\u003e pre_((firstDayOfContractMonth.Year))))","legal function application obligation:(forall aContractMonth:seq of (char) \u0026 (isCorrectContractMonth(aContractMonth) \u003d\u003e pre_((firstDayOfContractMonth.Month))))","legal function application obligation:(forall aContractMonth:seq of (char) \u0026 (isCorrectContractMonth(aContractMonth) \u003d\u003e let firstDayOfContractMonth:(Date | bool) \u003d (calendar.getDateFromString)((aContractMonth ^ \"01\")), designatedYear:int \u003d (firstDayOfContractMonth.Year)(), designatedMonth:int \u003d (firstDayOfContractMonth.Month)() in pre_(((calendar.getNthDayOfTheWeek)(designatedYear, designatedMonth, 2, \u003cFri\u003e).getPastWeekday))))","legal function application obligation:(forall aContractMonth:seq of (char) \u0026 (isCorrectContractMonth(aContractMonth) \u003d\u003e let firstDayOfContractMonth:(Date | bool) \u003d (calendar.getDateFromString)((aContractMonth ^ \"01\")), designatedYear:int \u003d (firstDayOfContractMonth.Year)(), designatedMonth:int \u003d (firstDayOfContractMonth.Month)() in pre_((calendar.getNthDayOfTheWeek)designatedYear, designatedMonth, 2, \u003cFri\u003e)))","function establishes postcondition obligation:(forall aDate:Date \u0026 post_getContractDate(aDate, let mk_(year, month):(int * int) \u003d (calendar.getMonthOf6monthsLater)((aDate.Year)(), (aDate.Month)()), date:int \u003d (aDate.day)(), candidateDate:Date \u003d getCandidateDate(year, month, date) in (candidateDate.getPastWeekday)()))","legal function application obligation:(forall aDate:Date \u0026 let RESULT \u003d let mk_(year, month):(int * int) \u003d (calendar.getMonthOf6monthsLater)((aDate.Year)(), (aDate.Month)()), date:int \u003d (aDate.day)(), candidateDate:Date \u003d getCandidateDate(year, month, date) in (candidateDate.getPastWeekday)() in pre_((calendar.getMonthOf6monthsLater)(aDate.Year)(), (aDate.Month)()))","legal function application obligation:(forall aDate:Date \u0026 let RESULT \u003d let mk_(year, month):(int * int) \u003d (calendar.getMonthOf6monthsLater)((aDate.Year)(), (aDate.Month)()), date:int \u003d (aDate.day)(), candidateDate:Date \u003d getCandidateDate(year, month, date) in (candidateDate.getPastWeekday)() in pre_((aDate.Year)))","legal function application obligation:(forall aDate:Date \u0026 let RESULT \u003d let mk_(year, month):(int * int) \u003d (calendar.getMonthOf6monthsLater)((aDate.Year)(), (aDate.Month)()), date:int \u003d (aDate.day)(), candidateDate:Date \u003d getCandidateDate(year, month, date) in (candidateDate.getPastWeekday)() in pre_((aDate.Month)))","legal function application obligation:(forall aDate:Date \u0026 let RESULT \u003d let mk_(year, month):(int * int) \u003d (calendar.getMonthOf6monthsLater)((aDate.Year)(), (aDate.Month)()), date:int \u003d (aDate.day)(), candidateDate:Date \u003d getCandidateDate(year, month, date) in (candidateDate.getPastWeekday)() in pre_((aDate.day)))","legal function application obligation:(forall aDate:Date \u0026 let RESULT \u003d let mk_(year, month):(int * int) \u003d (calendar.getMonthOf6monthsLater)((aDate.Year)(), (aDate.Month)()), date:int \u003d (aDate.day)(), candidateDate:Date \u003d getCandidateDate(year, month, date) in (candidateDate.getPastWeekday)() in let mk_(year, month):(int * int) \u003d (calendar.getMonthOf6monthsLater)((aDate.Year)(), (aDate.Month)()), date:int \u003d (aDate.day)(), candidateDate:Date \u003d getCandidateDate(year, month, date) in pre_((candidateDate.getPastWeekday)))","legal function application obligation:(forall aDate:Date \u0026 let RESULT \u003d let mk_(year, month):(int * int) \u003d (calendar.getMonthOf6monthsLater)((aDate.Year)(), (aDate.Month)()), date:int \u003d (aDate.day)(), candidateDate:Date \u003d getCandidateDate(year, month, date) in (candidateDate.getPastWeekday)() in let mk_(year, month):(int * int) \u003d (calendar.getMonthOf6monthsLater)((aDate.Year)(), (aDate.Month)()), date:int \u003d (aDate.day)(), candidateDate:Date \u003d getCandidateDate(year, month, date) in ((RESULT.EQ)((candidateDate.getPastWeekday)()) \u003d\u003e (isDayoffFromTheBeginingOfMonthToCandidateDate(candidateDate) \u003d\u003e pre_((RESULT.Month)))))","legal function application obligation:(forall aDate:Date \u0026 let RESULT \u003d let mk_(year, month):(int * int) \u003d (calendar.getMonthOf6monthsLater)((aDate.Year)(), (aDate.Month)()), date:int \u003d (aDate.day)(), candidateDate:Date \u003d getCandidateDate(year, month, date) in (candidateDate.getPastWeekday)() in let mk_(year, month):(int * int) \u003d (calendar.getMonthOf6monthsLater)((aDate.Year)(), (aDate.Month)()), date:int \u003d (aDate.day)(), candidateDate:Date \u003d getCandidateDate(year, month, date) in ((RESULT.EQ)((candidateDate.getPastWeekday)()) \u003d\u003e ((not isDayoffFromTheBeginingOfMonthToCandidateDate(candidateDate)) \u003d\u003e pre_((RESULT.Month)))))","legal function application obligation:(forall aDate:Date \u0026 pre_((calendar.getMonthOf6monthsLater)(aDate.Year)(), (aDate.Month)()))","legal function application obligation:(forall aDate:Date \u0026 pre_((aDate.Year)))","legal function application obligation:(forall aDate:Date \u0026 pre_((aDate.Month)))","legal function application obligation:(forall aDate:Date \u0026 pre_((aDate.day)))","legal function application obligation:(forall aDate:Date \u0026 let mk_(year, month):(int * int) \u003d (calendar.getMonthOf6monthsLater)((aDate.Year)(), (aDate.Month)()), date:int \u003d (aDate.day)(), candidateDate:Date \u003d getCandidateDate(year, month, date) in pre_((candidateDate.getPastWeekday)))","legal function application obligation:(forall year:int, month:int \u0026 pre_((calendar.getRegularMonth)year, (month + 6)))","legal function application obligation:(forall year:int, month:int, date:int \u0026 pre_((calendar.getLastDayOfMonth)year, month))","legal function application obligation:(forall year:int, month:int, date:int \u0026 let dateOfEndOfMonth:Date \u003d (calendar.getLastDayOfMonth)(year, month) in pre_((dateOfEndOfMonth.day)))","legal function application obligation:(forall candidateDate:Date \u0026 pre_((candidateDate.day)))","legal function application obligation:(forall candidateDate:Date \u0026 (forall day in set {1, ... ,(candidateDate.day)()} \u0026 pre_((calendar.isSundayOrDayoff)(calendar.getDateFrom_yyyy_mm_dd)((candidateDate.Year)(), (candidateDate.Month)(), day))))","legal function application obligation:(forall candidateDate:Date \u0026 (forall day in set {1, ... ,(candidateDate.day)()} \u0026 pre_((candidateDate.Year))))","legal function application obligation:(forall candidateDate:Date \u0026 (forall day in set {1, ... ,(candidateDate.day)()} \u0026 pre_((candidateDate.Month))))","legal function application obligation:(forall year:int, month:int \u0026 pre_((calendar.getRegularMonth)year, (month - 1)))","map compatible obligation:(forall year:int \u0026 ((year \u003e\u003d 2000) \u003d\u003e (forall ldom1 in set (dom Year2Holidays), rdom2 in set (dom {year |-\u003e ((japaneseDayoffSet union TR1のsetOfDayOff) union saturdaySet)}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (Year2Holidays(ldom1) \u003d {year |-\u003e ((japaneseDayoffSet union TR1のsetOfDayOff) union saturdaySet)}(rdom2))))))","legal function application obligation:(forall fname:seq of (char) \u0026 pre_(((io.freadval))[(int * int * int)]fname))","type compatibility obligation:is_(RESULT, Date)","type compatibility obligation:(forall fname:seq of (char) \u0026 is_(RESULT, Date))","legal map application obligation:(forall companyCode:seq of (char) \u0026 (forall iTodayOnBusiness4:[Date], iTodayOnCompanyMap5:[map (seq of (char)) to (Date)], timeOfSystem6:[Time] \u0026 (true \u003d\u003e (companyCode in set (dom iTodayOnCompanyMap5)))))","legal function application obligation:pre_(((io.freadval))[Time](homedir ^ \"/temp/SystemTime.txt\"))","type compatibility obligation:(forall iTodayOnBusiness1:[Date], iTodayOnCompanyMap2:[map (seq of (char)) to (Date)], timeOfSystem3:[Time] \u0026 (true \u003d\u003e is_(RESULT, Time)))","legal function application obligation:(forall cal:Calendar, year:int, month:int, 日:int, 時:nat, aMinute:nat, aSecond:nat, milliSecond:nat \u0026 pre_((self.IntProduct2TimeMillieSeconds)時, aMinute, aSecond, milliSecond))","type compatibility obligation:(forall cal:Calendar, year:int, month:int, 日:int, 時:nat, aMinute:nat, aSecond:nat, milliSecond:nat \u0026 is_((self.IntProduct2TimeMillieSeconds)(時, aMinute, aSecond, milliSecond), nat))","legal function application obligation:(forall cal:Calendar, year:int, month:int, 日:int \u0026 pre_((self.IntProduct2TimeMillieSeconds)0, 0, 0, 0))","type compatibility obligation:(forall cal:Calendar, year:int, month:int, 日:int \u0026 is_((self.IntProduct2TimeMillieSeconds)(0, 0, 0, 0), nat))","legal function application obligation:(forall aDate:Date \u0026 pre_((self.IntProduct2TimeMillieSeconds)0, 0, 0, 0))","type compatibility obligation:(forall aDate:Date \u0026 is_((self.IntProduct2TimeMillieSeconds)(0, 0, 0, 0), nat))","legal function application obligation:(forall dateFileName:seq of (char), 時間fname:seq of (char), cal:Calendar \u0026 pre_(((io.freadval))[(int * int * int * int)]時間fname))","legal function application obligation:(forall dateFileName:seq of (char), 時間fname:seq of (char), cal:Calendar \u0026 pre_((d.Year)))","legal function application obligation:(forall dateFileName:seq of (char), 時間fname:seq of (char), cal:Calendar \u0026 pre_((d.Month)))","legal function application obligation:(forall dateFileName:seq of (char), 時間fname:seq of (char), cal:Calendar \u0026 pre_((d.day)))","legal function application obligation:pre_((self.Time2IntProduct)(self.getTime)())","legal function application obligation:(forall aTime:nat \u0026 pre_((self.Time2IntProduct)(self.getTime)()))","legal function application obligation:pre_((self.Time2IntProduct)(self.getTime)())","legal function application obligation:(forall minute:nat \u0026 pre_((self.Time2IntProduct)(self.getTime)()))","legal function application obligation:pre_((self.Time2IntProduct)(self.getTime)())","legal function application obligation:(forall aSecond:nat \u0026 pre_((self.Time2IntProduct)(self.getTime)()))","legal function application obligation:pre_((self.Time2IntProduct)(self.getTime)())","legal function application obligation:(forall aMilliSecond:nat \u0026 pre_((self.Time2IntProduct)(self.getTime)()))","legal function application obligation:pre_((((self.getDate)().calendar)().Year)(self.getDate)())","legal function application obligation:pre_((((self.getDate)().calendar)().Month)(self.getDate)())","legal function application obligation:pre_((((self.getDate)().calendar)().day)(self.getDate)())","legal function application obligation:(forall aTime:Time \u0026 let date1:int \u003d (floor ((self.getDate)().getModifiedJulianDate)()), date2:int \u003d (floor ((aTime.getDate)().getModifiedJulianDate)()) in ((not ((date1 \u003c date2) \u003d true)) \u003d\u003e (((date1 \u003d date2) \u003d true) \u003d\u003e pre_((self.getTimeAsNat)))))","legal function application obligation:(forall aTime:Time \u0026 let date1:int \u003d (floor ((self.getDate)().getModifiedJulianDate)()), date2:int \u003d (floor ((aTime.getDate)().getModifiedJulianDate)()) in ((not ((date1 \u003c date2) \u003d true)) \u003d\u003e (((date1 \u003d date2) \u003d true) \u003d\u003e pre_((aTime.getTimeAsNat)))))","legal function application obligation:(forall aTime:Time \u0026 pre_((self.LT)aTime))","legal function application obligation:(forall aTime:Time \u0026 ((not (self.LT)(aTime)) \u003d\u003e pre_((self.EQ)aTime)))","legal function application obligation:(forall aTime:Time \u0026 pre_((self.GT)aTime))","legal function application obligation:(forall aTime:Time \u0026 pre_((self.LT)aTime))","legal function application obligation:(forall aTime:Time \u0026 (((self.getDate)().EQ)((aTime.getDate)()) \u003d\u003e pre_((self.getTimeAsNat))))","legal function application obligation:(forall aTime:Time \u0026 (((self.getDate)().EQ)((aTime.getDate)()) \u003d\u003e pre_((aTime.getTimeAsNat))))","legal function application obligation:(forall aTime:Time \u0026 pre_((self.EQ)aTime))","non-zero obligation:(forall aTime:TimeInMilliSeconds \u0026 (ミリ \u003c\u003e 0))","non-zero obligation:(forall aTime:TimeInMilliSeconds \u0026 (secondsPerMinute \u003c\u003e 0))","non-zero obligation:(forall aTime:TimeInMilliSeconds \u0026 (minutesPerHour \u003c\u003e 0))","type compatibility obligation:(forall aTime:TimeInMilliSeconds \u0026 is_(let hms:int \u003d (aTime div ミリ), milliSecond:int \u003d (aTime mod ミリ), hm:int \u003d (hms div secondsPerMinute), aSecond:int \u003d (hms mod secondsPerMinute), hour:int \u003d (hm div minutesPerHour), aMinute:int \u003d (hm mod minutesPerHour) in mk_(hour, aMinute, aSecond, milliSecond), (nat * nat * nat * nat)))","legal function application obligation:pre_((self.Time2IntProduct)(self.getTime)())","legal function application obligation:pre_(Integer`asStringZ(\"009\")milliSecond)","legal function application obligation:pre_((self.Time2IntProduct)(self.getTime)())","legal function application obligation:pre_(Integer`asStringZ(\"009\")milliSecond)","non-zero obligation:(forall aMilliSecond:int \u0026 ((time \u003e\u003d 0) \u003d\u003e (milliSecondsPerDay \u003c\u003e 0)))","non-zero obligation:(forall aMilliSecond:int \u0026 ((not (time \u003e\u003d 0)) \u003d\u003e (milliSecondsPerDay \u003c\u003e 0)))","legal function application obligation:(forall aMilliSecond:int \u0026 pre_((self.calendar)))","legal function application obligation:(forall aMilliSecond:int \u0026 pre_((self.Year)))","legal function application obligation:(forall aMilliSecond:int \u0026 pre_((self.Month)))","legal function application obligation:(forall aMilliSecond:int \u0026 pre_((self.day)))","legal function application obligation:(((c.todayOnBusiness)().EQ)((c.getDateFrom_yyyy_mm_dd)(2001, 9, 12)) \u003d\u003e pre_((c.isDateNil)nil))","legal function application obligation:(((c.todayOnBusiness)().EQ)((c.getDateFrom_yyyy_mm_dd)(2001, 9, 12)) \u003d\u003e (((c.isDateNil)(nil) \u003d true) \u003d\u003e pre_((c.isDateNil)(c.todayOnBusiness)())))","legal function application obligation:(((c.todayOnBusiness)().EQ)((c.getDateFrom_yyyy_mm_dd)(2001, 9, 12)) \u003d\u003e (((c.isDateNil)(nil) \u003d true) \u003d\u003e (((c.isDateNil)((c.todayOnBusiness)()) \u003d false) \u003d\u003e pre_((c.systemDate)))))","legal function application obligation:(((c.todayOnBusiness)().EQ)((c.getDateFrom_yyyy_mm_dd)(2001, 9, 12)) \u003d\u003e (((c.isDateNil)(nil) \u003d true) \u003d\u003e (((c.isDateNil)((c.todayOnBusiness)()) \u003d false) \u003d\u003e (((c.systemDate)().EQ)((c.today)()) \u003d\u003e pre_(((c.systemTime)().EQ)new Time(c, 2003, 10, 23, 13, 12, 34, 567))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:(forall dayOff in set setOfDayOff \u0026 pre_((jc.getYyyymmdd)dayOff))","legal function application obligation:(forall dayOff in set setOfDayOff2006 \u0026 pre_((jc.getYyyymmdd)dayOff))","legal function application obligation:((setOfDayOffBy_yyyy_mm_dd \u003d {mk_(2001, 1, 1), mk_(2001, 1, 2), mk_(2001, 1, 3), mk_(2001, 1, 6), mk_(2001, 1, 8), mk_(2001, 1, 13), mk_(2001, 1, 20), mk_(2001, 1, 27), mk_(2001, 2, 3), mk_(2001, 2, 10), mk_(2001, 2, 11), mk_(2001, 2, 12), mk_(2001, 2, 17), mk_(2001, 2, 24), mk_(2001, 3, 3), mk_(2001, 3, 10), mk_(2001, 3, 17), mk_(2001, 3, 20), mk_(2001, 3, 24), mk_(2001, 3, 31), mk_(2001, 4, 7), mk_(2001, 4, 14), mk_(2001, 4, 21), mk_(2001, 4, 28), mk_(2001, 4, 29), mk_(2001, 4, 30), mk_(2001, 5, 3), mk_(2001, 5, 4), mk_(2001, 5, 5), mk_(2001, 5, 12), mk_(2001, 5, 19), mk_(2001, 5, 26), mk_(2001, 6, 2), mk_(2001, 6, 9), mk_(2001, 6, 16), mk_(2001, 6, 23), mk_(2001, 6, 30), mk_(2001, 7, 7), mk_(2001, 7, 14), mk_(2001, 7, 20), mk_(2001, 7, 21), mk_(2001, 7, 28), mk_(2001, 8, 4), mk_(2001, 8, 11), mk_(2001, 8, 18), mk_(2001, 8, 25), mk_(2001, 9, 1), mk_(2001, 9, 8), mk_(2001, 9, 15), mk_(2001, 9, 22), mk_(2001, 9, 23), mk_(2001, 9, 24), mk_(2001, 9, 29), mk_(2001, 10, 6), mk_(2001, 10, 8), mk_(2001, 10, 13), mk_(2001, 10, 20), mk_(2001, 10, 27), mk_(2001, 11, 3), mk_(2001, 11, 10), mk_(2001, 11, 17), mk_(2001, 11, 23), mk_(2001, 11, 24), mk_(2001, 12, 1), mk_(2001, 12, 8), mk_(2001, 12, 15), mk_(2001, 12, 22), mk_(2001, 12, 23), mk_(2001, 12, 24), mk_(2001, 12, 29), mk_(2001, 12, 30), mk_(2001, 12, 31)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_dd2006 \u003d {mk_(2006, 1, 1), mk_(2006, 1, 2), mk_(2006, 1, 3), mk_(2006, 1, 7), mk_(2006, 1, 9), mk_(2006, 1, 14), mk_(2006, 1, 21), mk_(2006, 1, 28), mk_(2006, 2, 4), mk_(2006, 2, 11), mk_(2006, 2, 18), mk_(2006, 2, 25), mk_(2006, 3, 4), mk_(2006, 3, 11), mk_(2006, 3, 18), mk_(2006, 3, 21), mk_(2006, 3, 25), mk_(2006, 4, 1), mk_(2006, 4, 8), mk_(2006, 4, 15), mk_(2006, 4, 22), mk_(2006, 4, 29), mk_(2006, 5, 3), mk_(2006, 5, 4), mk_(2006, 5, 5), mk_(2006, 5, 6), mk_(2006, 5, 13), mk_(2006, 5, 20), mk_(2006, 5, 27), mk_(2006, 6, 3), mk_(2006, 6, 10), mk_(2006, 6, 17), mk_(2006, 6, 24), mk_(2006, 7, 1), mk_(2006, 7, 8), mk_(2006, 7, 15), mk_(2006, 7, 17), mk_(2006, 7, 22), mk_(2006, 7, 29), mk_(2006, 8, 5), mk_(2006, 8, 12), mk_(2006, 8, 19), mk_(2006, 8, 26), mk_(2006, 9, 2), mk_(2006, 9, 9), mk_(2006, 9, 16), mk_(2006, 9, 18), mk_(2006, 9, 23), mk_(2006, 9, 30), mk_(2006, 10, 7), mk_(2006, 10, 9), mk_(2006, 10, 14), mk_(2006, 10, 21), mk_(2006, 10, 28), mk_(2006, 11, 3), mk_(2006, 11, 4), mk_(2006, 11, 11), mk_(2006, 11, 18), mk_(2006, 11, 23), mk_(2006, 11, 25), mk_(2006, 12, 2), mk_(2006, 12, 9), mk_(2006, 12, 16), mk_(2006, 12, 23), mk_(2006, 12, 29), mk_(2006, 12, 30), mk_(2006, 12, 31)}) \u003d\u003e pre_((jc.getDayOffsExceptSunday)d0401, d0430)))","type compatibility obligation:((setOfDayOffBy_yyyy_mm_dd \u003d {mk_(2001, 1, 1), mk_(2001, 1, 2), mk_(2001, 1, 3), mk_(2001, 1, 6), mk_(2001, 1, 8), mk_(2001, 1, 13), mk_(2001, 1, 20), mk_(2001, 1, 27), mk_(2001, 2, 3), mk_(2001, 2, 10), mk_(2001, 2, 11), mk_(2001, 2, 12), mk_(2001, 2, 17), mk_(2001, 2, 24), mk_(2001, 3, 3), mk_(2001, 3, 10), mk_(2001, 3, 17), mk_(2001, 3, 20), mk_(2001, 3, 24), mk_(2001, 3, 31), mk_(2001, 4, 7), mk_(2001, 4, 14), mk_(2001, 4, 21), mk_(2001, 4, 28), mk_(2001, 4, 29), mk_(2001, 4, 30), mk_(2001, 5, 3), mk_(2001, 5, 4), mk_(2001, 5, 5), mk_(2001, 5, 12), mk_(2001, 5, 19), mk_(2001, 5, 26), mk_(2001, 6, 2), mk_(2001, 6, 9), mk_(2001, 6, 16), mk_(2001, 6, 23), mk_(2001, 6, 30), mk_(2001, 7, 7), mk_(2001, 7, 14), mk_(2001, 7, 20), mk_(2001, 7, 21), mk_(2001, 7, 28), mk_(2001, 8, 4), mk_(2001, 8, 11), mk_(2001, 8, 18), mk_(2001, 8, 25), mk_(2001, 9, 1), mk_(2001, 9, 8), mk_(2001, 9, 15), mk_(2001, 9, 22), mk_(2001, 9, 23), mk_(2001, 9, 24), mk_(2001, 9, 29), mk_(2001, 10, 6), mk_(2001, 10, 8), mk_(2001, 10, 13), mk_(2001, 10, 20), mk_(2001, 10, 27), mk_(2001, 11, 3), mk_(2001, 11, 10), mk_(2001, 11, 17), mk_(2001, 11, 23), mk_(2001, 11, 24), mk_(2001, 12, 1), mk_(2001, 12, 8), mk_(2001, 12, 15), mk_(2001, 12, 22), mk_(2001, 12, 23), mk_(2001, 12, 24), mk_(2001, 12, 29), mk_(2001, 12, 30), mk_(2001, 12, 31)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_dd2006 \u003d {mk_(2006, 1, 1), mk_(2006, 1, 2), mk_(2006, 1, 3), mk_(2006, 1, 7), mk_(2006, 1, 9), mk_(2006, 1, 14), mk_(2006, 1, 21), mk_(2006, 1, 28), mk_(2006, 2, 4), mk_(2006, 2, 11), mk_(2006, 2, 18), mk_(2006, 2, 25), mk_(2006, 3, 4), mk_(2006, 3, 11), mk_(2006, 3, 18), mk_(2006, 3, 21), mk_(2006, 3, 25), mk_(2006, 4, 1), mk_(2006, 4, 8), mk_(2006, 4, 15), mk_(2006, 4, 22), mk_(2006, 4, 29), mk_(2006, 5, 3), mk_(2006, 5, 4), mk_(2006, 5, 5), mk_(2006, 5, 6), mk_(2006, 5, 13), mk_(2006, 5, 20), mk_(2006, 5, 27), mk_(2006, 6, 3), mk_(2006, 6, 10), mk_(2006, 6, 17), mk_(2006, 6, 24), mk_(2006, 7, 1), mk_(2006, 7, 8), mk_(2006, 7, 15), mk_(2006, 7, 17), mk_(2006, 7, 22), mk_(2006, 7, 29), mk_(2006, 8, 5), mk_(2006, 8, 12), mk_(2006, 8, 19), mk_(2006, 8, 26), mk_(2006, 9, 2), mk_(2006, 9, 9), mk_(2006, 9, 16), mk_(2006, 9, 18), mk_(2006, 9, 23), mk_(2006, 9, 30), mk_(2006, 10, 7), mk_(2006, 10, 9), mk_(2006, 10, 14), mk_(2006, 10, 21), mk_(2006, 10, 28), mk_(2006, 11, 3), mk_(2006, 11, 4), mk_(2006, 11, 11), mk_(2006, 11, 18), mk_(2006, 11, 23), mk_(2006, 11, 25), mk_(2006, 12, 2), mk_(2006, 12, 9), mk_(2006, 12, 16), mk_(2006, 12, 23), mk_(2006, 12, 29), mk_(2006, 12, 30), mk_(2006, 12, 31)}) \u003d\u003e is_(d0401, Date)))","type compatibility obligation:((setOfDayOffBy_yyyy_mm_dd \u003d {mk_(2001, 1, 1), mk_(2001, 1, 2), mk_(2001, 1, 3), mk_(2001, 1, 6), mk_(2001, 1, 8), mk_(2001, 1, 13), mk_(2001, 1, 20), mk_(2001, 1, 27), mk_(2001, 2, 3), mk_(2001, 2, 10), mk_(2001, 2, 11), mk_(2001, 2, 12), mk_(2001, 2, 17), mk_(2001, 2, 24), mk_(2001, 3, 3), mk_(2001, 3, 10), mk_(2001, 3, 17), mk_(2001, 3, 20), mk_(2001, 3, 24), mk_(2001, 3, 31), mk_(2001, 4, 7), mk_(2001, 4, 14), mk_(2001, 4, 21), mk_(2001, 4, 28), mk_(2001, 4, 29), mk_(2001, 4, 30), mk_(2001, 5, 3), mk_(2001, 5, 4), mk_(2001, 5, 5), mk_(2001, 5, 12), mk_(2001, 5, 19), mk_(2001, 5, 26), mk_(2001, 6, 2), mk_(2001, 6, 9), mk_(2001, 6, 16), mk_(2001, 6, 23), mk_(2001, 6, 30), mk_(2001, 7, 7), mk_(2001, 7, 14), mk_(2001, 7, 20), mk_(2001, 7, 21), mk_(2001, 7, 28), mk_(2001, 8, 4), mk_(2001, 8, 11), mk_(2001, 8, 18), mk_(2001, 8, 25), mk_(2001, 9, 1), mk_(2001, 9, 8), mk_(2001, 9, 15), mk_(2001, 9, 22), mk_(2001, 9, 23), mk_(2001, 9, 24), mk_(2001, 9, 29), mk_(2001, 10, 6), mk_(2001, 10, 8), mk_(2001, 10, 13), mk_(2001, 10, 20), mk_(2001, 10, 27), mk_(2001, 11, 3), mk_(2001, 11, 10), mk_(2001, 11, 17), mk_(2001, 11, 23), mk_(2001, 11, 24), mk_(2001, 12, 1), mk_(2001, 12, 8), mk_(2001, 12, 15), mk_(2001, 12, 22), mk_(2001, 12, 23), mk_(2001, 12, 24), mk_(2001, 12, 29), mk_(2001, 12, 30), mk_(2001, 12, 31)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_dd2006 \u003d {mk_(2006, 1, 1), mk_(2006, 1, 2), mk_(2006, 1, 3), mk_(2006, 1, 7), mk_(2006, 1, 9), mk_(2006, 1, 14), mk_(2006, 1, 21), mk_(2006, 1, 28), mk_(2006, 2, 4), mk_(2006, 2, 11), mk_(2006, 2, 18), mk_(2006, 2, 25), mk_(2006, 3, 4), mk_(2006, 3, 11), mk_(2006, 3, 18), mk_(2006, 3, 21), mk_(2006, 3, 25), mk_(2006, 4, 1), mk_(2006, 4, 8), mk_(2006, 4, 15), mk_(2006, 4, 22), mk_(2006, 4, 29), mk_(2006, 5, 3), mk_(2006, 5, 4), mk_(2006, 5, 5), mk_(2006, 5, 6), mk_(2006, 5, 13), mk_(2006, 5, 20), mk_(2006, 5, 27), mk_(2006, 6, 3), mk_(2006, 6, 10), mk_(2006, 6, 17), mk_(2006, 6, 24), mk_(2006, 7, 1), mk_(2006, 7, 8), mk_(2006, 7, 15), mk_(2006, 7, 17), mk_(2006, 7, 22), mk_(2006, 7, 29), mk_(2006, 8, 5), mk_(2006, 8, 12), mk_(2006, 8, 19), mk_(2006, 8, 26), mk_(2006, 9, 2), mk_(2006, 9, 9), mk_(2006, 9, 16), mk_(2006, 9, 18), mk_(2006, 9, 23), mk_(2006, 9, 30), mk_(2006, 10, 7), mk_(2006, 10, 9), mk_(2006, 10, 14), mk_(2006, 10, 21), mk_(2006, 10, 28), mk_(2006, 11, 3), mk_(2006, 11, 4), mk_(2006, 11, 11), mk_(2006, 11, 18), mk_(2006, 11, 23), mk_(2006, 11, 25), mk_(2006, 12, 2), mk_(2006, 12, 9), mk_(2006, 12, 16), mk_(2006, 12, 23), mk_(2006, 12, 29), mk_(2006, 12, 30), mk_(2006, 12, 31)}) \u003d\u003e is_(d0430, Date)))","legal function application obligation:((setOfDayOffBy_yyyy_mm_dd \u003d {mk_(2001, 1, 1), mk_(2001, 1, 2), mk_(2001, 1, 3), mk_(2001, 1, 6), mk_(2001, 1, 8), mk_(2001, 1, 13), mk_(2001, 1, 20), mk_(2001, 1, 27), mk_(2001, 2, 3), mk_(2001, 2, 10), mk_(2001, 2, 11), mk_(2001, 2, 12), mk_(2001, 2, 17), mk_(2001, 2, 24), mk_(2001, 3, 3), mk_(2001, 3, 10), mk_(2001, 3, 17), mk_(2001, 3, 20), mk_(2001, 3, 24), mk_(2001, 3, 31), mk_(2001, 4, 7), mk_(2001, 4, 14), mk_(2001, 4, 21), mk_(2001, 4, 28), mk_(2001, 4, 29), mk_(2001, 4, 30), mk_(2001, 5, 3), mk_(2001, 5, 4), mk_(2001, 5, 5), mk_(2001, 5, 12), mk_(2001, 5, 19), mk_(2001, 5, 26), mk_(2001, 6, 2), mk_(2001, 6, 9), mk_(2001, 6, 16), mk_(2001, 6, 23), mk_(2001, 6, 30), mk_(2001, 7, 7), mk_(2001, 7, 14), mk_(2001, 7, 20), mk_(2001, 7, 21), mk_(2001, 7, 28), mk_(2001, 8, 4), mk_(2001, 8, 11), mk_(2001, 8, 18), mk_(2001, 8, 25), mk_(2001, 9, 1), mk_(2001, 9, 8), mk_(2001, 9, 15), mk_(2001, 9, 22), mk_(2001, 9, 23), mk_(2001, 9, 24), mk_(2001, 9, 29), mk_(2001, 10, 6), mk_(2001, 10, 8), mk_(2001, 10, 13), mk_(2001, 10, 20), mk_(2001, 10, 27), mk_(2001, 11, 3), mk_(2001, 11, 10), mk_(2001, 11, 17), mk_(2001, 11, 23), mk_(2001, 11, 24), mk_(2001, 12, 1), mk_(2001, 12, 8), mk_(2001, 12, 15), mk_(2001, 12, 22), mk_(2001, 12, 23), mk_(2001, 12, 24), mk_(2001, 12, 29), mk_(2001, 12, 30), mk_(2001, 12, 31)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_dd2006 \u003d {mk_(2006, 1, 1), mk_(2006, 1, 2), mk_(2006, 1, 3), mk_(2006, 1, 7), mk_(2006, 1, 9), mk_(2006, 1, 14), mk_(2006, 1, 21), mk_(2006, 1, 28), mk_(2006, 2, 4), mk_(2006, 2, 11), mk_(2006, 2, 18), mk_(2006, 2, 25), mk_(2006, 3, 4), mk_(2006, 3, 11), mk_(2006, 3, 18), mk_(2006, 3, 21), mk_(2006, 3, 25), mk_(2006, 4, 1), mk_(2006, 4, 8), mk_(2006, 4, 15), mk_(2006, 4, 22), mk_(2006, 4, 29), mk_(2006, 5, 3), mk_(2006, 5, 4), mk_(2006, 5, 5), mk_(2006, 5, 6), mk_(2006, 5, 13), mk_(2006, 5, 20), mk_(2006, 5, 27), mk_(2006, 6, 3), mk_(2006, 6, 10), mk_(2006, 6, 17), mk_(2006, 6, 24), mk_(2006, 7, 1), mk_(2006, 7, 8), mk_(2006, 7, 15), mk_(2006, 7, 17), mk_(2006, 7, 22), mk_(2006, 7, 29), mk_(2006, 8, 5), mk_(2006, 8, 12), mk_(2006, 8, 19), mk_(2006, 8, 26), mk_(2006, 9, 2), mk_(2006, 9, 9), mk_(2006, 9, 16), mk_(2006, 9, 18), mk_(2006, 9, 23), mk_(2006, 9, 30), mk_(2006, 10, 7), mk_(2006, 10, 9), mk_(2006, 10, 14), mk_(2006, 10, 21), mk_(2006, 10, 28), mk_(2006, 11, 3), mk_(2006, 11, 4), mk_(2006, 11, 11), mk_(2006, 11, 18), mk_(2006, 11, 23), mk_(2006, 11, 25), mk_(2006, 12, 2), mk_(2006, 12, 9), mk_(2006, 12, 16), mk_(2006, 12, 23), mk_(2006, 12, 29), mk_(2006, 12, 30), mk_(2006, 12, 31)}) \u003d\u003e (((jc.getDayOffsExceptSunday)(d0401, d0430) \u003d 6) \u003d\u003e pre_((jc.getDayOffsAndSunday)d0401, d0430))))","type compatibility obligation:((setOfDayOffBy_yyyy_mm_dd \u003d {mk_(2001, 1, 1), mk_(2001, 1, 2), mk_(2001, 1, 3), mk_(2001, 1, 6), mk_(2001, 1, 8), mk_(2001, 1, 13), mk_(2001, 1, 20), mk_(2001, 1, 27), mk_(2001, 2, 3), mk_(2001, 2, 10), mk_(2001, 2, 11), mk_(2001, 2, 12), mk_(2001, 2, 17), mk_(2001, 2, 24), mk_(2001, 3, 3), mk_(2001, 3, 10), mk_(2001, 3, 17), mk_(2001, 3, 20), mk_(2001, 3, 24), mk_(2001, 3, 31), mk_(2001, 4, 7), mk_(2001, 4, 14), mk_(2001, 4, 21), mk_(2001, 4, 28), mk_(2001, 4, 29), mk_(2001, 4, 30), mk_(2001, 5, 3), mk_(2001, 5, 4), mk_(2001, 5, 5), mk_(2001, 5, 12), mk_(2001, 5, 19), mk_(2001, 5, 26), mk_(2001, 6, 2), mk_(2001, 6, 9), mk_(2001, 6, 16), mk_(2001, 6, 23), mk_(2001, 6, 30), mk_(2001, 7, 7), mk_(2001, 7, 14), mk_(2001, 7, 20), mk_(2001, 7, 21), mk_(2001, 7, 28), mk_(2001, 8, 4), mk_(2001, 8, 11), mk_(2001, 8, 18), mk_(2001, 8, 25), mk_(2001, 9, 1), mk_(2001, 9, 8), mk_(2001, 9, 15), mk_(2001, 9, 22), mk_(2001, 9, 23), mk_(2001, 9, 24), mk_(2001, 9, 29), mk_(2001, 10, 6), mk_(2001, 10, 8), mk_(2001, 10, 13), mk_(2001, 10, 20), mk_(2001, 10, 27), mk_(2001, 11, 3), mk_(2001, 11, 10), mk_(2001, 11, 17), mk_(2001, 11, 23), mk_(2001, 11, 24), mk_(2001, 12, 1), mk_(2001, 12, 8), mk_(2001, 12, 15), mk_(2001, 12, 22), mk_(2001, 12, 23), mk_(2001, 12, 24), mk_(2001, 12, 29), mk_(2001, 12, 30), mk_(2001, 12, 31)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_dd2006 \u003d {mk_(2006, 1, 1), mk_(2006, 1, 2), mk_(2006, 1, 3), mk_(2006, 1, 7), mk_(2006, 1, 9), mk_(2006, 1, 14), mk_(2006, 1, 21), mk_(2006, 1, 28), mk_(2006, 2, 4), mk_(2006, 2, 11), mk_(2006, 2, 18), mk_(2006, 2, 25), mk_(2006, 3, 4), mk_(2006, 3, 11), mk_(2006, 3, 18), mk_(2006, 3, 21), mk_(2006, 3, 25), mk_(2006, 4, 1), mk_(2006, 4, 8), mk_(2006, 4, 15), mk_(2006, 4, 22), mk_(2006, 4, 29), mk_(2006, 5, 3), mk_(2006, 5, 4), mk_(2006, 5, 5), mk_(2006, 5, 6), mk_(2006, 5, 13), mk_(2006, 5, 20), mk_(2006, 5, 27), mk_(2006, 6, 3), mk_(2006, 6, 10), mk_(2006, 6, 17), mk_(2006, 6, 24), mk_(2006, 7, 1), mk_(2006, 7, 8), mk_(2006, 7, 15), mk_(2006, 7, 17), mk_(2006, 7, 22), mk_(2006, 7, 29), mk_(2006, 8, 5), mk_(2006, 8, 12), mk_(2006, 8, 19), mk_(2006, 8, 26), mk_(2006, 9, 2), mk_(2006, 9, 9), mk_(2006, 9, 16), mk_(2006, 9, 18), mk_(2006, 9, 23), mk_(2006, 9, 30), mk_(2006, 10, 7), mk_(2006, 10, 9), mk_(2006, 10, 14), mk_(2006, 10, 21), mk_(2006, 10, 28), mk_(2006, 11, 3), mk_(2006, 11, 4), mk_(2006, 11, 11), mk_(2006, 11, 18), mk_(2006, 11, 23), mk_(2006, 11, 25), mk_(2006, 12, 2), mk_(2006, 12, 9), mk_(2006, 12, 16), mk_(2006, 12, 23), mk_(2006, 12, 29), mk_(2006, 12, 30), mk_(2006, 12, 31)}) \u003d\u003e (((jc.getDayOffsExceptSunday)(d0401, d0430) \u003d 6) \u003d\u003e is_(d0401, Date))))","type compatibility obligation:((setOfDayOffBy_yyyy_mm_dd \u003d {mk_(2001, 1, 1), mk_(2001, 1, 2), mk_(2001, 1, 3), mk_(2001, 1, 6), mk_(2001, 1, 8), mk_(2001, 1, 13), mk_(2001, 1, 20), mk_(2001, 1, 27), mk_(2001, 2, 3), mk_(2001, 2, 10), mk_(2001, 2, 11), mk_(2001, 2, 12), mk_(2001, 2, 17), mk_(2001, 2, 24), mk_(2001, 3, 3), mk_(2001, 3, 10), mk_(2001, 3, 17), mk_(2001, 3, 20), mk_(2001, 3, 24), mk_(2001, 3, 31), mk_(2001, 4, 7), mk_(2001, 4, 14), mk_(2001, 4, 21), mk_(2001, 4, 28), mk_(2001, 4, 29), mk_(2001, 4, 30), mk_(2001, 5, 3), mk_(2001, 5, 4), mk_(2001, 5, 5), mk_(2001, 5, 12), mk_(2001, 5, 19), mk_(2001, 5, 26), mk_(2001, 6, 2), mk_(2001, 6, 9), mk_(2001, 6, 16), mk_(2001, 6, 23), mk_(2001, 6, 30), mk_(2001, 7, 7), mk_(2001, 7, 14), mk_(2001, 7, 20), mk_(2001, 7, 21), mk_(2001, 7, 28), mk_(2001, 8, 4), mk_(2001, 8, 11), mk_(2001, 8, 18), mk_(2001, 8, 25), mk_(2001, 9, 1), mk_(2001, 9, 8), mk_(2001, 9, 15), mk_(2001, 9, 22), mk_(2001, 9, 23), mk_(2001, 9, 24), mk_(2001, 9, 29), mk_(2001, 10, 6), mk_(2001, 10, 8), mk_(2001, 10, 13), mk_(2001, 10, 20), mk_(2001, 10, 27), mk_(2001, 11, 3), mk_(2001, 11, 10), mk_(2001, 11, 17), mk_(2001, 11, 23), mk_(2001, 11, 24), mk_(2001, 12, 1), mk_(2001, 12, 8), mk_(2001, 12, 15), mk_(2001, 12, 22), mk_(2001, 12, 23), mk_(2001, 12, 24), mk_(2001, 12, 29), mk_(2001, 12, 30), mk_(2001, 12, 31)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_dd2006 \u003d {mk_(2006, 1, 1), mk_(2006, 1, 2), mk_(2006, 1, 3), mk_(2006, 1, 7), mk_(2006, 1, 9), mk_(2006, 1, 14), mk_(2006, 1, 21), mk_(2006, 1, 28), mk_(2006, 2, 4), mk_(2006, 2, 11), mk_(2006, 2, 18), mk_(2006, 2, 25), mk_(2006, 3, 4), mk_(2006, 3, 11), mk_(2006, 3, 18), mk_(2006, 3, 21), mk_(2006, 3, 25), mk_(2006, 4, 1), mk_(2006, 4, 8), mk_(2006, 4, 15), mk_(2006, 4, 22), mk_(2006, 4, 29), mk_(2006, 5, 3), mk_(2006, 5, 4), mk_(2006, 5, 5), mk_(2006, 5, 6), mk_(2006, 5, 13), mk_(2006, 5, 20), mk_(2006, 5, 27), mk_(2006, 6, 3), mk_(2006, 6, 10), mk_(2006, 6, 17), mk_(2006, 6, 24), mk_(2006, 7, 1), mk_(2006, 7, 8), mk_(2006, 7, 15), mk_(2006, 7, 17), mk_(2006, 7, 22), mk_(2006, 7, 29), mk_(2006, 8, 5), mk_(2006, 8, 12), mk_(2006, 8, 19), mk_(2006, 8, 26), mk_(2006, 9, 2), mk_(2006, 9, 9), mk_(2006, 9, 16), mk_(2006, 9, 18), mk_(2006, 9, 23), mk_(2006, 9, 30), mk_(2006, 10, 7), mk_(2006, 10, 9), mk_(2006, 10, 14), mk_(2006, 10, 21), mk_(2006, 10, 28), mk_(2006, 11, 3), mk_(2006, 11, 4), mk_(2006, 11, 11), mk_(2006, 11, 18), mk_(2006, 11, 23), mk_(2006, 11, 25), mk_(2006, 12, 2), mk_(2006, 12, 9), mk_(2006, 12, 16), mk_(2006, 12, 23), mk_(2006, 12, 29), mk_(2006, 12, 30), mk_(2006, 12, 31)}) \u003d\u003e (((jc.getDayOffsExceptSunday)(d0401, d0430) \u003d 6) \u003d\u003e is_(d0430, Date))))","legal function application obligation:((setOfDayOffBy_yyyy_mm_dd \u003d {mk_(2001, 1, 1), mk_(2001, 1, 2), mk_(2001, 1, 3), mk_(2001, 1, 6), mk_(2001, 1, 8), mk_(2001, 1, 13), mk_(2001, 1, 20), mk_(2001, 1, 27), mk_(2001, 2, 3), mk_(2001, 2, 10), mk_(2001, 2, 11), mk_(2001, 2, 12), mk_(2001, 2, 17), mk_(2001, 2, 24), mk_(2001, 3, 3), mk_(2001, 3, 10), mk_(2001, 3, 17), mk_(2001, 3, 20), mk_(2001, 3, 24), mk_(2001, 3, 31), mk_(2001, 4, 7), mk_(2001, 4, 14), mk_(2001, 4, 21), mk_(2001, 4, 28), mk_(2001, 4, 29), mk_(2001, 4, 30), mk_(2001, 5, 3), mk_(2001, 5, 4), mk_(2001, 5, 5), mk_(2001, 5, 12), mk_(2001, 5, 19), mk_(2001, 5, 26), mk_(2001, 6, 2), mk_(2001, 6, 9), mk_(2001, 6, 16), mk_(2001, 6, 23), mk_(2001, 6, 30), mk_(2001, 7, 7), mk_(2001, 7, 14), mk_(2001, 7, 20), mk_(2001, 7, 21), mk_(2001, 7, 28), mk_(2001, 8, 4), mk_(2001, 8, 11), mk_(2001, 8, 18), mk_(2001, 8, 25), mk_(2001, 9, 1), mk_(2001, 9, 8), mk_(2001, 9, 15), mk_(2001, 9, 22), mk_(2001, 9, 23), mk_(2001, 9, 24), mk_(2001, 9, 29), mk_(2001, 10, 6), mk_(2001, 10, 8), mk_(2001, 10, 13), mk_(2001, 10, 20), mk_(2001, 10, 27), mk_(2001, 11, 3), mk_(2001, 11, 10), mk_(2001, 11, 17), mk_(2001, 11, 23), mk_(2001, 11, 24), mk_(2001, 12, 1), mk_(2001, 12, 8), mk_(2001, 12, 15), mk_(2001, 12, 22), mk_(2001, 12, 23), mk_(2001, 12, 24), mk_(2001, 12, 29), mk_(2001, 12, 30), mk_(2001, 12, 31)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_dd2006 \u003d {mk_(2006, 1, 1), mk_(2006, 1, 2), mk_(2006, 1, 3), mk_(2006, 1, 7), mk_(2006, 1, 9), mk_(2006, 1, 14), mk_(2006, 1, 21), mk_(2006, 1, 28), mk_(2006, 2, 4), mk_(2006, 2, 11), mk_(2006, 2, 18), mk_(2006, 2, 25), mk_(2006, 3, 4), mk_(2006, 3, 11), mk_(2006, 3, 18), mk_(2006, 3, 21), mk_(2006, 3, 25), mk_(2006, 4, 1), mk_(2006, 4, 8), mk_(2006, 4, 15), mk_(2006, 4, 22), mk_(2006, 4, 29), mk_(2006, 5, 3), mk_(2006, 5, 4), mk_(2006, 5, 5), mk_(2006, 5, 6), mk_(2006, 5, 13), mk_(2006, 5, 20), mk_(2006, 5, 27), mk_(2006, 6, 3), mk_(2006, 6, 10), mk_(2006, 6, 17), mk_(2006, 6, 24), mk_(2006, 7, 1), mk_(2006, 7, 8), mk_(2006, 7, 15), mk_(2006, 7, 17), mk_(2006, 7, 22), mk_(2006, 7, 29), mk_(2006, 8, 5), mk_(2006, 8, 12), mk_(2006, 8, 19), mk_(2006, 8, 26), mk_(2006, 9, 2), mk_(2006, 9, 9), mk_(2006, 9, 16), mk_(2006, 9, 18), mk_(2006, 9, 23), mk_(2006, 9, 30), mk_(2006, 10, 7), mk_(2006, 10, 9), mk_(2006, 10, 14), mk_(2006, 10, 21), mk_(2006, 10, 28), mk_(2006, 11, 3), mk_(2006, 11, 4), mk_(2006, 11, 11), mk_(2006, 11, 18), mk_(2006, 11, 23), mk_(2006, 11, 25), mk_(2006, 12, 2), mk_(2006, 12, 9), mk_(2006, 12, 16), mk_(2006, 12, 23), mk_(2006, 12, 29), mk_(2006, 12, 30), mk_(2006, 12, 31)}) \u003d\u003e (((jc.getDayOffsExceptSunday)(d0401, d0430) \u003d 6) \u003d\u003e (((card (jc.getDayOffsAndSunday)(d0401, d0430)) \u003d 1) \u003d\u003e pre_((jc.getDayOffsAndSunday)d0401, d0408)))))","type compatibility obligation:((setOfDayOffBy_yyyy_mm_dd \u003d {mk_(2001, 1, 1), mk_(2001, 1, 2), mk_(2001, 1, 3), mk_(2001, 1, 6), mk_(2001, 1, 8), mk_(2001, 1, 13), mk_(2001, 1, 20), mk_(2001, 1, 27), mk_(2001, 2, 3), mk_(2001, 2, 10), mk_(2001, 2, 11), mk_(2001, 2, 12), mk_(2001, 2, 17), mk_(2001, 2, 24), mk_(2001, 3, 3), mk_(2001, 3, 10), mk_(2001, 3, 17), mk_(2001, 3, 20), mk_(2001, 3, 24), mk_(2001, 3, 31), mk_(2001, 4, 7), mk_(2001, 4, 14), mk_(2001, 4, 21), mk_(2001, 4, 28), mk_(2001, 4, 29), mk_(2001, 4, 30), mk_(2001, 5, 3), mk_(2001, 5, 4), mk_(2001, 5, 5), mk_(2001, 5, 12), mk_(2001, 5, 19), mk_(2001, 5, 26), mk_(2001, 6, 2), mk_(2001, 6, 9), mk_(2001, 6, 16), mk_(2001, 6, 23), mk_(2001, 6, 30), mk_(2001, 7, 7), mk_(2001, 7, 14), mk_(2001, 7, 20), mk_(2001, 7, 21), mk_(2001, 7, 28), mk_(2001, 8, 4), mk_(2001, 8, 11), mk_(2001, 8, 18), mk_(2001, 8, 25), mk_(2001, 9, 1), mk_(2001, 9, 8), mk_(2001, 9, 15), mk_(2001, 9, 22), mk_(2001, 9, 23), mk_(2001, 9, 24), mk_(2001, 9, 29), mk_(2001, 10, 6), mk_(2001, 10, 8), mk_(2001, 10, 13), mk_(2001, 10, 20), mk_(2001, 10, 27), mk_(2001, 11, 3), mk_(2001, 11, 10), mk_(2001, 11, 17), mk_(2001, 11, 23), mk_(2001, 11, 24), mk_(2001, 12, 1), mk_(2001, 12, 8), mk_(2001, 12, 15), mk_(2001, 12, 22), mk_(2001, 12, 23), mk_(2001, 12, 24), mk_(2001, 12, 29), mk_(2001, 12, 30), mk_(2001, 12, 31)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_dd2006 \u003d {mk_(2006, 1, 1), mk_(2006, 1, 2), mk_(2006, 1, 3), mk_(2006, 1, 7), mk_(2006, 1, 9), mk_(2006, 1, 14), mk_(2006, 1, 21), mk_(2006, 1, 28), mk_(2006, 2, 4), mk_(2006, 2, 11), mk_(2006, 2, 18), mk_(2006, 2, 25), mk_(2006, 3, 4), mk_(2006, 3, 11), mk_(2006, 3, 18), mk_(2006, 3, 21), mk_(2006, 3, 25), mk_(2006, 4, 1), mk_(2006, 4, 8), mk_(2006, 4, 15), mk_(2006, 4, 22), mk_(2006, 4, 29), mk_(2006, 5, 3), mk_(2006, 5, 4), mk_(2006, 5, 5), mk_(2006, 5, 6), mk_(2006, 5, 13), mk_(2006, 5, 20), mk_(2006, 5, 27), mk_(2006, 6, 3), mk_(2006, 6, 10), mk_(2006, 6, 17), mk_(2006, 6, 24), mk_(2006, 7, 1), mk_(2006, 7, 8), mk_(2006, 7, 15), mk_(2006, 7, 17), mk_(2006, 7, 22), mk_(2006, 7, 29), mk_(2006, 8, 5), mk_(2006, 8, 12), mk_(2006, 8, 19), mk_(2006, 8, 26), mk_(2006, 9, 2), mk_(2006, 9, 9), mk_(2006, 9, 16), mk_(2006, 9, 18), mk_(2006, 9, 23), mk_(2006, 9, 30), mk_(2006, 10, 7), mk_(2006, 10, 9), mk_(2006, 10, 14), mk_(2006, 10, 21), mk_(2006, 10, 28), mk_(2006, 11, 3), mk_(2006, 11, 4), mk_(2006, 11, 11), mk_(2006, 11, 18), mk_(2006, 11, 23), mk_(2006, 11, 25), mk_(2006, 12, 2), mk_(2006, 12, 9), mk_(2006, 12, 16), mk_(2006, 12, 23), mk_(2006, 12, 29), mk_(2006, 12, 30), mk_(2006, 12, 31)}) \u003d\u003e (((jc.getDayOffsExceptSunday)(d0401, d0430) \u003d 6) \u003d\u003e (((card (jc.getDayOffsAndSunday)(d0401, d0430)) \u003d 1) \u003d\u003e is_(d0401, Date)))))","type compatibility obligation:((setOfDayOffBy_yyyy_mm_dd \u003d {mk_(2001, 1, 1), mk_(2001, 1, 2), mk_(2001, 1, 3), mk_(2001, 1, 6), mk_(2001, 1, 8), mk_(2001, 1, 13), mk_(2001, 1, 20), mk_(2001, 1, 27), mk_(2001, 2, 3), mk_(2001, 2, 10), mk_(2001, 2, 11), mk_(2001, 2, 12), mk_(2001, 2, 17), mk_(2001, 2, 24), mk_(2001, 3, 3), mk_(2001, 3, 10), mk_(2001, 3, 17), mk_(2001, 3, 20), mk_(2001, 3, 24), mk_(2001, 3, 31), mk_(2001, 4, 7), mk_(2001, 4, 14), mk_(2001, 4, 21), mk_(2001, 4, 28), mk_(2001, 4, 29), mk_(2001, 4, 30), mk_(2001, 5, 3), mk_(2001, 5, 4), mk_(2001, 5, 5), mk_(2001, 5, 12), mk_(2001, 5, 19), mk_(2001, 5, 26), mk_(2001, 6, 2), mk_(2001, 6, 9), mk_(2001, 6, 16), mk_(2001, 6, 23), mk_(2001, 6, 30), mk_(2001, 7, 7), mk_(2001, 7, 14), mk_(2001, 7, 20), mk_(2001, 7, 21), mk_(2001, 7, 28), mk_(2001, 8, 4), mk_(2001, 8, 11), mk_(2001, 8, 18), mk_(2001, 8, 25), mk_(2001, 9, 1), mk_(2001, 9, 8), mk_(2001, 9, 15), mk_(2001, 9, 22), mk_(2001, 9, 23), mk_(2001, 9, 24), mk_(2001, 9, 29), mk_(2001, 10, 6), mk_(2001, 10, 8), mk_(2001, 10, 13), mk_(2001, 10, 20), mk_(2001, 10, 27), mk_(2001, 11, 3), mk_(2001, 11, 10), mk_(2001, 11, 17), mk_(2001, 11, 23), mk_(2001, 11, 24), mk_(2001, 12, 1), mk_(2001, 12, 8), mk_(2001, 12, 15), mk_(2001, 12, 22), mk_(2001, 12, 23), mk_(2001, 12, 24), mk_(2001, 12, 29), mk_(2001, 12, 30), mk_(2001, 12, 31)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_dd2006 \u003d {mk_(2006, 1, 1), mk_(2006, 1, 2), mk_(2006, 1, 3), mk_(2006, 1, 7), mk_(2006, 1, 9), mk_(2006, 1, 14), mk_(2006, 1, 21), mk_(2006, 1, 28), mk_(2006, 2, 4), mk_(2006, 2, 11), mk_(2006, 2, 18), mk_(2006, 2, 25), mk_(2006, 3, 4), mk_(2006, 3, 11), mk_(2006, 3, 18), mk_(2006, 3, 21), mk_(2006, 3, 25), mk_(2006, 4, 1), mk_(2006, 4, 8), mk_(2006, 4, 15), mk_(2006, 4, 22), mk_(2006, 4, 29), mk_(2006, 5, 3), mk_(2006, 5, 4), mk_(2006, 5, 5), mk_(2006, 5, 6), mk_(2006, 5, 13), mk_(2006, 5, 20), mk_(2006, 5, 27), mk_(2006, 6, 3), mk_(2006, 6, 10), mk_(2006, 6, 17), mk_(2006, 6, 24), mk_(2006, 7, 1), mk_(2006, 7, 8), mk_(2006, 7, 15), mk_(2006, 7, 17), mk_(2006, 7, 22), mk_(2006, 7, 29), mk_(2006, 8, 5), mk_(2006, 8, 12), mk_(2006, 8, 19), mk_(2006, 8, 26), mk_(2006, 9, 2), mk_(2006, 9, 9), mk_(2006, 9, 16), mk_(2006, 9, 18), mk_(2006, 9, 23), mk_(2006, 9, 30), mk_(2006, 10, 7), mk_(2006, 10, 9), mk_(2006, 10, 14), mk_(2006, 10, 21), mk_(2006, 10, 28), mk_(2006, 11, 3), mk_(2006, 11, 4), mk_(2006, 11, 11), mk_(2006, 11, 18), mk_(2006, 11, 23), mk_(2006, 11, 25), mk_(2006, 12, 2), mk_(2006, 12, 9), mk_(2006, 12, 16), mk_(2006, 12, 23), mk_(2006, 12, 29), mk_(2006, 12, 30), mk_(2006, 12, 31)}) \u003d\u003e (((jc.getDayOffsExceptSunday)(d0401, d0430) \u003d 6) \u003d\u003e (((card (jc.getDayOffsAndSunday)(d0401, d0430)) \u003d 1) \u003d\u003e is_(d0408, Date)))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((c.getExerciseDate)\"200111\")","legal function application obligation:(((c.getExerciseDate)(\"200111\").EQ)((c.getDateFrom_yyyy_mm_dd)(2001, 11, 9)) \u003d\u003e pre_((c.getExerciseDate)\"200109\"))","legal function application obligation:(((c.getExerciseDate)(\"200111\").EQ)((c.getDateFrom_yyyy_mm_dd)(2001, 11, 9)) \u003d\u003e (((c.getExerciseDate)(\"200109\").EQ)((c.getDateFrom_yyyy_mm_dd)(2001, 9, 14)) \u003d\u003e pre_((c.isCorrectContractMonth)\"200206\")))","legal function application obligation:(((c.getExerciseDate)(\"200111\").EQ)((c.getDateFrom_yyyy_mm_dd)(2001, 11, 9)) \u003d\u003e (((c.getExerciseDate)(\"200109\").EQ)((c.getDateFrom_yyyy_mm_dd)(2001, 9, 14)) \u003d\u003e (((c.isCorrectContractMonth)(\"200206\") \u003d true) \u003d\u003e pre_((c.isCorrectContractMonth)\"200206.01\"))))","legal function application obligation:(((c.getExerciseDate)(\"200111\").EQ)((c.getDateFrom_yyyy_mm_dd)(2001, 11, 9)) \u003d\u003e (((c.getExerciseDate)(\"200109\").EQ)((c.getDateFrom_yyyy_mm_dd)(2001, 9, 14)) \u003d\u003e (((c.isCorrectContractMonth)(\"200206\") \u003d true) \u003d\u003e (((c.isCorrectContractMonth)(\"200206.01\") \u003d false) \u003d\u003e pre_((c.isCorrectContractMonth)\"Shin Sahara\")))))","type compatibility obligation:is_(RESULT, ())","type compatibility obligation:is_(RESULT, ())","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2004, 1, 5))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2004, 2, 1))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2004, 2, 27))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2004, 3, 30))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2004, 4, 1))))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 1)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)))))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 29)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2004, 5, 6))))))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 29)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 6)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2004, 5, 7)))))))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 29)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 6)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 7)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2004, 5, 10))))))))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 29)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 6)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 7)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 10)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 10)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2004, 6, 1)))))))))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 29)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 6)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 7)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 10)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 10)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 1)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2004, 6, 28))))))))))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 29)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 6)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 7)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 10)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 10)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2004, 6, 29)))))))))))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 29)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 6)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 7)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 10)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 10)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2004, 6, 30))))))))))))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 29)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 6)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 7)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 10)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 10)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2004, 7, 1)))))))))))))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 29)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 6)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 7)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 10)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 10)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2004, 7, 2))))))))))))))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 29)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 6)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 7)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 10)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 10)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)))))))))))))))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 29)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 6)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 7)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 10)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 10)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2005, 1, 5)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2004, 7, 30))))))))))))))))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 29)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 6)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 7)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 10)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 10)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2005, 1, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2005, 1, 28)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2003, 8, 2)))))))))))))))))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 29)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 6)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 7)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 10)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 10)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2005, 1, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2005, 1, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2003, 8, 28))))))))))))))))))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 29)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 6)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 7)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 10)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 10)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2005, 1, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2005, 1, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2003, 8, 29)))))))))))))))))))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 29)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 6)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 7)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 10)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 10)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2005, 1, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2005, 1, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2003, 9, 1))))))))))))))))))))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 29)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 6)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 7)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 10)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 10)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2005, 1, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2005, 1, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 9, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2003, 9, 30)))))))))))))))))))))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 29)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 6)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 7)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 10)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 10)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2005, 1, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2005, 1, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 9, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 9, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2003, 10, 1))))))))))))))))))))))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 29)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 6)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 7)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 10)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 10)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2005, 1, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2005, 1, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 9, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 9, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 10, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2003, 10, 29)))))))))))))))))))))))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 29)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 6)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 7)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 10)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 10)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2005, 1, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2005, 1, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 9, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 9, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 10, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 10, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 4, 28)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2003, 11, 1))))))))))))))))))))))))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 29)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 6)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 7)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 10)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 10)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2005, 1, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2005, 1, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 9, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 9, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 10, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 10, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 4, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 11, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2003, 11, 30)))))))))))))))))))))))))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 29)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 6)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 7)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 10)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 10)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2005, 1, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2005, 1, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 9, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 9, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 10, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 10, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 4, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 11, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 11, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 5, 28)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2003, 12, 1))))))))))))))))))))))))))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 29)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 6)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 7)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 10)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 10)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2005, 1, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2005, 1, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 9, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 9, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 10, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 10, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 4, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 11, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 11, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 5, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 12, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 6, 1)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2003, 12, 26)))))))))))))))))))))))))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:(forall f:(@e * @e -\u003e bool), n1:@e, n2:@e \u0026 pre_(fn1, n2))","legal function application obligation:(forall f:(@e * @e -\u003e bool), n1:@e, n2:@e \u0026 pre_(fn1, n2))","recursive function obligation:(forall i:int, numberOfDigit:nat \u0026 let q:int \u003d (i div 10) in ((not (0 \u003d q)) \u003d\u003e (idiv10(i, numberOfDigit) \u003e idiv10(q, (numberOfDigit + 1)))))","type compatibility obligation:(forall i:int, -:nat \u0026 ((i div 10) \u003e\u003d 0))","non-zero obligation:(forall r:real, numberOfDigit:nat \u0026 ((r \u003e\u003d 0) \u003d\u003e let multiple:nat1 \u003d (10 ** numberOfDigit) in (multiple \u003c\u003e 0)))","legal function application obligation:(forall f:(real -\u003e real), x:real \u0026 pre_(f(x + Variation)))","legal function application obligation:(forall f:(real -\u003e real), x:real \u0026 pre_(fx))","non-zero obligation:(forall f:(real -\u003e real), x:real \u0026 (Variation \u003c\u003e 0))","legal function application obligation:(forall f:(real -\u003e real), x:real \u0026 (forall y:real \u0026 pre_(fy)))","legal function application obligation:(forall f:(real -\u003e real), x:real \u0026 (forall y:real \u0026 pre_(fy)))","legal function application obligation:(forall f:(real -\u003e real), x:real \u0026 (forall y:real \u0026 pre_(Differentiate(f)y)))","non-zero obligation:(forall f:(real -\u003e real), x:real \u0026 (forall y:real \u0026 (Differentiate(f)(y) \u003c\u003e 0)))","legal function application obligation:(forall f:(real -\u003e real), x:real \u0026 let terminationCondition:(real -\u003e bool) \u003d (lambda [y:real] \u0026 ((abs f(y)) \u003c Tolerance)), nextApproximation:(real -\u003e real) \u003d (lambda [y:real] \u0026 (y - (f(y) / Differentiate(f)(y)))) in pre_(((new Function().Funtil))[real](terminationCondition)(nextApproximation)x))","legal function application obligation:(forall f:(real -\u003e real), x:real \u0026 let terminationCondition:(real -\u003e bool) \u003d (lambda [y:real] \u0026 ((abs f(y)) \u003c Tolerance)), nextApproximation:(real -\u003e real) \u003d (lambda [y:real] \u0026 (y - (f(y) / Differentiate(f)(y)))) in pre_(((new Function().Funtil))[real](terminationCondition)nextApproximation))","legal function application obligation:(forall f:(real -\u003e real), x:real \u0026 let terminationCondition:(real -\u003e bool) \u003d (lambda [y:real] \u0026 ((abs f(y)) \u003c Tolerance)), nextApproximation:(real -\u003e real) \u003d (lambda [y:real] \u0026 (y - (f(y) / Differentiate(f)(y)))) in pre_(((new Function().Funtil))[real]terminationCondition))","non-zero obligation:(forall f:(real -\u003e real), n:nat1, a:real, b:real \u0026 (n \u003c\u003e 0))","legal function application obligation:(forall f:(real -\u003e real), n:nat1, a:real, b:real \u0026 let h:real \u003d ((b - a) / n), s:seq of (real) \u003d seqGenerate(n, a, h) in pre_(fa))","legal function application obligation:(forall f:(real -\u003e real), n:nat1, a:real, b:real \u0026 let h:real \u003d ((b - a) / n), s:seq of (real) \u003d seqGenerate(n, a, h) in pre_Sum((Sequence`fmap)[real, real](f)(s)))","legal function application obligation:(forall f:(real -\u003e real), n:nat1, a:real, b:real \u0026 let h:real \u003d ((b - a) / n), s:seq of (real) \u003d seqGenerate(n, a, h) in pre_((Sequence`fmap)[real, real](f)s))","legal function application obligation:(forall f:(real -\u003e real), n:nat1, a:real, b:real \u0026 let h:real \u003d ((b - a) / n), s:seq of (real) \u003d seqGenerate(n, a, h) in pre_(fb))","legal function application obligation:(forall x:real \u0026 let f:(real -\u003e real) \u003d (lambda [y:real] \u0026 ((y ** 2) - x)) in pre_(NewtonMethod(f)x))","legal function application obligation:(forall multiple:real, years:int \u0026 (forall Interest:real \u0026 pre_getTotalPrincipal(Interest, years)))","legal function application obligation:(forall multiple:real, years:int \u0026 let f:(real -\u003e real) \u003d (lambda [Interest:real] \u0026 (multiple - getTotalPrincipal(Interest, years))) in pre_(NewtonMethod(f)0))","non-empty sequence obligation:(forall aQueue:seq of (@T) \u0026 ((not (aQueue \u003d [])) \u003d\u003e (aQueue \u003c\u003e [])))","non-empty sequence obligation:(forall aQueue:seq of (@T) \u0026 ((not (aQueue \u003d [])) \u003d\u003e (aQueue \u003c\u003e [])))","legal function application obligation:pre_((d.getNumberOfDayOfTheWeek))","legal function application obligation:pre_((jc.getNumberOfDayOfTheWeekFromName)\u003cTue\u003e)","legal function application obligation:(((d.getNumberOfDayOfTheWeek)() \u003d (jc.getNumberOfDayOfTheWeekFromName)(\u003cTue\u003e)) \u003d\u003e pre_((d.getNameOfDayOfTheWeek)))","legal function application obligation:(((d.getNumberOfDayOfTheWeek)() \u003d (jc.getNumberOfDayOfTheWeekFromName)(\u003cTue\u003e)) \u003d\u003e (((d.getNameOfDayOfTheWeek)() \u003d \u003cTue\u003e) \u003d\u003e pre_((d1.getNameOfDayOfTheWeek))))","legal function application obligation:(((d.getNumberOfDayOfTheWeek)() \u003d (jc.getNumberOfDayOfTheWeekFromName)(\u003cTue\u003e)) \u003d\u003e (((d.getNameOfDayOfTheWeek)() \u003d \u003cTue\u003e) \u003d\u003e (((d1.getNameOfDayOfTheWeek)() \u003d \u003cSun\u003e) \u003d\u003e pre_((d2.getNameOfDayOfTheWeek)))))","legal function application obligation:(((d.getNumberOfDayOfTheWeek)() \u003d (jc.getNumberOfDayOfTheWeekFromName)(\u003cTue\u003e)) \u003d\u003e (((d.getNameOfDayOfTheWeek)() \u003d \u003cTue\u003e) \u003d\u003e (((d1.getNameOfDayOfTheWeek)() \u003d \u003cSun\u003e) \u003d\u003e (((d2.getNameOfDayOfTheWeek)() \u003d \u003cSat\u003e) \u003d\u003e pre_((d.isSunday))))))","legal function application obligation:(((d.getNumberOfDayOfTheWeek)() \u003d (jc.getNumberOfDayOfTheWeekFromName)(\u003cTue\u003e)) \u003d\u003e (((d.getNameOfDayOfTheWeek)() \u003d \u003cTue\u003e) \u003d\u003e (((d1.getNameOfDayOfTheWeek)() \u003d \u003cSun\u003e) \u003d\u003e (((d2.getNameOfDayOfTheWeek)() \u003d \u003cSat\u003e) \u003d\u003e (((d.isSunday)() \u003d false) \u003d\u003e pre_((d.isSaturday)))))))","legal function application obligation:(((d.getNumberOfDayOfTheWeek)() \u003d (jc.getNumberOfDayOfTheWeekFromName)(\u003cTue\u003e)) \u003d\u003e (((d.getNameOfDayOfTheWeek)() \u003d \u003cTue\u003e) \u003d\u003e (((d1.getNameOfDayOfTheWeek)() \u003d \u003cSun\u003e) \u003d\u003e (((d2.getNameOfDayOfTheWeek)() \u003d \u003cSat\u003e) \u003d\u003e (((d.isSunday)() \u003d false) \u003d\u003e (((d.isSaturday)() \u003d false) \u003d\u003e pre_((d.isWeekday))))))))","legal function application obligation:(((d.getNumberOfDayOfTheWeek)() \u003d (jc.getNumberOfDayOfTheWeekFromName)(\u003cTue\u003e)) \u003d\u003e (((d.getNameOfDayOfTheWeek)() \u003d \u003cTue\u003e) \u003d\u003e (((d1.getNameOfDayOfTheWeek)() \u003d \u003cSun\u003e) \u003d\u003e (((d2.getNameOfDayOfTheWeek)() \u003d \u003cSat\u003e) \u003d\u003e (((d.isSunday)() \u003d false) \u003d\u003e (((d.isSaturday)() \u003d false) \u003d\u003e (((d.isWeekday)() \u003d true) \u003d\u003e pre_((d.isDayOff)))))))))","legal function application obligation:(((d.getNumberOfDayOfTheWeek)() \u003d (jc.getNumberOfDayOfTheWeekFromName)(\u003cTue\u003e)) \u003d\u003e (((d.getNameOfDayOfTheWeek)() \u003d \u003cTue\u003e) \u003d\u003e (((d1.getNameOfDayOfTheWeek)() \u003d \u003cSun\u003e) \u003d\u003e (((d2.getNameOfDayOfTheWeek)() \u003d \u003cSat\u003e) \u003d\u003e (((d.isSunday)() \u003d false) \u003d\u003e (((d.isSaturday)() \u003d false) \u003d\u003e (((d.isWeekday)() \u003d true) \u003d\u003e (((d.isDayOff)() \u003d false) \u003d\u003e pre_((d.isNotDayOff))))))))))","legal function application obligation:(((d.getNumberOfDayOfTheWeek)() \u003d (jc.getNumberOfDayOfTheWeekFromName)(\u003cTue\u003e)) \u003d\u003e (((d.getNameOfDayOfTheWeek)() \u003d \u003cTue\u003e) \u003d\u003e (((d1.getNameOfDayOfTheWeek)() \u003d \u003cSun\u003e) \u003d\u003e (((d2.getNameOfDayOfTheWeek)() \u003d \u003cSat\u003e) \u003d\u003e (((d.isSunday)() \u003d false) \u003d\u003e (((d.isSaturday)() \u003d false) \u003d\u003e (((d.isWeekday)() \u003d true) \u003d\u003e (((d.isDayOff)() \u003d false) \u003d\u003e (((d.isNotDayOff)() \u003d true) \u003d\u003e pre_((d.isSundayOrDayoff)))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((d.get_yyyy_mm_dd))","legal function application obligation:(((d.get_yyyy_mm_dd)() \u003d mk_(2001, 5, 1)) \u003d\u003e pre_((d.date2Str)))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((d0301.getTheNumberOfDayOff)d0711)","legal function application obligation:(((d0301.getTheNumberOfDayOff)(d0711) \u003d 24) \u003d\u003e pre_((d0501.getTheNumberOfDayOffExceptStartDate)d0711))","legal function application obligation:(((d0301.getTheNumberOfDayOff)(d0711) \u003d 24) \u003d\u003e (((d0501.getTheNumberOfDayOffExceptStartDate)(d0711) \u003d 13) \u003d\u003e pre_((d20000101.getTheNumberOfDayOff)d0711)))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((((d0502.addWeekday)(1).getFutureWeekday)().date2Str))","legal function application obligation:pre_(((d0502.addWeekday)(1).getFutureWeekday))","legal function application obligation:pre_((d0502.addWeekday)1)","legal function application obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e pre_((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)))","legal function application obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e pre_(((d0502.getPastWeekday)().subtractWeekday)1))","legal function application obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e pre_((d0502.getPastWeekday)))","legal function application obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e pre_((((d0501.getPastWeekday)().subtractWeekday)(1).date2Str))))","legal function application obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e pre_(((d0501.getPastWeekday)().subtractWeekday)1)))","legal function application obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e pre_((d0501.getPastWeekday))))","legal function application obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e (((((d0501.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010427\") \u003d\u003e pre_(((d0501.getFutureWeekday)().date2Str)))))","legal function application obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e (((((d0501.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010427\") \u003d\u003e pre_((d0501.getFutureWeekday)))))","legal function application obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e (((((d0501.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010427\") \u003d\u003e ((((d0501.getFutureWeekday)().date2Str)() \u003d \"20010501\") \u003d\u003e pre_(((d0501.addWeekday)(2).date2Str))))))","legal function application obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e (((((d0501.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010427\") \u003d\u003e ((((d0501.getFutureWeekday)().date2Str)() \u003d \"20010501\") \u003d\u003e pre_((d0501.addWeekday)2)))))","legal function application obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e (((((d0501.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010427\") \u003d\u003e ((((d0501.getFutureWeekday)().date2Str)() \u003d \"20010501\") \u003d\u003e ((((d0501.addWeekday)(2).date2Str)() \u003d \"20010507\") \u003d\u003e pre_(((d0502.subtractWeekday)(2).date2Str)))))))","legal function application obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e (((((d0501.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010427\") \u003d\u003e ((((d0501.getFutureWeekday)().date2Str)() \u003d \"20010501\") \u003d\u003e ((((d0501.addWeekday)(2).date2Str)() \u003d \"20010507\") \u003d\u003e pre_((d0502.subtractWeekday)2))))))","legal function application obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e (((((d0501.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010427\") \u003d\u003e ((((d0501.getFutureWeekday)().date2Str)() \u003d \"20010501\") \u003d\u003e ((((d0501.addWeekday)(2).date2Str)() \u003d \"20010507\") \u003d\u003e ((((d0502.subtractWeekday)(2).date2Str)() \u003d \"20010427\") \u003d\u003e pre_((d1231.daysFromNewYear))))))))","legal function application obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e (((((d0501.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010427\") \u003d\u003e ((((d0501.getFutureWeekday)().date2Str)() \u003d \"20010501\") \u003d\u003e ((((d0501.addWeekday)(2).date2Str)() \u003d \"20010507\") \u003d\u003e ((((d0502.subtractWeekday)(2).date2Str)() \u003d \"20010427\") \u003d\u003e (((d1231.daysFromNewYear)() \u003d 365) \u003d\u003e pre_((d20001231.daysFromNewYear)))))))))","legal function application obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e (((((d0501.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010427\") \u003d\u003e ((((d0501.getFutureWeekday)().date2Str)() \u003d \"20010501\") \u003d\u003e ((((d0501.addWeekday)(2).date2Str)() \u003d \"20010507\") \u003d\u003e ((((d0502.subtractWeekday)(2).date2Str)() \u003d \"20010427\") \u003d\u003e (((d1231.daysFromNewYear)() \u003d 365) \u003d\u003e (((d20001231.daysFromNewYear)() \u003d 366) \u003d\u003e pre_((d0501.getNumberOfTheDayOfWeek)d0626, \u003cTue\u003e)))))))))","legal function application obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e (((((d0501.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010427\") \u003d\u003e ((((d0501.getFutureWeekday)().date2Str)() \u003d \"20010501\") \u003d\u003e ((((d0501.addWeekday)(2).date2Str)() \u003d \"20010507\") \u003d\u003e ((((d0502.subtractWeekday)(2).date2Str)() \u003d \"20010427\") \u003d\u003e (((d1231.daysFromNewYear)() \u003d 365) \u003d\u003e (((d20001231.daysFromNewYear)() \u003d 366) \u003d\u003e (((d0501.getNumberOfTheDayOfWeek)(d0626, \u003cTue\u003e) \u003d 9) \u003d\u003e pre_(((jc.getFutureWeekday)(d0505).date2Str)))))))))))","legal function application obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e (((((d0501.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010427\") \u003d\u003e ((((d0501.getFutureWeekday)().date2Str)() \u003d \"20010501\") \u003d\u003e ((((d0501.addWeekday)(2).date2Str)() \u003d \"20010507\") \u003d\u003e ((((d0502.subtractWeekday)(2).date2Str)() \u003d \"20010427\") \u003d\u003e (((d1231.daysFromNewYear)() \u003d 365) \u003d\u003e (((d20001231.daysFromNewYear)() \u003d 366) \u003d\u003e (((d0501.getNumberOfTheDayOfWeek)(d0626, \u003cTue\u003e) \u003d 9) \u003d\u003e pre_((jc.getFutureWeekday)d0505))))))))))","type compatibility obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e (((((d0501.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010427\") \u003d\u003e ((((d0501.getFutureWeekday)().date2Str)() \u003d \"20010501\") \u003d\u003e ((((d0501.addWeekday)(2).date2Str)() \u003d \"20010507\") \u003d\u003e ((((d0502.subtractWeekday)(2).date2Str)() \u003d \"20010427\") \u003d\u003e (((d1231.daysFromNewYear)() \u003d 365) \u003d\u003e (((d20001231.daysFromNewYear)() \u003d 366) \u003d\u003e (((d0501.getNumberOfTheDayOfWeek)(d0626, \u003cTue\u003e) \u003d 9) \u003d\u003e is_(d0505, Date))))))))))","legal function application obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e (((((d0501.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010427\") \u003d\u003e ((((d0501.getFutureWeekday)().date2Str)() \u003d \"20010501\") \u003d\u003e ((((d0501.addWeekday)(2).date2Str)() \u003d \"20010507\") \u003d\u003e ((((d0502.subtractWeekday)(2).date2Str)() \u003d \"20010427\") \u003d\u003e (((d1231.daysFromNewYear)() \u003d 365) \u003d\u003e (((d20001231.daysFromNewYear)() \u003d 366) \u003d\u003e (((d0501.getNumberOfTheDayOfWeek)(d0626, \u003cTue\u003e) \u003d 9) \u003d\u003e ((((jc.getFutureWeekday)(d0505).date2Str)() \u003d \"20010507\") \u003d\u003e pre_(((jc.getFutureWeekday)(d0501).date2Str))))))))))))","legal function application obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e (((((d0501.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010427\") \u003d\u003e ((((d0501.getFutureWeekday)().date2Str)() \u003d \"20010501\") \u003d\u003e ((((d0501.addWeekday)(2).date2Str)() \u003d \"20010507\") \u003d\u003e ((((d0502.subtractWeekday)(2).date2Str)() \u003d \"20010427\") \u003d\u003e (((d1231.daysFromNewYear)() \u003d 365) \u003d\u003e (((d20001231.daysFromNewYear)() \u003d 366) \u003d\u003e (((d0501.getNumberOfTheDayOfWeek)(d0626, \u003cTue\u003e) \u003d 9) \u003d\u003e ((((jc.getFutureWeekday)(d0505).date2Str)() \u003d \"20010507\") \u003d\u003e pre_((jc.getFutureWeekday)d0501)))))))))))","type compatibility obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e (((((d0501.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010427\") \u003d\u003e ((((d0501.getFutureWeekday)().date2Str)() \u003d \"20010501\") \u003d\u003e ((((d0501.addWeekday)(2).date2Str)() \u003d \"20010507\") \u003d\u003e ((((d0502.subtractWeekday)(2).date2Str)() \u003d \"20010427\") \u003d\u003e (((d1231.daysFromNewYear)() \u003d 365) \u003d\u003e (((d20001231.daysFromNewYear)() \u003d 366) \u003d\u003e (((d0501.getNumberOfTheDayOfWeek)(d0626, \u003cTue\u003e) \u003d 9) \u003d\u003e ((((jc.getFutureWeekday)(d0505).date2Str)() \u003d \"20010507\") \u003d\u003e is_(d0501, Date)))))))))))","legal function application obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e (((((d0501.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010427\") \u003d\u003e ((((d0501.getFutureWeekday)().date2Str)() \u003d \"20010501\") \u003d\u003e ((((d0501.addWeekday)(2).date2Str)() \u003d \"20010507\") \u003d\u003e ((((d0502.subtractWeekday)(2).date2Str)() \u003d \"20010427\") \u003d\u003e (((d1231.daysFromNewYear)() \u003d 365) \u003d\u003e (((d20001231.daysFromNewYear)() \u003d 366) \u003d\u003e (((d0501.getNumberOfTheDayOfWeek)(d0626, \u003cTue\u003e) \u003d 9) \u003d\u003e ((((jc.getFutureWeekday)(d0505).date2Str)() \u003d \"20010507\") \u003d\u003e ((((jc.getFutureWeekday)(d0501).date2Str)() \u003d \"20010501\") \u003d\u003e pre_(((jc.getPastWeekday)(d0501).date2Str)))))))))))))","legal function application obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e (((((d0501.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010427\") \u003d\u003e ((((d0501.getFutureWeekday)().date2Str)() \u003d \"20010501\") \u003d\u003e ((((d0501.addWeekday)(2).date2Str)() \u003d \"20010507\") \u003d\u003e ((((d0502.subtractWeekday)(2).date2Str)() \u003d \"20010427\") \u003d\u003e (((d1231.daysFromNewYear)() \u003d 365) \u003d\u003e (((d20001231.daysFromNewYear)() \u003d 366) \u003d\u003e (((d0501.getNumberOfTheDayOfWeek)(d0626, \u003cTue\u003e) \u003d 9) \u003d\u003e ((((jc.getFutureWeekday)(d0505).date2Str)() \u003d \"20010507\") \u003d\u003e ((((jc.getFutureWeekday)(d0501).date2Str)() \u003d \"20010501\") \u003d\u003e pre_((jc.getPastWeekday)d0501))))))))))))","type compatibility obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e (((((d0501.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010427\") \u003d\u003e ((((d0501.getFutureWeekday)().date2Str)() \u003d \"20010501\") \u003d\u003e ((((d0501.addWeekday)(2).date2Str)() \u003d \"20010507\") \u003d\u003e ((((d0502.subtractWeekday)(2).date2Str)() \u003d \"20010427\") \u003d\u003e (((d1231.daysFromNewYear)() \u003d 365) \u003d\u003e (((d20001231.daysFromNewYear)() \u003d 366) \u003d\u003e (((d0501.getNumberOfTheDayOfWeek)(d0626, \u003cTue\u003e) \u003d 9) \u003d\u003e ((((jc.getFutureWeekday)(d0505).date2Str)() \u003d \"20010507\") \u003d\u003e ((((jc.getFutureWeekday)(d0501).date2Str)() \u003d \"20010501\") \u003d\u003e is_(d0501, Date))))))))))))","legal function application obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e (((((d0501.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010427\") \u003d\u003e ((((d0501.getFutureWeekday)().date2Str)() \u003d \"20010501\") \u003d\u003e ((((d0501.addWeekday)(2).date2Str)() \u003d \"20010507\") \u003d\u003e ((((d0502.subtractWeekday)(2).date2Str)() \u003d \"20010427\") \u003d\u003e (((d1231.daysFromNewYear)() \u003d 365) \u003d\u003e (((d20001231.daysFromNewYear)() \u003d 366) \u003d\u003e (((d0501.getNumberOfTheDayOfWeek)(d0626, \u003cTue\u003e) \u003d 9) \u003d\u003e ((((jc.getFutureWeekday)(d0505).date2Str)() \u003d \"20010507\") \u003d\u003e ((((jc.getFutureWeekday)(d0501).date2Str)() \u003d \"20010501\") \u003d\u003e ((((jc.getPastWeekday)(d0501).date2Str)() \u003d \"20010501\") \u003d\u003e pre_(((jc.getPastWeekday)(d0505).date2Str))))))))))))))","legal function application obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e (((((d0501.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010427\") \u003d\u003e ((((d0501.getFutureWeekday)().date2Str)() \u003d \"20010501\") \u003d\u003e ((((d0501.addWeekday)(2).date2Str)() \u003d \"20010507\") \u003d\u003e ((((d0502.subtractWeekday)(2).date2Str)() \u003d \"20010427\") \u003d\u003e (((d1231.daysFromNewYear)() \u003d 365) \u003d\u003e (((d20001231.daysFromNewYear)() \u003d 366) \u003d\u003e (((d0501.getNumberOfTheDayOfWeek)(d0626, \u003cTue\u003e) \u003d 9) \u003d\u003e ((((jc.getFutureWeekday)(d0505).date2Str)() \u003d \"20010507\") \u003d\u003e ((((jc.getFutureWeekday)(d0501).date2Str)() \u003d \"20010501\") \u003d\u003e ((((jc.getPastWeekday)(d0501).date2Str)() \u003d \"20010501\") \u003d\u003e pre_((jc.getPastWeekday)d0505)))))))))))))","type compatibility obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e (((((d0501.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010427\") \u003d\u003e ((((d0501.getFutureWeekday)().date2Str)() \u003d \"20010501\") \u003d\u003e ((((d0501.addWeekday)(2).date2Str)() \u003d \"20010507\") \u003d\u003e ((((d0502.subtractWeekday)(2).date2Str)() \u003d \"20010427\") \u003d\u003e (((d1231.daysFromNewYear)() \u003d 365) \u003d\u003e (((d20001231.daysFromNewYear)() \u003d 366) \u003d\u003e (((d0501.getNumberOfTheDayOfWeek)(d0626, \u003cTue\u003e) \u003d 9) \u003d\u003e ((((jc.getFutureWeekday)(d0505).date2Str)() \u003d \"20010507\") \u003d\u003e ((((jc.getFutureWeekday)(d0501).date2Str)() \u003d \"20010501\") \u003d\u003e ((((jc.getPastWeekday)(d0501).date2Str)() \u003d \"20010501\") \u003d\u003e is_(d0505, Date)))))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0711.NE)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 12)) \u003d\u003e pre_((jc.EQ)d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11))))","type compatibility obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0711.NE)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 12)) \u003d\u003e is_(d0711, Date)))","legal function application obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0711.NE)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 12)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e pre_((jc.LT)d0301, d0711)))))","type compatibility obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0711.NE)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 12)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e is_(d0711, Date)))))","legal function application obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0711.NE)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 12)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e pre_((jc.GT)d0711, d0301)))))))","type compatibility obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0711.NE)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 12)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e is_(d0711, Date)))))))","legal function application obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0711.NE)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 12)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e ((jc.GT)(d0711, d0301) \u003d\u003e ((d0711.GE)(d0711) \u003d\u003e ((d0711.GE)(d0301) \u003d\u003e pre_((jc.GE)d0711, d0711))))))))))","type compatibility obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0711.NE)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 12)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e ((jc.GT)(d0711, d0301) \u003d\u003e ((d0711.GE)(d0711) \u003d\u003e ((d0711.GE)(d0301) \u003d\u003e is_(d0711, Date))))))))))","type compatibility obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0711.NE)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 12)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e ((jc.GT)(d0711, d0301) \u003d\u003e ((d0711.GE)(d0711) \u003d\u003e ((d0711.GE)(d0301) \u003d\u003e is_(d0711, Date))))))))))","legal function application obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0711.NE)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 12)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e ((jc.GT)(d0711, d0301) \u003d\u003e ((d0711.GE)(d0711) \u003d\u003e ((d0711.GE)(d0301) \u003d\u003e ((jc.GE)(d0711, d0711) \u003d\u003e pre_((jc.GE)d0711, d0301)))))))))))","type compatibility obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0711.NE)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 12)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e ((jc.GT)(d0711, d0301) \u003d\u003e ((d0711.GE)(d0711) \u003d\u003e ((d0711.GE)(d0301) \u003d\u003e ((jc.GE)(d0711, d0711) \u003d\u003e is_(d0711, Date)))))))))))","legal function application obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0711.NE)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 12)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e ((jc.GT)(d0711, d0301) \u003d\u003e ((d0711.GE)(d0711) \u003d\u003e ((d0711.GE)(d0301) \u003d\u003e ((jc.GE)(d0711, d0711) \u003d\u003e ((jc.GE)(d0711, d0301) \u003d\u003e ((d0711.LE)(d0711) \u003d\u003e ((d0301.LE)(d0711) \u003d\u003e pre_((jc.LE)d0711, d0711))))))))))))))","type compatibility obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0711.NE)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 12)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e ((jc.GT)(d0711, d0301) \u003d\u003e ((d0711.GE)(d0711) \u003d\u003e ((d0711.GE)(d0301) \u003d\u003e ((jc.GE)(d0711, d0711) \u003d\u003e ((jc.GE)(d0711, d0301) \u003d\u003e ((d0711.LE)(d0711) \u003d\u003e ((d0301.LE)(d0711) \u003d\u003e is_(d0711, Date))))))))))))))","type compatibility obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0711.NE)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 12)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e ((jc.GT)(d0711, d0301) \u003d\u003e ((d0711.GE)(d0711) \u003d\u003e ((d0711.GE)(d0301) \u003d\u003e ((jc.GE)(d0711, d0711) \u003d\u003e ((jc.GE)(d0711, d0301) \u003d\u003e ((d0711.LE)(d0711) \u003d\u003e ((d0301.LE)(d0711) \u003d\u003e is_(d0711, Date))))))))))))))","legal function application obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0711.NE)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 12)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e ((jc.GT)(d0711, d0301) \u003d\u003e ((d0711.GE)(d0711) \u003d\u003e ((d0711.GE)(d0301) \u003d\u003e ((jc.GE)(d0711, d0711) \u003d\u003e ((jc.GE)(d0711, d0301) \u003d\u003e ((d0711.LE)(d0711) \u003d\u003e ((d0301.LE)(d0711) \u003d\u003e ((jc.LE)(d0711, d0711) \u003d\u003e pre_((jc.LE)d0301, d0711)))))))))))))))","type compatibility obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0711.NE)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 12)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e ((jc.GT)(d0711, d0301) \u003d\u003e ((d0711.GE)(d0711) \u003d\u003e ((d0711.GE)(d0301) \u003d\u003e ((jc.GE)(d0711, d0711) \u003d\u003e ((jc.GE)(d0711, d0301) \u003d\u003e ((d0711.LE)(d0711) \u003d\u003e ((d0301.LE)(d0711) \u003d\u003e ((jc.LE)(d0711, d0711) \u003d\u003e is_(d0711, Date)))))))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd))","legal function application obligation:pre_((jc.firstDayOfTheWeekInMonth)2000, 3, \u003cWed\u003e)","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e pre_(((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e pre_((jc.firstDayOfTheWeekInMonth)2001, 7, \u003cSun\u003e))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e pre_(((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd))))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e pre_((jc.lastDayOfTheWeekInMonth)2000, 2, \u003cTue\u003e)))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e pre_(((jc.lastDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)))))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e pre_((jc.lastDayOfTheWeekInMonth)2001, 7, \u003cSun\u003e))))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e pre_(((jc.getNthDayOfTheWeek)(2001, 7, 5, \u003cSun\u003e).get_yyyy_mm_dd))))))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e pre_((jc.getNthDayOfTheWeek)2001, 7, 5, \u003cSun\u003e)))))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e ((((jc.getNthDayOfTheWeek)(2001, 7, 5, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e pre_((jc.getNthDayOfTheWeek)2001, 7, 6, \u003cSun\u003e))))))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e ((((jc.getNthDayOfTheWeek)(2001, 7, 5, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e (((jc.getNthDayOfTheWeek)(2001, 7, 6, \u003cSun\u003e) \u003d false) \u003d\u003e pre_((jc.getNumberOfTheDayOfWeek)d0711, d0301, \u003cSun\u003e)))))))","type compatibility obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e ((((jc.getNthDayOfTheWeek)(2001, 7, 5, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e (((jc.getNthDayOfTheWeek)(2001, 7, 6, \u003cSun\u003e) \u003d false) \u003d\u003e is_(d0711, Date)))))))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e ((((jc.getNthDayOfTheWeek)(2001, 7, 5, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e (((jc.getNthDayOfTheWeek)(2001, 7, 6, \u003cSun\u003e) \u003d false) \u003d\u003e (((jc.getNumberOfTheDayOfWeek)(d0711, d0301, \u003cSun\u003e) \u003d 19) \u003d\u003e pre_((jc.getNumberOfTheDayOfWeek)d0711, d10010301, \u003cSun\u003e))))))))","type compatibility obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e ((((jc.getNthDayOfTheWeek)(2001, 7, 5, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e (((jc.getNthDayOfTheWeek)(2001, 7, 6, \u003cSun\u003e) \u003d false) \u003d\u003e (((jc.getNumberOfTheDayOfWeek)(d0711, d0301, \u003cSun\u003e) \u003d 19) \u003d\u003e is_(d0711, Date))))))))","type compatibility obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e ((((jc.getNthDayOfTheWeek)(2001, 7, 5, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e (((jc.getNthDayOfTheWeek)(2001, 7, 6, \u003cSun\u003e) \u003d false) \u003d\u003e (((jc.getNumberOfTheDayOfWeek)(d0711, d0301, \u003cSun\u003e) \u003d 19) \u003d\u003e is_(d10010301, Date))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((jc.isLeapYear)2000)","legal function application obligation:(((jc.isLeapYear)(2000) \u003d true) \u003d\u003e pre_((jc.isLeapYear)2001))","legal function application obligation:(((jc.isLeapYear)(2000) \u003d true) \u003d\u003e (((jc.isLeapYear)(2001) \u003d false) \u003d\u003e pre_((jc.isLeapYear)1996)))","legal function application obligation:(((jc.isLeapYear)(2000) \u003d true) \u003d\u003e (((jc.isLeapYear)(2001) \u003d false) \u003d\u003e (((jc.isLeapYear)(1996) \u003d true) \u003d\u003e pre_((jc.isLeapYear)1900))))","legal function application obligation:(((jc.isLeapYear)(2000) \u003d true) \u003d\u003e (((jc.isLeapYear)(2001) \u003d false) \u003d\u003e (((jc.isLeapYear)(1996) \u003d true) \u003d\u003e (((jc.isLeapYear)(1900) \u003d false) \u003d\u003e pre_((jc.isLeapYear)1600)))))","legal function application obligation:(((jc.isLeapYear)(2000) \u003d true) \u003d\u003e (((jc.isLeapYear)(2001) \u003d false) \u003d\u003e (((jc.isLeapYear)(1996) \u003d true) \u003d\u003e (((jc.isLeapYear)(1900) \u003d false) \u003d\u003e (((jc.isLeapYear)(1600) \u003d true) \u003d\u003e pre_((jc.isDateString)\"sahara\"))))))","legal function application obligation:(((jc.isLeapYear)(2000) \u003d true) \u003d\u003e (((jc.isLeapYear)(2001) \u003d false) \u003d\u003e (((jc.isLeapYear)(1996) \u003d true) \u003d\u003e (((jc.isLeapYear)(1900) \u003d false) \u003d\u003e (((jc.isLeapYear)(1600) \u003d true) \u003d\u003e (((jc.isDateString)(\"sahara\") \u003d false) \u003d\u003e pre_((jc.isDateString)\"20010723\")))))))","legal function application obligation:(((jc.isLeapYear)(2000) \u003d true) \u003d\u003e (((jc.isLeapYear)(2001) \u003d false) \u003d\u003e (((jc.isLeapYear)(1996) \u003d true) \u003d\u003e (((jc.isLeapYear)(1900) \u003d false) \u003d\u003e (((jc.isLeapYear)(1600) \u003d true) \u003d\u003e (((jc.isDateString)(\"sahara\") \u003d false) \u003d\u003e (((jc.isDateString)(\"20010723\") \u003d true) \u003d\u003e pre_((jc.isDateString)\"20011232\"))))))))","legal function application obligation:(((jc.isLeapYear)(2000) \u003d true) \u003d\u003e (((jc.isLeapYear)(2001) \u003d false) \u003d\u003e (((jc.isLeapYear)(1996) \u003d true) \u003d\u003e (((jc.isLeapYear)(1900) \u003d false) \u003d\u003e (((jc.isLeapYear)(1600) \u003d true) \u003d\u003e (((jc.isDateString)(\"sahara\") \u003d false) \u003d\u003e (((jc.isDateString)(\"20010723\") \u003d true) \u003d\u003e (((jc.isDateString)(\"20011232\") \u003d false) \u003d\u003e pre_((jc.isWeekday)\u003cMon\u003e)))))))))","legal function application obligation:(((jc.isLeapYear)(2000) \u003d true) \u003d\u003e (((jc.isLeapYear)(2001) \u003d false) \u003d\u003e (((jc.isLeapYear)(1996) \u003d true) \u003d\u003e (((jc.isLeapYear)(1900) \u003d false) \u003d\u003e (((jc.isLeapYear)(1600) \u003d true) \u003d\u003e (((jc.isDateString)(\"sahara\") \u003d false) \u003d\u003e (((jc.isDateString)(\"20010723\") \u003d true) \u003d\u003e (((jc.isDateString)(\"20011232\") \u003d false) \u003d\u003e (((jc.isWeekday)(\u003cMon\u003e) \u003d true) \u003d\u003e pre_((jc.isWeekday)\u003cTue\u003e))))))))))","legal function application obligation:(((jc.isLeapYear)(2000) \u003d true) \u003d\u003e (((jc.isLeapYear)(2001) \u003d false) \u003d\u003e (((jc.isLeapYear)(1996) \u003d true) \u003d\u003e (((jc.isLeapYear)(1900) \u003d false) \u003d\u003e (((jc.isLeapYear)(1600) \u003d true) \u003d\u003e (((jc.isDateString)(\"sahara\") \u003d false) \u003d\u003e (((jc.isDateString)(\"20010723\") \u003d true) \u003d\u003e (((jc.isDateString)(\"20011232\") \u003d false) \u003d\u003e (((jc.isWeekday)(\u003cMon\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cTue\u003e) \u003d true) \u003d\u003e pre_((jc.isWeekday)\u003cWed\u003e)))))))))))","legal function application obligation:(((jc.isLeapYear)(2000) \u003d true) \u003d\u003e (((jc.isLeapYear)(2001) \u003d false) \u003d\u003e (((jc.isLeapYear)(1996) \u003d true) \u003d\u003e (((jc.isLeapYear)(1900) \u003d false) \u003d\u003e (((jc.isLeapYear)(1600) \u003d true) \u003d\u003e (((jc.isDateString)(\"sahara\") \u003d false) \u003d\u003e (((jc.isDateString)(\"20010723\") \u003d true) \u003d\u003e (((jc.isDateString)(\"20011232\") \u003d false) \u003d\u003e (((jc.isWeekday)(\u003cMon\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cTue\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cWed\u003e) \u003d true) \u003d\u003e pre_((jc.isWeekday)\u003cThu\u003e))))))))))))","legal function application obligation:(((jc.isLeapYear)(2000) \u003d true) \u003d\u003e (((jc.isLeapYear)(2001) \u003d false) \u003d\u003e (((jc.isLeapYear)(1996) \u003d true) \u003d\u003e (((jc.isLeapYear)(1900) \u003d false) \u003d\u003e (((jc.isLeapYear)(1600) \u003d true) \u003d\u003e (((jc.isDateString)(\"sahara\") \u003d false) \u003d\u003e (((jc.isDateString)(\"20010723\") \u003d true) \u003d\u003e (((jc.isDateString)(\"20011232\") \u003d false) \u003d\u003e (((jc.isWeekday)(\u003cMon\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cTue\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cWed\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cThu\u003e) \u003d true) \u003d\u003e pre_((jc.isWeekday)\u003cFri\u003e)))))))))))))","legal function application obligation:(((jc.isLeapYear)(2000) \u003d true) \u003d\u003e (((jc.isLeapYear)(2001) \u003d false) \u003d\u003e (((jc.isLeapYear)(1996) \u003d true) \u003d\u003e (((jc.isLeapYear)(1900) \u003d false) \u003d\u003e (((jc.isLeapYear)(1600) \u003d true) \u003d\u003e (((jc.isDateString)(\"sahara\") \u003d false) \u003d\u003e (((jc.isDateString)(\"20010723\") \u003d true) \u003d\u003e (((jc.isDateString)(\"20011232\") \u003d false) \u003d\u003e (((jc.isWeekday)(\u003cMon\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cTue\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cWed\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cThu\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cFri\u003e) \u003d true) \u003d\u003e pre_((jc.isWeekday)\u003cSat\u003e))))))))))))))","legal function application obligation:(((jc.isLeapYear)(2000) \u003d true) \u003d\u003e (((jc.isLeapYear)(2001) \u003d false) \u003d\u003e (((jc.isLeapYear)(1996) \u003d true) \u003d\u003e (((jc.isLeapYear)(1900) \u003d false) \u003d\u003e (((jc.isLeapYear)(1600) \u003d true) \u003d\u003e (((jc.isDateString)(\"sahara\") \u003d false) \u003d\u003e (((jc.isDateString)(\"20010723\") \u003d true) \u003d\u003e (((jc.isDateString)(\"20011232\") \u003d false) \u003d\u003e (((jc.isWeekday)(\u003cMon\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cTue\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cWed\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cThu\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cFri\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cSat\u003e) \u003d false) \u003d\u003e pre_((jc.isWeekday)\u003cSun\u003e)))))))))))))))","legal function application obligation:(((jc.isLeapYear)(2000) \u003d true) \u003d\u003e (((jc.isLeapYear)(2001) \u003d false) \u003d\u003e (((jc.isLeapYear)(1996) \u003d true) \u003d\u003e (((jc.isLeapYear)(1900) \u003d false) \u003d\u003e (((jc.isLeapYear)(1600) \u003d true) \u003d\u003e (((jc.isDateString)(\"sahara\") \u003d false) \u003d\u003e (((jc.isDateString)(\"20010723\") \u003d true) \u003d\u003e (((jc.isDateString)(\"20011232\") \u003d false) \u003d\u003e (((jc.isWeekday)(\u003cMon\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cTue\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cWed\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cThu\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cFri\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cSat\u003e) \u003d false) \u003d\u003e (((jc.isWeekday)(\u003cSun\u003e) \u003d false) \u003d\u003e pre_((jc.date2Str)(jc.getLastDayOfMonth)(2000, 2)))))))))))))))))","legal function application obligation:(((jc.isLeapYear)(2000) \u003d true) \u003d\u003e (((jc.isLeapYear)(2001) \u003d false) \u003d\u003e (((jc.isLeapYear)(1996) \u003d true) \u003d\u003e (((jc.isLeapYear)(1900) \u003d false) \u003d\u003e (((jc.isLeapYear)(1600) \u003d true) \u003d\u003e (((jc.isDateString)(\"sahara\") \u003d false) \u003d\u003e (((jc.isDateString)(\"20010723\") \u003d true) \u003d\u003e (((jc.isDateString)(\"20011232\") \u003d false) \u003d\u003e (((jc.isWeekday)(\u003cMon\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cTue\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cWed\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cThu\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cFri\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cSat\u003e) \u003d false) \u003d\u003e (((jc.isWeekday)(\u003cSun\u003e) \u003d false) \u003d\u003e pre_((jc.getLastDayOfMonth)2000, 2))))))))))))))))","legal function application obligation:(((jc.isLeapYear)(2000) \u003d true) \u003d\u003e (((jc.isLeapYear)(2001) \u003d false) \u003d\u003e (((jc.isLeapYear)(1996) \u003d true) \u003d\u003e (((jc.isLeapYear)(1900) \u003d false) \u003d\u003e (((jc.isLeapYear)(1600) \u003d true) \u003d\u003e (((jc.isDateString)(\"sahara\") \u003d false) \u003d\u003e (((jc.isDateString)(\"20010723\") \u003d true) \u003d\u003e (((jc.isDateString)(\"20011232\") \u003d false) \u003d\u003e (((jc.isWeekday)(\u003cMon\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cTue\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cWed\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cThu\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cFri\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cSat\u003e) \u003d false) \u003d\u003e (((jc.isWeekday)(\u003cSun\u003e) \u003d false) \u003d\u003e (((jc.date2Str)((jc.getLastDayOfMonth)(2000, 2)) \u003d \"20000229\") \u003d\u003e pre_((jc.date2Str)(jc.getLastDayOfMonth)(2001, 2))))))))))))))))))","legal function application obligation:(((jc.isLeapYear)(2000) \u003d true) \u003d\u003e (((jc.isLeapYear)(2001) \u003d false) \u003d\u003e (((jc.isLeapYear)(1996) \u003d true) \u003d\u003e (((jc.isLeapYear)(1900) \u003d false) \u003d\u003e (((jc.isLeapYear)(1600) \u003d true) \u003d\u003e (((jc.isDateString)(\"sahara\") \u003d false) \u003d\u003e (((jc.isDateString)(\"20010723\") \u003d true) \u003d\u003e (((jc.isDateString)(\"20011232\") \u003d false) \u003d\u003e (((jc.isWeekday)(\u003cMon\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cTue\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cWed\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cThu\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cFri\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cSat\u003e) \u003d false) \u003d\u003e (((jc.isWeekday)(\u003cSun\u003e) \u003d false) \u003d\u003e (((jc.date2Str)((jc.getLastDayOfMonth)(2000, 2)) \u003d \"20000229\") \u003d\u003e pre_((jc.getLastDayOfMonth)2001, 2)))))))))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(Real`EQ((r.getInterest)(2, 10))0.07177346254161253)","legal function application obligation:pre_((r.getInterest)2, 10)","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(Real`EQ((r.root)(2))1.414213562382246)","legal function application obligation:pre_((r.root)2)","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((r.isNDigitsAfterTheDecimalPoint)10.01, 2)","legal function application obligation:((r.isNDigitsAfterTheDecimalPoint)(10.01, 2) \u003d\u003e pre_((r.isNDigitsAfterTheDecimalPoint)10.01, 3))","legal function application obligation:((r.isNDigitsAfterTheDecimalPoint)(10.01, 2) \u003d\u003e ((not (r.isNDigitsAfterTheDecimalPoint)(10.01, 3)) \u003d\u003e pre_((r.isNDigitsAfterTheDecimalPoint)10.012, 3)))","legal function application obligation:((r.isNDigitsAfterTheDecimalPoint)(10.01, 2) \u003d\u003e ((not (r.isNDigitsAfterTheDecimalPoint)(10.01, 3)) \u003d\u003e ((r.isNDigitsAfterTheDecimalPoint)(10.012, 3) \u003d\u003e pre_((r.isNDigitsAfterTheDecimalPoint)10.0, 0))))","legal function application obligation:((r.isNDigitsAfterTheDecimalPoint)(10.01, 2) \u003d\u003e ((not (r.isNDigitsAfterTheDecimalPoint)(10.01, 3)) \u003d\u003e ((r.isNDigitsAfterTheDecimalPoint)(10.012, 3) \u003d\u003e ((r.isNDigitsAfterTheDecimalPoint)(10.0, 0) \u003d\u003e pre_((r.isNDigitsAfterTheDecimalPoint)10.011, 2)))))","legal function application obligation:((r.isNDigitsAfterTheDecimalPoint)(10.01, 2) \u003d\u003e ((not (r.isNDigitsAfterTheDecimalPoint)(10.01, 3)) \u003d\u003e ((r.isNDigitsAfterTheDecimalPoint)(10.012, 3) \u003d\u003e ((r.isNDigitsAfterTheDecimalPoint)(10.0, 0) \u003d\u003e (((r.isNDigitsAfterTheDecimalPoint)(10.011, 2) \u003d false) \u003d\u003e pre_((r.isNDigitsAfterTheDecimalPoint)10.1, 0))))))","legal function application obligation:((r.isNDigitsAfterTheDecimalPoint)(10.01, 2) \u003d\u003e ((not (r.isNDigitsAfterTheDecimalPoint)(10.01, 3)) \u003d\u003e ((r.isNDigitsAfterTheDecimalPoint)(10.012, 3) \u003d\u003e ((r.isNDigitsAfterTheDecimalPoint)(10.0, 0) \u003d\u003e (((r.isNDigitsAfterTheDecimalPoint)(10.011, 2) \u003d false) \u003d\u003e (((r.isNDigitsAfterTheDecimalPoint)(10.1, 0) \u003d false) \u003d\u003e pre_((r.getNumberOfDigitsAfterTheDecimalPoint)-1.2)))))))","legal function application obligation:((r.isNDigitsAfterTheDecimalPoint)(10.01, 2) \u003d\u003e ((not (r.isNDigitsAfterTheDecimalPoint)(10.01, 3)) \u003d\u003e ((r.isNDigitsAfterTheDecimalPoint)(10.012, 3) \u003d\u003e ((r.isNDigitsAfterTheDecimalPoint)(10.0, 0) \u003d\u003e (((r.isNDigitsAfterTheDecimalPoint)(10.011, 2) \u003d false) \u003d\u003e (((r.isNDigitsAfterTheDecimalPoint)(10.1, 0) \u003d false) \u003d\u003e (((r.getNumberOfDigitsAfterTheDecimalPoint)(-1.2) \u003d 1) \u003d\u003e pre_((r.getNumberOfDigitsAfterTheDecimalPoint)1.0))))))))","legal function application obligation:((r.isNDigitsAfterTheDecimalPoint)(10.01, 2) \u003d\u003e ((not (r.isNDigitsAfterTheDecimalPoint)(10.01, 3)) \u003d\u003e ((r.isNDigitsAfterTheDecimalPoint)(10.012, 3) \u003d\u003e ((r.isNDigitsAfterTheDecimalPoint)(10.0, 0) \u003d\u003e (((r.isNDigitsAfterTheDecimalPoint)(10.011, 2) \u003d false) \u003d\u003e (((r.isNDigitsAfterTheDecimalPoint)(10.1, 0) \u003d false) \u003d\u003e (((r.getNumberOfDigitsAfterTheDecimalPoint)(-1.2) \u003d 1) \u003d\u003e (((r.getNumberOfDigitsAfterTheDecimalPoint)(1.0) \u003d 0) \u003d\u003e pre_((r.getNumberOfDigitsAfterTheDecimalPoint)1)))))))))","legal function application obligation:((r.isNDigitsAfterTheDecimalPoint)(10.01, 2) \u003d\u003e ((not (r.isNDigitsAfterTheDecimalPoint)(10.01, 3)) \u003d\u003e ((r.isNDigitsAfterTheDecimalPoint)(10.012, 3) \u003d\u003e ((r.isNDigitsAfterTheDecimalPoint)(10.0, 0) \u003d\u003e (((r.isNDigitsAfterTheDecimalPoint)(10.011, 2) \u003d false) \u003d\u003e (((r.isNDigitsAfterTheDecimalPoint)(10.1, 0) \u003d false) \u003d\u003e (((r.getNumberOfDigitsAfterTheDecimalPoint)(-1.2) \u003d 1) \u003d\u003e (((r.getNumberOfDigitsAfterTheDecimalPoint)(1.0) \u003d 0) \u003d\u003e (((r.getNumberOfDigitsAfterTheDecimalPoint)(1) \u003d 0) \u003d\u003e pre_((r.getNumberOfDigitsAfterTheDecimalPoint)1.23))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((r.numberOfDigit)0)","legal function application obligation:(((r.numberOfDigit)(0) \u003d 1) \u003d\u003e pre_((r.numberOfDigit)1))","legal function application obligation:(((r.numberOfDigit)(0) \u003d 1) \u003d\u003e (((r.numberOfDigit)(1) \u003d 1) \u003d\u003e pre_((r.numberOfDigit)9)))","legal function application obligation:(((r.numberOfDigit)(0) \u003d 1) \u003d\u003e (((r.numberOfDigit)(1) \u003d 1) \u003d\u003e (((r.numberOfDigit)(9) \u003d 1) \u003d\u003e pre_((r.numberOfDigit)10))))","legal function application obligation:(((r.numberOfDigit)(0) \u003d 1) \u003d\u003e (((r.numberOfDigit)(1) \u003d 1) \u003d\u003e (((r.numberOfDigit)(9) \u003d 1) \u003d\u003e (((r.numberOfDigit)(10) \u003d 2) \u003d\u003e pre_((r.numberOfDigit)99)))))","legal function application obligation:(((r.numberOfDigit)(0) \u003d 1) \u003d\u003e (((r.numberOfDigit)(1) \u003d 1) \u003d\u003e (((r.numberOfDigit)(9) \u003d 1) \u003d\u003e (((r.numberOfDigit)(10) \u003d 2) \u003d\u003e (((r.numberOfDigit)(99) \u003d 2) \u003d\u003e pre_((r.numberOfDigit)100))))))","legal function application obligation:(((r.numberOfDigit)(0) \u003d 1) \u003d\u003e (((r.numberOfDigit)(1) \u003d 1) \u003d\u003e (((r.numberOfDigit)(9) \u003d 1) \u003d\u003e (((r.numberOfDigit)(10) \u003d 2) \u003d\u003e (((r.numberOfDigit)(99) \u003d 2) \u003d\u003e (((r.numberOfDigit)(100) \u003d 3) \u003d\u003e pre_((r.numberOfDigit)0.1)))))))","legal function application obligation:(((r.numberOfDigit)(0) \u003d 1) \u003d\u003e (((r.numberOfDigit)(1) \u003d 1) \u003d\u003e (((r.numberOfDigit)(9) \u003d 1) \u003d\u003e (((r.numberOfDigit)(10) \u003d 2) \u003d\u003e (((r.numberOfDigit)(99) \u003d 2) \u003d\u003e (((r.numberOfDigit)(100) \u003d 3) \u003d\u003e (((r.numberOfDigit)(0.1) \u003d 3) \u003d\u003e pre_((r.numberOfDigit)9.1))))))))","legal function application obligation:(((r.numberOfDigit)(0) \u003d 1) \u003d\u003e (((r.numberOfDigit)(1) \u003d 1) \u003d\u003e (((r.numberOfDigit)(9) \u003d 1) \u003d\u003e (((r.numberOfDigit)(10) \u003d 2) \u003d\u003e (((r.numberOfDigit)(99) \u003d 2) \u003d\u003e (((r.numberOfDigit)(100) \u003d 3) \u003d\u003e (((r.numberOfDigit)(0.1) \u003d 3) \u003d\u003e (((r.numberOfDigit)(9.1) \u003d 3) \u003d\u003e pre_((r.numberOfDigit)10.1)))))))))","legal function application obligation:(((r.numberOfDigit)(0) \u003d 1) \u003d\u003e (((r.numberOfDigit)(1) \u003d 1) \u003d\u003e (((r.numberOfDigit)(9) \u003d 1) \u003d\u003e (((r.numberOfDigit)(10) \u003d 2) \u003d\u003e (((r.numberOfDigit)(99) \u003d 2) \u003d\u003e (((r.numberOfDigit)(100) \u003d 3) \u003d\u003e (((r.numberOfDigit)(0.1) \u003d 3) \u003d\u003e (((r.numberOfDigit)(9.1) \u003d 3) \u003d\u003e (((r.numberOfDigit)(10.1) \u003d 4) \u003d\u003e pre_((r.numberOfDigit)10.123))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 4))10.1235)","legal function application obligation:pre_roundAterDecimalPointByNdigit(10.12345, 4)","legal function application obligation:(Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 4))(10.1235) \u003d\u003e pre_(Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 3))10.123))","legal function application obligation:(Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 4))(10.1235) \u003d\u003e pre_roundAterDecimalPointByNdigit(10.12345, 3))","legal function application obligation:(Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 4))(10.1235) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 3))(10.123) \u003d\u003e pre_(Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 2))10.12)))","legal function application obligation:(Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 4))(10.1235) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 3))(10.123) \u003d\u003e pre_roundAterDecimalPointByNdigit(10.12345, 2)))","legal function application obligation:(Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 4))(10.1235) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 3))(10.123) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 2))(10.12) \u003d\u003e pre_(Real`EQ(Real`roundAterDecimalPointByNdigit(10.125, 2))10.13))))","legal function application obligation:(Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 4))(10.1235) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 3))(10.123) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 2))(10.12) \u003d\u003e pre_roundAterDecimalPointByNdigit(10.125, 2))))","legal function application obligation:(Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 4))(10.1235) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 3))(10.123) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 2))(10.12) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.125, 2))(10.13) \u003d\u003e pre_(Real`EQ(Real`roundAterDecimalPointByNdigit(10.14, 1))10.1)))))","legal function application obligation:(Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 4))(10.1235) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 3))(10.123) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 2))(10.12) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.125, 2))(10.13) \u003d\u003e pre_roundAterDecimalPointByNdigit(10.14, 1)))))","legal function application obligation:(Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 4))(10.1235) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 3))(10.123) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 2))(10.12) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.125, 2))(10.13) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.14, 1))(10.1) \u003d\u003e pre_(Real`EQ(Real`roundAterDecimalPointByNdigit(10.15, 1))10.2))))))","legal function application obligation:(Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 4))(10.1235) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 3))(10.123) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 2))(10.12) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.125, 2))(10.13) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.14, 1))(10.1) \u003d\u003e pre_roundAterDecimalPointByNdigit(10.15, 1))))))","legal function application obligation:(Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 4))(10.1235) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 3))(10.123) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 2))(10.12) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.125, 2))(10.13) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.14, 1))(10.1) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.15, 1))(10.2) \u003d\u003e pre_(Real`EQ(Real`roundAterDecimalPointByNdigit(10.5, 0))11)))))))","legal function application obligation:(Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 4))(10.1235) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 3))(10.123) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 2))(10.12) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.125, 2))(10.13) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.14, 1))(10.1) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.15, 1))(10.2) \u003d\u003e pre_roundAterDecimalPointByNdigit(10.5, 0)))))))","legal function application obligation:(Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 4))(10.1235) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 3))(10.123) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 2))(10.12) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.125, 2))(10.13) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.14, 1))(10.1) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.15, 1))(10.2) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.5, 0))(11) \u003d\u003e pre_(Real`EQ(Real`roundAterDecimalPointByNdigit(10.4, 0))10))))))))","legal function application obligation:(Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 4))(10.1235) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 3))(10.123) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 2))(10.12) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.125, 2))(10.13) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.14, 1))(10.1) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.15, 1))(10.2) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.5, 0))(11) \u003d\u003e pre_roundAterDecimalPointByNdigit(10.4, 0))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(Real`EQ(10.0123456678)10.0123456789)","legal function application obligation:((Real`EQ(10.0123456678)(10.0123456789) \u003d false) \u003d\u003e pre_(Real`EQ(10.01234567891)10.01234567892))","legal function application obligation:((Real`EQ(10.0123456678)(10.0123456789) \u003d false) \u003d\u003e (Real`EQ(10.01234567891)(10.01234567892) \u003d\u003e pre_(Real`EQ(10.012345678801)10.0123456789)))","legal function application obligation:((Real`EQ(10.0123456678)(10.0123456789) \u003d false) \u003d\u003e (Real`EQ(10.01234567891)(10.01234567892) \u003d\u003e (Real`EQ(10.012345678801)(10.0123456789) \u003d\u003e pre_(Real`EQE(0.01)(10.12345)10.12987))))","legal function application obligation:((Real`EQ(10.0123456678)(10.0123456789) \u003d false) \u003d\u003e (Real`EQ(10.01234567891)(10.01234567892) \u003d\u003e (Real`EQ(10.012345678801)(10.0123456789) \u003d\u003e pre_(Real`EQE(0.01)10.12345))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(Real`EQ(Real`integrate(f1)(10)(1)(2))2.735)","legal function application obligation:pre_(Real`integrate(f1)(10)(1)2)","legal function application obligation:pre_(Real`integrate(f1)(10)1)","legal function application obligation:pre_(Real`integrate(f1)10)","legal function application obligation:(Real`EQ(Real`integrate(f1)(10)(1)(2))(2.735) \u003d\u003e pre_(Real`EQ(Real`integrate(f1)(100)(1)(2))2.37335))","legal function application obligation:(Real`EQ(Real`integrate(f1)(10)(1)(2))(2.735) \u003d\u003e pre_(Real`integrate(f1)(100)(1)2))","legal function application obligation:(Real`EQ(Real`integrate(f1)(10)(1)(2))(2.735) \u003d\u003e pre_(Real`integrate(f1)(100)1))","legal function application obligation:(Real`EQ(Real`integrate(f1)(10)(1)(2))(2.735) \u003d\u003e pre_(Real`integrate(f1)100))","legal function application obligation:(Real`EQ(Real`integrate(f1)(10)(1)(2))(2.735) \u003d\u003e (Real`EQ(Real`integrate(f1)(100)(1)(2))(2.37335) \u003d\u003e pre_(Real`EQ(Real`integrate(f1)(1000)(1)(2))2.3373335)))","legal function application obligation:(Real`EQ(Real`integrate(f1)(10)(1)(2))(2.735) \u003d\u003e (Real`EQ(Real`integrate(f1)(100)(1)(2))(2.37335) \u003d\u003e pre_(Real`integrate(f1)(1000)(1)2)))","legal function application obligation:(Real`EQ(Real`integrate(f1)(10)(1)(2))(2.735) \u003d\u003e (Real`EQ(Real`integrate(f1)(100)(1)(2))(2.37335) \u003d\u003e pre_(Real`integrate(f1)(1000)1)))","legal function application obligation:(Real`EQ(Real`integrate(f1)(10)(1)(2))(2.735) \u003d\u003e (Real`EQ(Real`integrate(f1)(100)(1)(2))(2.37335) \u003d\u003e pre_(Real`integrate(f1)1000)))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(Real`EQ(Real`integrate(sin)(2)(0)(pi))1.5707963278)","legal function application obligation:pre_(Real`integrate(sin)(2)(0)pi)","legal function application obligation:pre_(Real`integrate(sin)(2)0)","legal function application obligation:pre_(Real`integrate(sin)2)","legal function application obligation:(Real`EQ(Real`integrate(sin)(2)(0)(pi))(1.5707963278) \u003d\u003e pre_(Real`EQ(Real`integrate(sin)(3)(0)(pi))1.8137993649))","legal function application obligation:(Real`EQ(Real`integrate(sin)(2)(0)(pi))(1.5707963278) \u003d\u003e pre_(Real`integrate(sin)(3)(0)pi))","legal function application obligation:(Real`EQ(Real`integrate(sin)(2)(0)(pi))(1.5707963278) \u003d\u003e pre_(Real`integrate(sin)(3)0))","legal function application obligation:(Real`EQ(Real`integrate(sin)(2)(0)(pi))(1.5707963278) \u003d\u003e pre_(Real`integrate(sin)3))","legal function application obligation:(Real`EQ(Real`integrate(sin)(2)(0)(pi))(1.5707963278) \u003d\u003e (Real`EQ(Real`integrate(sin)(3)(0)(pi))(1.8137993649) \u003d\u003e pre_(Real`EQ(Real`integrate(sin)(4)(0)(pi))1.8961188984)))","legal function application obligation:(Real`EQ(Real`integrate(sin)(2)(0)(pi))(1.5707963278) \u003d\u003e (Real`EQ(Real`integrate(sin)(3)(0)(pi))(1.8137993649) \u003d\u003e pre_(Real`integrate(sin)(4)(0)pi)))","legal function application obligation:(Real`EQ(Real`integrate(sin)(2)(0)(pi))(1.5707963278) \u003d\u003e (Real`EQ(Real`integrate(sin)(3)(0)(pi))(1.8137993649) \u003d\u003e pre_(Real`integrate(sin)(4)0)))","legal function application obligation:(Real`EQ(Real`integrate(sin)(2)(0)(pi))(1.5707963278) \u003d\u003e (Real`EQ(Real`integrate(sin)(3)(0)(pi))(1.8137993649) \u003d\u003e pre_(Real`integrate(sin)4)))","legal function application obligation:(Real`EQ(Real`integrate(sin)(2)(0)(pi))(1.5707963278) \u003d\u003e (Real`EQ(Real`integrate(sin)(3)(0)(pi))(1.8137993649) \u003d\u003e (Real`EQ(Real`integrate(sin)(4)(0)(pi))(1.8961188984) \u003d\u003e pre_(Real`EQ(Real`integrate(sin)(5)(0)(pi))1.9337655984))))","legal function application obligation:(Real`EQ(Real`integrate(sin)(2)(0)(pi))(1.5707963278) \u003d\u003e (Real`EQ(Real`integrate(sin)(3)(0)(pi))(1.8137993649) \u003d\u003e (Real`EQ(Real`integrate(sin)(4)(0)(pi))(1.8961188984) \u003d\u003e pre_(Real`integrate(sin)(5)(0)pi))))","legal function application obligation:(Real`EQ(Real`integrate(sin)(2)(0)(pi))(1.5707963278) \u003d\u003e (Real`EQ(Real`integrate(sin)(3)(0)(pi))(1.8137993649) \u003d\u003e (Real`EQ(Real`integrate(sin)(4)(0)(pi))(1.8961188984) \u003d\u003e pre_(Real`integrate(sin)(5)0))))","legal function application obligation:(Real`EQ(Real`integrate(sin)(2)(0)(pi))(1.5707963278) \u003d\u003e (Real`EQ(Real`integrate(sin)(3)(0)(pi))(1.8137993649) \u003d\u003e (Real`EQ(Real`integrate(sin)(4)(0)(pi))(1.8961188984) \u003d\u003e pre_(Real`integrate(sin)5))))","legal function application obligation:(Real`EQ(Real`integrate(sin)(2)(0)(pi))(1.5707963278) \u003d\u003e (Real`EQ(Real`integrate(sin)(3)(0)(pi))(1.8137993649) \u003d\u003e (Real`EQ(Real`integrate(sin)(4)(0)(pi))(1.8961188984) \u003d\u003e (Real`EQ(Real`integrate(sin)(5)(0)(pi))(1.9337655984) \u003d\u003e pre_(Real`EQ(Real`integrate(sin)(2000)(1)(pi))1.5403021586)))))","legal function application obligation:(Real`EQ(Real`integrate(sin)(2)(0)(pi))(1.5707963278) \u003d\u003e (Real`EQ(Real`integrate(sin)(3)(0)(pi))(1.8137993649) \u003d\u003e (Real`EQ(Real`integrate(sin)(4)(0)(pi))(1.8961188984) \u003d\u003e (Real`EQ(Real`integrate(sin)(5)(0)(pi))(1.9337655984) \u003d\u003e pre_(Real`integrate(sin)(2000)(1)pi)))))","legal function application obligation:(Real`EQ(Real`integrate(sin)(2)(0)(pi))(1.5707963278) \u003d\u003e (Real`EQ(Real`integrate(sin)(3)(0)(pi))(1.8137993649) \u003d\u003e (Real`EQ(Real`integrate(sin)(4)(0)(pi))(1.8961188984) \u003d\u003e (Real`EQ(Real`integrate(sin)(5)(0)(pi))(1.9337655984) \u003d\u003e pre_(Real`integrate(sin)(2000)1)))))","legal function application obligation:(Real`EQ(Real`integrate(sin)(2)(0)(pi))(1.5707963278) \u003d\u003e (Real`EQ(Real`integrate(sin)(3)(0)(pi))(1.8137993649) \u003d\u003e (Real`EQ(Real`integrate(sin)(4)(0)(pi))(1.8961188984) \u003d\u003e (Real`EQ(Real`integrate(sin)(5)(0)(pi))(1.9337655984) \u003d\u003e pre_(Real`integrate(sin)2000)))))","type compatibility obligation:is_(RESULT, ())","operation call obligation:(forall text:seq of (char) \u0026 ((\"\" \u003d \"\") \u003c\u003d\u003e (\"\" \u003d nil)))","non-zero obligation:(forall a:real \u0026 ((a \u003c\u003e 0) \u003d\u003e (a \u003c\u003e 0)))"] \ No newline at end of file +["legal map application obligation:(forall aMap:map (@T1) to (@T2), aKey:@T1 \u0026 ((aKey in set (dom aMap)) \u003d\u003e (aKey in set (dom aMap))))","legal sequence application obligation:(forall t:seq of (TestCase) \u0026 (forall i in set (inds t) \u0026 (i in set (inds t))))","legal sequence application obligation:(forall t:seq of (TestCase) \u0026 let m:seq1 of (char) \u003d \"Result-of-testcases.\", r:seq of (bool) \u003d [isOK(t(i)) | i in set (inds t)] in (forall i in set (inds r) \u0026 (i in set (inds r))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:(forall p:(@T -\u003e bool), f:(@T -\u003e @T), x:@T \u0026 pre_(px))","legal function application obligation:(forall p:(@T -\u003e bool), f:(@T -\u003e @T), x:@T \u0026 ((not p(x)) \u003d\u003e pre_((Funtil)[@T](p)(f)f(x))))","legal function application obligation:(forall p:(@T -\u003e bool), f:(@T -\u003e @T), x:@T \u0026 ((not p(x)) \u003d\u003e pre_((Funtil)[@T](p)f)))","legal function application obligation:(forall p:(@T -\u003e bool), f:(@T -\u003e @T), x:@T \u0026 ((not p(x)) \u003d\u003e pre_(fx)))","legal function application obligation:(forall p:(@T -\u003e bool), f:(@T -\u003e @T), x:@T \u0026 pre_(px))","legal function application obligation:(forall p:(@T -\u003e bool), f:(@T -\u003e @T), x:@T \u0026 (p(x) \u003d\u003e pre_((Fwhile)[@T](p)(f)f(x))))","legal function application obligation:(forall p:(@T -\u003e bool), f:(@T -\u003e @T), x:@T \u0026 (p(x) \u003d\u003e pre_((Fwhile)[@T](p)f)))","legal function application obligation:(forall p:(@T -\u003e bool), f:(@T -\u003e @T), x:@T \u0026 (p(x) \u003d\u003e pre_(fx)))","legal function application obligation:(forall fs:seq of ((@T -\u003e @T)), p:@T \u0026 (exists [xf] ^ xfs:seq of ((@T -\u003e @T)) \u0026 ((([xf] ^ xfs) \u003d fs) \u003d\u003e let [xf] ^ xfs \u003d fs in pre_((Seq)[@T](xfs)xf(p)))))","legal function application obligation:(forall fs:seq of ((@T -\u003e @T)), p:@T \u0026 (exists [xf] ^ xfs:seq of ((@T -\u003e @T)) \u0026 ((([xf] ^ xfs) \u003d fs) \u003d\u003e let [xf] ^ xfs \u003d fs in pre_(xfp))))","cases exhaustive obligation:(forall fs:seq of ((@T -\u003e @T)), p:@T \u0026 ((exists [xf] ^ xfs:seq of ((@T -\u003e @T)) \u0026 (fs \u003d ([xf] ^ xfs))) or (fs \u003d [])))","legal function application obligation:(forall fname:seq of (char) \u0026 pre_(((io.freadval))[@T]fname))","legal function application obligation:(forall s:seq of (@T) \u0026 ((is_(s, seq of (int)) or (is_(s, seq of (nat)) or (is_(s, seq of (nat1)) or (is_(s, seq of (real)) or is_(s, seq of (rat)))))) \u003d\u003e pre_((Foldl)[@T, @T]((Plus)[@T])(0)s)))","legal function application obligation:(forall s:seq of (@T) \u0026 ((is_(s, seq of (int)) or (is_(s, seq of (nat)) or (is_(s, seq of (nat1)) or (is_(s, seq of (real)) or is_(s, seq of (rat)))))) \u003d\u003e pre_((Foldl)[@T, @T]((Plus)[@T])0)))","legal function application obligation:(forall s:seq of (@T) \u0026 ((is_(s, seq of (int)) or (is_(s, seq of (nat)) or (is_(s, seq of (nat1)) or (is_(s, seq of (real)) or is_(s, seq of (rat)))))) \u003d\u003e pre_((Foldl)[@T, @T]((Product)[@T])(1)s)))","legal function application obligation:(forall s:seq of (@T) \u0026 ((is_(s, seq of (int)) or (is_(s, seq of (nat)) or (is_(s, seq of (nat1)) or (is_(s, seq of (real)) or is_(s, seq of (rat)))))) \u003d\u003e pre_((Foldl)[@T, @T]((Product)[@T])1)))","function establishes postcondition obligation:(forall s:seq of (@T) \u0026 post_Average(s, (if (s \u003d [])\nthen nil\nelse (AverageAux)[@T](0)(0)(s))))","legal function application obligation:(forall s:seq of (@T) \u0026 let RESULT \u003d (if (s \u003d [])\nthen nil\nelse (AverageAux)[@T](0)(0)(s)) in ((not (s \u003d [])) \u003d\u003e pre_Sum(s)))","non-zero obligation:(forall s:seq of (@T) \u0026 let RESULT \u003d (if (s \u003d [])\nthen nil\nelse (AverageAux)[@T](0)(0)(s)) in ((not (s \u003d [])) \u003d\u003e let sum:@T \u003d (Sum)[@T](s) in (is_(sum, real) \u003d\u003e ((len s) \u003c\u003e 0))))","legal function application obligation:(forall s:seq of (@T) \u0026 ((not (s \u003d [])) \u003d\u003e pre_((AverageAux)[@T](0)(0)s)))","legal function application obligation:(forall s:seq of (@T) \u0026 ((not (s \u003d [])) \u003d\u003e pre_((AverageAux)[@T](0)0)))","legal function application obligation:(forall total:@T, numOfElem:@T, s:seq of (@T) \u0026 ((is_(s, seq of (real)) and (is_(total, real) and is_(numOfElem, real))) \u003d\u003e (exists [x] ^ xs:seq of (real) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in pre_((AverageAux)[@T]((total + x))((numOfElem + 1))xs)))))","legal function application obligation:(forall total:@T, numOfElem:@T, s:seq of (@T) \u0026 ((is_(s, seq of (real)) and (is_(total, real) and is_(numOfElem, real))) \u003d\u003e (exists [x] ^ xs:seq of (real) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in pre_((AverageAux)[@T]((total + x))(numOfElem + 1))))))","non-zero obligation:(forall total:@T, numOfElem:@T, s:seq of (@T) \u0026 ((is_(s, seq of (real)) and (is_(total, real) and is_(numOfElem, real))) \u003d\u003e ((not (exists [x] ^ xs:seq of (real) \u0026 (([x] ^ xs) \u003d s))) \u003d\u003e (([] \u003d s) \u003d\u003e (numOfElem \u003c\u003e 0)))))","cases exhaustive obligation:(forall total:@T, numOfElem:@T, s:seq of (@T) \u0026 ((is_(s, seq of (real)) and (is_(total, real) and is_(numOfElem, real))) \u003d\u003e ((exists [x] ^ xs:seq of (real) \u0026 (s \u003d ([x] ^ xs))) or (s \u003d []))))","legal function application obligation:(forall f:(@T * @T -\u003e bool), s:seq of (@T) \u0026 (forall i, j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e pre_(fs(i), s(j)))))","legal sequence application obligation:(forall f:(@T * @T -\u003e bool), s:seq of (@T) \u0026 (forall i, j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e (i in set (inds s)))))","legal sequence application obligation:(forall f:(@T * @T -\u003e bool), s:seq of (@T) \u0026 (forall i, j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e (j in set (inds s)))))","legal sequence application obligation:(forall f:(@T * @T -\u003e bool), s:seq of (@T) \u0026 (forall i, j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e ((not f(s(i), s(j))) \u003d\u003e (i in set (inds s))))))","legal sequence application obligation:(forall f:(@T * @T -\u003e bool), s:seq of (@T) \u0026 (forall i, j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e ((not f(s(i), s(j))) \u003d\u003e (j in set (inds s))))))","legal function application obligation:(forall f:(@T * @T -\u003e bool), s:seq of (@T) \u0026 (forall i, j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e pre_(fs(j), s(i)))))","legal sequence application obligation:(forall f:(@T * @T -\u003e bool), s:seq of (@T) \u0026 (forall i, j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e (j in set (inds s)))))","legal sequence application obligation:(forall f:(@T * @T -\u003e bool), s:seq of (@T) \u0026 (forall i, j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e (i in set (inds s)))))","legal sequence application obligation:(forall f:(@T * @T -\u003e bool), s:seq of (@T) \u0026 (forall i, j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e ((not f(s(j), s(i))) \u003d\u003e (i in set (inds s))))))","legal sequence application obligation:(forall f:(@T * @T -\u003e bool), s:seq of (@T) \u0026 (forall i, j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e ((not f(s(j), s(i))) \u003d\u003e (j in set (inds s))))))","legal function application obligation:(forall s:seq of (@T) \u0026 pre_((IsAscendingInTotalOrder)[@T]((lambda [x:@T, y:@T] \u0026 (if (is_(x, real) and is_(y, real))\nthen (x \u003c y)\nelse (undefined))))s))","legal function application obligation:(forall s:seq of (@T) \u0026 pre_((IsDescendingInTotalOrder)[@T]((lambda [x:@T, y:@T] \u0026 (if (is_(x, real) and is_(y, real))\nthen (x \u003c y)\nelse (undefined))))s))","legal function application obligation:(forall f:(@T * @T -\u003e bool), s:seq of (@T) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in pre_((Sort)[@T](f)[xs(i) | i in set (inds xs) \u0026 f(xs(i), x)])))))","legal sequence application obligation:(forall f:(@T * @T -\u003e bool), s:seq of (@T) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in (forall i in set (inds xs) \u0026 (f(xs(i), x) \u003d\u003e (i in set (inds xs))))))))","legal function application obligation:(forall f:(@T * @T -\u003e bool), s:seq of (@T) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in (forall i in set (inds xs) \u0026 pre_(fxs(i), x))))))","legal sequence application obligation:(forall f:(@T * @T -\u003e bool), s:seq of (@T) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in (forall i in set (inds xs) \u0026 (i in set (inds xs)))))))","legal function application obligation:(forall f:(@T * @T -\u003e bool), s:seq of (@T) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in pre_((Sort)[@T](f)[xs(i) | i in set (inds xs) \u0026 (not f(xs(i), x))])))))","legal sequence application obligation:(forall f:(@T * @T -\u003e bool), s:seq of (@T) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in (forall i in set (inds xs) \u0026 ((not f(xs(i), x)) \u003d\u003e (i in set (inds xs))))))))","legal function application obligation:(forall f:(@T * @T -\u003e bool), s:seq of (@T) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in (forall i in set (inds xs) \u0026 pre_(fxs(i), x))))))","legal sequence application obligation:(forall f:(@T * @T -\u003e bool), s:seq of (@T) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in (forall i in set (inds xs) \u0026 (i in set (inds xs)))))))","cases exhaustive obligation:(forall f:(@T * @T -\u003e bool), s:seq of (@T) \u0026 ((s \u003d []) or (exists [x] ^ xs:seq of (@T) \u0026 (s \u003d ([x] ^ xs)))))","function establishes postcondition obligation:(forall s:seq of (@T) \u0026 post_AscendingSort(s, (Sort)[@T]((lambda [x:@T, y:@T] \u0026 (if (is_(x, real) and is_(y, real))\nthen (x \u003c y)\nelse (undefined))))(s)))","legal function application obligation:(forall s:seq of (@T) \u0026 pre_((Sort)[@T]((lambda [x:@T, y:@T] \u0026 (if (is_(x, real) and is_(y, real))\nthen (x \u003c y)\nelse (undefined))))s))","function establishes postcondition obligation:(forall s:seq of (@T) \u0026 post_DescendingSort(s, (Sort)[@T]((lambda [x:@T, y:@T] \u0026 (if (is_(x, real) and is_(y, real))\nthen (x \u003e y)\nelse (undefined))))(s)))","legal function application obligation:(forall s:seq of (@T) \u0026 pre_((Sort)[@T]((lambda [x:@T, y:@T] \u0026 (if (is_(x, real) and is_(y, real))\nthen (x \u003e y)\nelse (undefined))))s))","legal function application obligation:(forall f:seq of ((@T * @T -\u003e bool)), s1:seq of (@T), s2:seq of (@T) \u0026 ((not (mk_([], []) \u003d mk_(s1, s2))) \u003d\u003e ((not (exists mk_([], -):(seq of (@T) * seq of (@T)) \u0026 (mk_([], any1) \u003d mk_(s1, s2)))) \u003d\u003e ((not (exists mk_(-, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(any1, []) \u003d mk_(s1, s2)))) \u003d\u003e (exists mk_([x1] ^ xs1, [x2] ^ xs2):(seq of (@T) * seq of (@T)) \u0026 ((mk_(([x1] ^ xs1), ([x2] ^ xs2)) \u003d mk_(s1, s2)) \u003d\u003e let mk_([x1] ^ xs1, [x2] ^ xs2) \u003d mk_(s1, s2) in pre_((hd f)x1, x2)))))))","non-empty sequence obligation:(forall f:seq of ((@T * @T -\u003e bool)), s1:seq of (@T), s2:seq of (@T) \u0026 ((not (mk_([], []) \u003d mk_(s1, s2))) \u003d\u003e ((not (exists mk_([], -):(seq of (@T) * seq of (@T)) \u0026 (mk_([], any1) \u003d mk_(s1, s2)))) \u003d\u003e ((not (exists mk_(-, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(any1, []) \u003d mk_(s1, s2)))) \u003d\u003e (exists mk_([x1] ^ xs1, [x2] ^ xs2):(seq of (@T) * seq of (@T)) \u0026 ((mk_(([x1] ^ xs1), ([x2] ^ xs2)) \u003d mk_(s1, s2)) \u003d\u003e let mk_([x1] ^ xs1, [x2] ^ xs2) \u003d mk_(s1, s2) in (f \u003c\u003e [])))))))","legal function application obligation:(forall f:seq of ((@T * @T -\u003e bool)), s1:seq of (@T), s2:seq of (@T) \u0026 ((not (mk_([], []) \u003d mk_(s1, s2))) \u003d\u003e ((not (exists mk_([], -):(seq of (@T) * seq of (@T)) \u0026 (mk_([], any1) \u003d mk_(s1, s2)))) \u003d\u003e ((not (exists mk_(-, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(any1, []) \u003d mk_(s1, s2)))) \u003d\u003e (exists mk_([x1] ^ xs1, [x2] ^ xs2):(seq of (@T) * seq of (@T)) \u0026 ((mk_(([x1] ^ xs1), ([x2] ^ xs2)) \u003d mk_(s1, s2)) \u003d\u003e let mk_([x1] ^ xs1, [x2] ^ xs2) \u003d mk_(s1, s2) in ((not (hd f)(x1, x2)) \u003d\u003e ((not (hd f)(x2, x1)) \u003d\u003e pre_((IsOrdered)[@T]((tl f))(xs1)xs2)))))))))","legal function application obligation:(forall f:seq of ((@T * @T -\u003e bool)), s1:seq of (@T), s2:seq of (@T) \u0026 ((not (mk_([], []) \u003d mk_(s1, s2))) \u003d\u003e ((not (exists mk_([], -):(seq of (@T) * seq of (@T)) \u0026 (mk_([], any1) \u003d mk_(s1, s2)))) \u003d\u003e ((not (exists mk_(-, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(any1, []) \u003d mk_(s1, s2)))) \u003d\u003e (exists mk_([x1] ^ xs1, [x2] ^ xs2):(seq of (@T) * seq of (@T)) \u0026 ((mk_(([x1] ^ xs1), ([x2] ^ xs2)) \u003d mk_(s1, s2)) \u003d\u003e let mk_([x1] ^ xs1, [x2] ^ xs2) \u003d mk_(s1, s2) in ((not (hd f)(x1, x2)) \u003d\u003e ((not (hd f)(x2, x1)) \u003d\u003e pre_((IsOrdered)[@T]((tl f))xs1)))))))))","non-empty sequence obligation:(forall f:seq of ((@T * @T -\u003e bool)), s1:seq of (@T), s2:seq of (@T) \u0026 ((not (mk_([], []) \u003d mk_(s1, s2))) \u003d\u003e ((not (exists mk_([], -):(seq of (@T) * seq of (@T)) \u0026 (mk_([], any1) \u003d mk_(s1, s2)))) \u003d\u003e ((not (exists mk_(-, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(any1, []) \u003d mk_(s1, s2)))) \u003d\u003e (exists mk_([x1] ^ xs1, [x2] ^ xs2):(seq of (@T) * seq of (@T)) \u0026 ((mk_(([x1] ^ xs1), ([x2] ^ xs2)) \u003d mk_(s1, s2)) \u003d\u003e let mk_([x1] ^ xs1, [x2] ^ xs2) \u003d mk_(s1, s2) in ((not (hd f)(x1, x2)) \u003d\u003e ((not (hd f)(x2, x1)) \u003d\u003e (f \u003c\u003e [])))))))))","cases exhaustive obligation:(forall f:seq of ((@T * @T -\u003e bool)), s1:seq of (@T), s2:seq of (@T) \u0026 ((((mk_(s1, s2) \u003d mk_([], [])) or (exists mk_([], -):(seq of (@T) * seq of (@T)) \u0026 (mk_(s1, s2) \u003d mk_([], any1)))) or (exists mk_(-, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(s1, s2) \u003d mk_(any1, [])))) or (exists mk_([x1] ^ xs1, [x2] ^ xs2):(seq of (@T) * seq of (@T)) \u0026 (mk_(s1, s2) \u003d mk_(([x1] ^ xs1), ([x2] ^ xs2))))))","legal function application obligation:(forall f:(@T * @T -\u003e bool), s1:seq of (@T), s2:seq of (@T) \u0026 ((not (exists mk_([], y):(seq of (@T) * seq of (@T)) \u0026 (mk_([], y) \u003d mk_(s1, s2)))) \u003d\u003e ((not (exists mk_(x, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(x, []) \u003d mk_(s1, s2)))) \u003d\u003e (exists mk_([x1] ^ xs1, [x2] ^ xs2):(seq of (@T) * seq of (@T)) \u0026 ((mk_(([x1] ^ xs1), ([x2] ^ xs2)) \u003d mk_(s1, s2)) \u003d\u003e let mk_([x1] ^ xs1, [x2] ^ xs2) \u003d mk_(s1, s2) in pre_(fx1, x2))))))","legal function application obligation:(forall f:(@T * @T -\u003e bool), s1:seq of (@T), s2:seq of (@T) \u0026 ((not (exists mk_([], y):(seq of (@T) * seq of (@T)) \u0026 (mk_([], y) \u003d mk_(s1, s2)))) \u003d\u003e ((not (exists mk_(x, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(x, []) \u003d mk_(s1, s2)))) \u003d\u003e (exists mk_([x1] ^ xs1, [x2] ^ xs2):(seq of (@T) * seq of (@T)) \u0026 ((mk_(([x1] ^ xs1), ([x2] ^ xs2)) \u003d mk_(s1, s2)) \u003d\u003e let mk_([x1] ^ xs1, [x2] ^ xs2) \u003d mk_(s1, s2) in (f(x1, x2) \u003d\u003e pre_((FSequence`Merge)[@T](f)(xs1)s2)))))))","legal function application obligation:(forall f:(@T * @T -\u003e bool), s1:seq of (@T), s2:seq of (@T) \u0026 ((not (exists mk_([], y):(seq of (@T) * seq of (@T)) \u0026 (mk_([], y) \u003d mk_(s1, s2)))) \u003d\u003e ((not (exists mk_(x, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(x, []) \u003d mk_(s1, s2)))) \u003d\u003e (exists mk_([x1] ^ xs1, [x2] ^ xs2):(seq of (@T) * seq of (@T)) \u0026 ((mk_(([x1] ^ xs1), ([x2] ^ xs2)) \u003d mk_(s1, s2)) \u003d\u003e let mk_([x1] ^ xs1, [x2] ^ xs2) \u003d mk_(s1, s2) in (f(x1, x2) \u003d\u003e pre_((FSequence`Merge)[@T](f)xs1)))))))","legal function application obligation:(forall f:(@T * @T -\u003e bool), s1:seq of (@T), s2:seq of (@T) \u0026 ((not (exists mk_([], y):(seq of (@T) * seq of (@T)) \u0026 (mk_([], y) \u003d mk_(s1, s2)))) \u003d\u003e ((not (exists mk_(x, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(x, []) \u003d mk_(s1, s2)))) \u003d\u003e (exists mk_([x1] ^ xs1, [x2] ^ xs2):(seq of (@T) * seq of (@T)) \u0026 ((mk_(([x1] ^ xs1), ([x2] ^ xs2)) \u003d mk_(s1, s2)) \u003d\u003e let mk_([x1] ^ xs1, [x2] ^ xs2) \u003d mk_(s1, s2) in ((not f(x1, x2)) \u003d\u003e pre_((FSequence`Merge)[@T](f)(s1)xs2)))))))","legal function application obligation:(forall f:(@T * @T -\u003e bool), s1:seq of (@T), s2:seq of (@T) \u0026 ((not (exists mk_([], y):(seq of (@T) * seq of (@T)) \u0026 (mk_([], y) \u003d mk_(s1, s2)))) \u003d\u003e ((not (exists mk_(x, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(x, []) \u003d mk_(s1, s2)))) \u003d\u003e (exists mk_([x1] ^ xs1, [x2] ^ xs2):(seq of (@T) * seq of (@T)) \u0026 ((mk_(([x1] ^ xs1), ([x2] ^ xs2)) \u003d mk_(s1, s2)) \u003d\u003e let mk_([x1] ^ xs1, [x2] ^ xs2) \u003d mk_(s1, s2) in ((not f(x1, x2)) \u003d\u003e pre_((FSequence`Merge)[@T](f)s1)))))))","cases exhaustive obligation:(forall f:(@T * @T -\u003e bool), s1:seq of (@T), s2:seq of (@T) \u0026 (((exists mk_([], y):(seq of (@T) * seq of (@T)) \u0026 (mk_(s1, s2) \u003d mk_([], y))) or (exists mk_(x, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(s1, s2) \u003d mk_(x, [])))) or (exists mk_([x1] ^ xs1, [x2] ^ xs2):(seq of (@T) * seq of (@T)) \u0026 (mk_(s1, s2) \u003d mk_(([x1] ^ xs1), ([x2] ^ xs2))))))","legal function application obligation:(forall i:nat1, e:@T, s:seq of (@T) \u0026 ((not (exists mk_(1, s1):(nat1 * seq of (@T)) \u0026 (mk_(1, s1) \u003d mk_(i, s)))) \u003d\u003e ((not (exists mk_(-, []):(nat1 * seq of (@T)) \u0026 (mk_(any1, []) \u003d mk_(i, s)))) \u003d\u003e (exists mk_(i1, [x] ^ xs):(nat1 * seq of (@T)) \u0026 ((mk_(i1, ([x] ^ xs)) \u003d mk_(i, s)) \u003d\u003e let mk_(i1, [x] ^ xs) \u003d mk_(i, s) in pre_((InsertAt)[@T]((i1 - 1))(e)xs))))))","legal function application obligation:(forall i:nat1, e:@T, s:seq of (@T) \u0026 ((not (exists mk_(1, s1):(nat1 * seq of (@T)) \u0026 (mk_(1, s1) \u003d mk_(i, s)))) \u003d\u003e ((not (exists mk_(-, []):(nat1 * seq of (@T)) \u0026 (mk_(any1, []) \u003d mk_(i, s)))) \u003d\u003e (exists mk_(i1, [x] ^ xs):(nat1 * seq of (@T)) \u0026 ((mk_(i1, ([x] ^ xs)) \u003d mk_(i, s)) \u003d\u003e let mk_(i1, [x] ^ xs) \u003d mk_(i, s) in pre_((InsertAt)[@T]((i1 - 1))e))))))","type compatibility obligation:(forall i:nat1, e:@T, s:seq of (@T) \u0026 ((not (exists mk_(1, s1):(nat1 * seq of (@T)) \u0026 (mk_(1, s1) \u003d mk_(i, s)))) \u003d\u003e ((not (exists mk_(-, []):(nat1 * seq of (@T)) \u0026 (mk_(any1, []) \u003d mk_(i, s)))) \u003d\u003e (exists mk_(i1, [x] ^ xs):(nat1 * seq of (@T)) \u0026 ((mk_(i1, ([x] ^ xs)) \u003d mk_(i, s)) \u003d\u003e let mk_(i1, [x] ^ xs) \u003d mk_(i, s) in ((i1 - 1) \u003e 0))))))","cases exhaustive obligation:(forall i:nat1, e:@T, s:seq of (@T) \u0026 (((exists mk_(1, s1):(nat1 * seq of (@T)) \u0026 (mk_(i, s) \u003d mk_(1, s1))) or (exists mk_(-, []):(nat1 * seq of (@T)) \u0026 (mk_(i, s) \u003d mk_(any1, [])))) or (exists mk_(i1, [x] ^ xs):(nat1 * seq of (@T)) \u0026 (mk_(i, s) \u003d mk_(i1, ([x] ^ xs))))))","legal function application obligation:(forall i:nat1, s:seq of (@T) \u0026 ((not (exists mk_(1, [-] ^ xs):(nat1 * seq of (@T)) \u0026 (mk_(1, ([any1] ^ xs)) \u003d mk_(i, s)))) \u003d\u003e (exists mk_(i1, [x] ^ xs):(nat1 * seq of (@T)) \u0026 ((mk_(i1, ([x] ^ xs)) \u003d mk_(i, s)) \u003d\u003e let mk_(i1, [x] ^ xs) \u003d mk_(i, s) in pre_((RemoveAt)[@T]((i1 - 1))xs)))))","type compatibility obligation:(forall i:nat1, s:seq of (@T) \u0026 ((not (exists mk_(1, [-] ^ xs):(nat1 * seq of (@T)) \u0026 (mk_(1, ([any1] ^ xs)) \u003d mk_(i, s)))) \u003d\u003e (exists mk_(i1, [x] ^ xs):(nat1 * seq of (@T)) \u0026 ((mk_(i1, ([x] ^ xs)) \u003d mk_(i, s)) \u003d\u003e let mk_(i1, [x] ^ xs) \u003d mk_(i, s) in ((i1 - 1) \u003e 0)))))","cases exhaustive obligation:(forall i:nat1, s:seq of (@T) \u0026 (((exists mk_(1, [-] ^ xs):(nat1 * seq of (@T)) \u0026 (mk_(i, s) \u003d mk_(1, ([any1] ^ xs)))) or (exists mk_(i1, [x] ^ xs):(nat1 * seq of (@T)) \u0026 (mk_(i, s) \u003d mk_(i1, ([x] ^ xs))))) or (exists mk_(-, []):(nat1 * seq of (@T)) \u0026 (mk_(i, s) \u003d mk_(any1, [])))))","function establishes postcondition obligation:(forall s:seq of (@T) \u0026 post_RemoveDup(s, (cases s :\n[x] ^ xs -\u003e ([x] ^ (RemoveDup)[@T]((Filter)[@T]((lambda [e:@T] \u0026 (e \u003c\u003e x)))(xs))),\n[] -\u003e []\n end)))","legal function application obligation:(forall s:seq of (@T) \u0026 (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in pre_((Filter)[@T]((lambda [e:@T] \u0026 (e \u003c\u003e x)))xs))))","cases exhaustive obligation:(forall s:seq of (@T) \u0026 ((exists [x] ^ xs:seq of (@T) \u0026 (s \u003d ([x] ^ xs))) or (s \u003d [])))","legal function application obligation:(forall e:@T, s:seq of (@T) \u0026 (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in ((not (e \u003d x)) \u003d\u003e pre_((RemoveMember)[@T](e)xs)))))","cases exhaustive obligation:(forall e:@T, s:seq of (@T) \u0026 ((exists [x] ^ xs:seq of (@T) \u0026 (s \u003d ([x] ^ xs))) or (s \u003d [])))","legal function application obligation:(forall es:seq of (@T), s:seq of (@T) \u0026 ((not ([] \u003d es)) \u003d\u003e (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d es) \u003d\u003e let [x] ^ xs \u003d es in pre_((RemoveMembers)[@T](xs)(RemoveMember)[@T](x)(s))))))","legal function application obligation:(forall es:seq of (@T), s:seq of (@T) \u0026 ((not ([] \u003d es)) \u003d\u003e (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d es) \u003d\u003e let [x] ^ xs \u003d es in pre_((RemoveMember)[@T](x)s)))))","cases exhaustive obligation:(forall es:seq of (@T), s:seq of (@T) \u0026 ((es \u003d []) or (exists [x] ^ xs:seq of (@T) \u0026 (es \u003d ([x] ^ xs)))))","legal function application obligation:(forall i:nat1, e:@T, s:seq of (@T) \u0026 ((not (exists mk_(-, []):(nat1 * seq of (@T)) \u0026 (mk_(any1, []) \u003d mk_(i, s)))) \u003d\u003e ((not (exists mk_(1, [-] ^ xs):(nat1 * seq of (@T)) \u0026 (mk_(1, ([any1] ^ xs)) \u003d mk_(i, s)))) \u003d\u003e (exists mk_(i1, [x] ^ xs):(nat1 * seq of (@T)) \u0026 ((mk_(i1, ([x] ^ xs)) \u003d mk_(i, s)) \u003d\u003e let mk_(i1, [x] ^ xs) \u003d mk_(i, s) in pre_((UpdateAt)[@T]((i1 - 1))(e)xs))))))","legal function application obligation:(forall i:nat1, e:@T, s:seq of (@T) \u0026 ((not (exists mk_(-, []):(nat1 * seq of (@T)) \u0026 (mk_(any1, []) \u003d mk_(i, s)))) \u003d\u003e ((not (exists mk_(1, [-] ^ xs):(nat1 * seq of (@T)) \u0026 (mk_(1, ([any1] ^ xs)) \u003d mk_(i, s)))) \u003d\u003e (exists mk_(i1, [x] ^ xs):(nat1 * seq of (@T)) \u0026 ((mk_(i1, ([x] ^ xs)) \u003d mk_(i, s)) \u003d\u003e let mk_(i1, [x] ^ xs) \u003d mk_(i, s) in pre_((UpdateAt)[@T]((i1 - 1))e))))))","type compatibility obligation:(forall i:nat1, e:@T, s:seq of (@T) \u0026 ((not (exists mk_(-, []):(nat1 * seq of (@T)) \u0026 (mk_(any1, []) \u003d mk_(i, s)))) \u003d\u003e ((not (exists mk_(1, [-] ^ xs):(nat1 * seq of (@T)) \u0026 (mk_(1, ([any1] ^ xs)) \u003d mk_(i, s)))) \u003d\u003e (exists mk_(i1, [x] ^ xs):(nat1 * seq of (@T)) \u0026 ((mk_(i1, ([x] ^ xs)) \u003d mk_(i, s)) \u003d\u003e let mk_(i1, [x] ^ xs) \u003d mk_(i, s) in ((i1 - 1) \u003e 0))))))","cases exhaustive obligation:(forall i:nat1, e:@T, s:seq of (@T) \u0026 (((exists mk_(-, []):(nat1 * seq of (@T)) \u0026 (mk_(i, s) \u003d mk_(any1, []))) or (exists mk_(1, [-] ^ xs):(nat1 * seq of (@T)) \u0026 (mk_(i, s) \u003d mk_(1, ([any1] ^ xs))))) or (exists mk_(i1, [x] ^ xs):(nat1 * seq of (@T)) \u0026 (mk_(i, s) \u003d mk_(i1, ([x] ^ xs))))))","legal function application obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in pre_(fx))))","legal function application obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in (f(x) \u003d\u003e pre_((TakeWhile)[@T](f)xs)))))","cases exhaustive obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 ((exists [x] ^ xs:seq of (@T) \u0026 (s \u003d ([x] ^ xs))) or (s \u003d [])))","legal function application obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in pre_(fx))))","legal function application obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in (f(x) \u003d\u003e pre_((DropWhile)[@T](f)xs)))))","cases exhaustive obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 ((exists [x] ^ xs:seq of (@T) \u0026 (s \u003d ([x] ^ xs))) or (s \u003d [])))","legal function application obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in pre_(fx))))","legal function application obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in (f(x) \u003d\u003e pre_((Span)[@T](f)xs)))))","cases exhaustive obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 ((exists [x] ^ xs:seq of (@T) \u0026 (s \u003d ([x] ^ xs))) or (s \u003d [])))","legal sequence application obligation:(forall s:seq of (@T) \u0026 ((len s) in set (inds s)))","legal function application obligation:(forall f:(@T1 -\u003e @T2), s:seq of (@T1) \u0026 (forall i in set (inds s) \u0026 pre_(fs(i))))","legal sequence application obligation:(forall f:(@T1 -\u003e @T2), s:seq of (@T1) \u0026 (forall i in set (inds s) \u0026 (i in set (inds s))))","legal sequence application obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 (forall i in set (inds s) \u0026 (f(s(i)) \u003d\u003e (i in set (inds s)))))","legal function application obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 (forall i in set (inds s) \u0026 pre_(fs(i))))","legal sequence application obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 (forall i in set (inds s) \u0026 (i in set (inds s))))","legal function application obligation:(forall f:(@T1 -\u003e (@T2 -\u003e @T1)), args:@T1, s:seq of (@T2) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [x] ^ xs:seq of (@T2) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in pre_((Foldl)[@T1, @T2](f)(f(args)(x))xs)))))","legal function application obligation:(forall f:(@T1 -\u003e (@T2 -\u003e @T1)), args:@T1, s:seq of (@T2) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [x] ^ xs:seq of (@T2) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in pre_((Foldl)[@T1, @T2](f)f(args)(x))))))","legal function application obligation:(forall f:(@T1 -\u003e (@T2 -\u003e @T1)), args:@T1, s:seq of (@T2) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [x] ^ xs:seq of (@T2) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in pre_(f(args)x)))))","legal function application obligation:(forall f:(@T1 -\u003e (@T2 -\u003e @T1)), args:@T1, s:seq of (@T2) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [x] ^ xs:seq of (@T2) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in pre_(fargs)))))","cases exhaustive obligation:(forall f:(@T1 -\u003e (@T2 -\u003e @T1)), args:@T1, s:seq of (@T2) \u0026 ((s \u003d []) or (exists [x] ^ xs:seq of (@T2) \u0026 (s \u003d ([x] ^ xs)))))","legal function application obligation:(forall f:(@T1 -\u003e (@T2 -\u003e @T2)), args:@T2, s:seq of (@T1) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [x] ^ xs:seq of (@T1) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in pre_(f(x)(Foldr)[@T1, @T2](f)(args)(xs))))))","legal function application obligation:(forall f:(@T1 -\u003e (@T2 -\u003e @T2)), args:@T2, s:seq of (@T1) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [x] ^ xs:seq of (@T1) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in pre_(fx)))))","legal function application obligation:(forall f:(@T1 -\u003e (@T2 -\u003e @T2)), args:@T2, s:seq of (@T1) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [x] ^ xs:seq of (@T1) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in pre_((Foldr)[@T1, @T2](f)(args)xs)))))","legal function application obligation:(forall f:(@T1 -\u003e (@T2 -\u003e @T2)), args:@T2, s:seq of (@T1) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [x] ^ xs:seq of (@T1) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in pre_((Foldr)[@T1, @T2](f)args)))))","cases exhaustive obligation:(forall f:(@T1 -\u003e (@T2 -\u003e @T2)), args:@T2, s:seq of (@T1) \u0026 ((s \u003d []) or (exists [x] ^ xs:seq of (@T1) \u0026 (s \u003d ([x] ^ xs)))))","legal function application obligation:(forall e:@T, s:seq of (@T) \u0026 (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in ((not (e \u003d x)) \u003d\u003e pre_((IsMember)[@T](e)xs)))))","cases exhaustive obligation:(forall e:@T, s:seq of (@T) \u0026 ((exists [x] ^ xs:seq of (@T) \u0026 (s \u003d ([x] ^ xs))) or (s \u003d [])))","legal function application obligation:(forall es:seq of (@T), s:seq of (@T) \u0026 (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d es) \u003d\u003e let [x] ^ xs \u003d es in pre_((IsMember)[@T](x)s))))","legal function application obligation:(forall es:seq of (@T), s:seq of (@T) \u0026 (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d es) \u003d\u003e let [x] ^ xs \u003d es in ((not (IsMember)[@T](x)(s)) \u003d\u003e pre_((IsAnyMember)[@T](xs)s)))))","cases exhaustive obligation:(forall es:seq of (@T), s:seq of (@T) \u0026 ((exists [x] ^ xs:seq of (@T) \u0026 (es \u003d ([x] ^ xs))) or (es \u003d [])))","function establishes postcondition obligation:(forall s:seq of (@T) \u0026 post_IsDup(s, (not ((card (elems s)) \u003d (len s)))))","legal sequence application obligation:(forall s:seq of (@T) \u0026 let RESULT \u003d (not ((card (elems s)) \u003d (len s))) in ((not (s \u003d [])) \u003d\u003e (forall i, j in set (inds s) \u0026 (i in set (inds s)))))","legal sequence application obligation:(forall s:seq of (@T) \u0026 let RESULT \u003d (not ((card (elems s)) \u003d (len s))) in ((not (s \u003d [])) \u003d\u003e (forall i, j in set (inds s) \u0026 (j in set (inds s)))))","legal function application obligation:(forall e:@T, s:seq of (@T) \u0026 let i:nat \u003d 0 in pre_((IndexAux)[@T](e)(s)i))","legal function application obligation:(forall e:@T, s:seq of (@T) \u0026 let i:nat \u003d 0 in pre_((IndexAux)[@T](e)s))","legal function application obligation:(forall e:@T, s:seq of (@T), i:int \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in ((not (x \u003d e)) \u003d\u003e pre_((IndexAux)[@T](e)(xs)(i + 1)))))))","legal function application obligation:(forall e:@T, s:seq of (@T), i:int \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in ((not (x \u003d e)) \u003d\u003e pre_((IndexAux)[@T](e)xs))))))","cases exhaustive obligation:(forall e:@T, s:seq of (@T), i:int \u0026 ((s \u003d []) or (exists [x] ^ xs:seq of (@T) \u0026 (s \u003d ([x] ^ xs)))))","legal sequence application obligation:(forall e:@T, s:seq of (@T) \u0026 (forall i in set (inds s) \u0026 (i in set (inds s))))","function establishes postcondition obligation:(forall s:seq of ([@T]) \u0026 post_Compact(s, [s(i) | i in set (inds s) \u0026 (s(i) \u003c\u003e nil)]))","legal sequence application obligation:(forall s:seq of ([@T]) \u0026 let RESULT \u003d [s(i) | i in set (inds s) \u0026 (s(i) \u003c\u003e nil)] in (forall i in set (inds RESULT) \u0026 (i in set (inds RESULT))))","legal sequence application obligation:(forall s:seq of ([@T]) \u0026 (forall i in set (inds s) \u0026 ((s(i) \u003c\u003e nil) \u003d\u003e (i in set (inds s)))))","legal sequence application obligation:(forall s:seq of ([@T]) \u0026 (forall i in set (inds s) \u0026 (i in set (inds s))))","legal sequence application obligation:(forall s:seq of (@T) \u0026 (forall i in set (inds s) \u0026 ((((len s) + 1) - i) in set (inds s))))","function establishes postcondition obligation:(forall s:seq of (@T) \u0026 post_Permutations(s, (cases s :\n[] -\u003e {s},\n[-] -\u003e {s}\nothers (dunion {{([s(i)] ^ j) | j in set (Permutations)[@T]((RemoveAt)[@T](i)(s))} | i in set (inds s)})\n end)))","legal sequence application obligation:(forall s:seq of (@T) \u0026 ((not ([] \u003d s)) \u003d\u003e ((not (exists [-]:seq of (@T) \u0026 ([any1] \u003d s))) \u003d\u003e (forall i in set (inds s) \u0026 (forall j in set (Permutations)[@T]((RemoveAt)[@T](i)(s)) \u0026 (i in set (inds s)))))))","legal function application obligation:(forall s:seq of (@T) \u0026 ((not ([] \u003d s)) \u003d\u003e ((not (exists [-]:seq of (@T) \u0026 ([any1] \u003d s))) \u003d\u003e (forall i in set (inds s) \u0026 pre_((RemoveAt)[@T](i)s)))))","legal function application obligation:(forall s:seq of (@T), t:seq of (@T) \u0026 pre_((RemoveMembers)[@T](s)t))","legal function application obligation:(forall s:seq of (@T), t:seq of (@T) \u0026 (((RemoveMembers)[@T](s)(t) \u003d []) \u003d\u003e pre_((RemoveMembers)[@T](t)s)))","cases exhaustive obligation:(forall s:seq of ((@T1 * @T2)) \u0026 ((s \u003d []) or (exists [mk_(x, y)] ^ xs:seq of ((@T1 * @T2)) \u0026 (s \u003d ([mk_(x, y)] ^ xs)))))","legal function application obligation:(forall s1:seq of (@T1), s2:seq of (@T2) \u0026 pre_((Zip2)[@T1, @T2](s1)s2))","legal function application obligation:(forall s1:seq of (@T1), s2:seq of (@T2) \u0026 (exists mk_([x1] ^ xs1, [x2] ^ xs2):(seq of (@T1) * seq of (@T2)) \u0026 ((mk_(([x1] ^ xs1), ([x2] ^ xs2)) \u003d mk_(s1, s2)) \u003d\u003e let mk_([x1] ^ xs1, [x2] ^ xs2) \u003d mk_(s1, s2) in pre_((Zip2)[@T1, @T2](xs1)xs2))))","cases exhaustive obligation:(forall s1:seq of (@T1), s2:seq of (@T2) \u0026 ((exists mk_([x1] ^ xs1, [x2] ^ xs2):(seq of (@T1) * seq of (@T2)) \u0026 (mk_(s1, s2) \u003d mk_(([x1] ^ xs1), ([x2] ^ xs2)))) or (exists mk_(-, -):(seq of (@T1) * seq of (@T2)) \u0026 (mk_(s1, s2) \u003d mk_(any1, any1)))))","type compatibility obligation:is_(tests(), seq of (TestCase))","legal function application obligation:(forall t:TestCase \u0026 ((t.TestACase)() \u003d\u003e pre_((new TestLogger().Succeeded)t)))","legal function application obligation:(forall t:TestCase \u0026 ((not (t.TestACase)()) \u003d\u003e pre_((new TestLogger().Failed)t)))","legal sequence application obligation:(forall i in set (inds TestcaseSeq) \u0026 (i in set (inds TestcaseSeq)))","legal sequence application obligation:(forall i in set (inds aResult) \u0026 (i in set (inds aResult)))","legal function application obligation:pre_((new TestLogger().succeededInAllTestcases)Message)","legal function application obligation:pre_((new TestLogger().notSucceededInAllTestcases)Message)","legal function application obligation:pre_((calendar().getNumberOfDayOfTheWeek)self)","legal function application obligation:pre_((calendar().getNameOfDayOfTheWeek)self)","legal function application obligation:(forall date:Date, nameOfDayOfTheWeek:NameOfDayOfTheWeek \u0026 pre_((calendar().getNumberOfTheDayOfWeek)self, date, nameOfDayOfTheWeek))","legal function application obligation:(forall date:Date \u0026 pre_((calendar().getTheNumberOfDayOff)self, date))","legal function application obligation:(forall date:Date \u0026 pre_((calendar().getTheNumberOfDayOffExceptStartDate)self, date))","legal function application obligation:pre_((calendar().Year)self)","legal function application obligation:pre_((calendar().Month)self)","legal function application obligation:pre_((calendar().day)self)","legal function application obligation:pre_((calendar().getFutureWeekday)self)","legal function application obligation:pre_((calendar().getPastWeekday)self)","legal function application obligation:(forall addNumOfDays:int \u0026 pre_((calendar().addWeekday)self, addNumOfDays))","legal function application obligation:(forall subtractNumOfDays:int \u0026 pre_((calendar().subtractWeekday)self, subtractNumOfDays))","legal function application obligation:pre_((calendar().isSunday)self)","legal function application obligation:pre_((calendar().isSaturday)self)","legal function application obligation:pre_((calendar().isWeekday)self)","legal function application obligation:pre_((calendar().isNotDayOff)self)","legal function application obligation:pre_((calendar().isDayOff)self)","legal function application obligation:pre_((calendar().isSundayOrDayoff)self)","legal function application obligation:pre_((calendar().daysFromNewYear)self)","legal function application obligation:pre_((self.Year))","legal function application obligation:pre_((self.Month))","legal function application obligation:pre_((self.day))","legal function application obligation:(forall i:int \u0026 let str:(int -\u003e seq1 of (char)) \u003d Integer`asString in ((i \u003e\u003d 10) \u003d\u003e pre_(stri)))","legal function application obligation:(forall i:int \u0026 let str:(int -\u003e seq1 of (char)) \u003d Integer`asString in ((not (i \u003e\u003d 10)) \u003d\u003e pre_(stri)))","legal function application obligation:pre_((self.Year))","legal function application obligation:pre_((self.Month))","legal function application obligation:pre_((self.day))","legal function application obligation:pre_(asStringy)","legal function application obligation:pre_((self.Year))","legal function application obligation:pre_((self.Month))","legal function application obligation:pre_((self.day))","legal function application obligation:pre_(asStringy)","legal function application obligation:pre_((new FHashtableT().run))","legal sequence application obligation:(forall i in set (inds ResultOfTest) \u0026 (i in set (inds ResultOfTest)))","legal function application obligation:pre_((new TestLogger().succeededInAllTestcases)Message)","legal function application obligation:pre_((new TestLogger().notSucceededInAllTestcases)Message)","legal function application obligation:pre_((c.isDigit)\u00270\u0027)","legal function application obligation:(((c.isDigit)(\u00270\u0027) \u003d true) \u003d\u003e pre_((c.isDigit)\u00271\u0027))","legal function application obligation:(((c.isDigit)(\u00270\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00271\u0027) \u003d true) \u003d\u003e pre_((c.isDigit)\u00272\u0027)))","legal function application obligation:(((c.isDigit)(\u00270\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00271\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00272\u0027) \u003d true) \u003d\u003e pre_((c.isDigit)\u00273\u0027))))","legal function application obligation:(((c.isDigit)(\u00270\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00271\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00272\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00273\u0027) \u003d true) \u003d\u003e pre_((c.isDigit)\u00274\u0027)))))","legal function application obligation:(((c.isDigit)(\u00270\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00271\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00272\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00273\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00274\u0027) \u003d true) \u003d\u003e pre_((c.isDigit)\u00275\u0027))))))","legal function application obligation:(((c.isDigit)(\u00270\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00271\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00272\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00273\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00274\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00275\u0027) \u003d true) \u003d\u003e pre_((c.isDigit)\u00276\u0027)))))))","legal function application obligation:(((c.isDigit)(\u00270\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00271\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00272\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00273\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00274\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00275\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00276\u0027) \u003d true) \u003d\u003e pre_((c.isDigit)\u00277\u0027))))))))","legal function application obligation:(((c.isDigit)(\u00270\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00271\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00272\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00273\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00274\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00275\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00276\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00277\u0027) \u003d true) \u003d\u003e pre_((c.isDigit)\u00278\u0027)))))))))","legal function application obligation:(((c.isDigit)(\u00270\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00271\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00272\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00273\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00274\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00275\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00276\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00277\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00278\u0027) \u003d true) \u003d\u003e pre_((c.isDigit)\u00279\u0027))))))))))","legal function application obligation:(((c.isDigit)(\u00270\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00271\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00272\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00273\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00274\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00275\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00276\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00277\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00278\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00279\u0027) \u003d true) \u003d\u003e pre_((c.isDigit)\u0027a\u0027)))))))))))","legal function application obligation:(((c.isDigit)(\u00270\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00271\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00272\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00273\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00274\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00275\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00276\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00277\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00278\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00279\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u0027a\u0027) \u003d false) \u003d\u003e pre_((c.asDigit)\u00270\u0027))))))))))))","legal function application obligation:(((c.isDigit)(\u00270\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00271\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00272\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00273\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00274\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00275\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00276\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00277\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00278\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00279\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u0027a\u0027) \u003d false) \u003d\u003e (((c.asDigit)(\u00270\u0027) \u003d 0) \u003d\u003e pre_((c.asDigit)\u00271\u0027)))))))))))))","legal function application obligation:(((c.isDigit)(\u00270\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00271\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00272\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00273\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00274\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00275\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00276\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00277\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00278\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00279\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u0027a\u0027) \u003d false) \u003d\u003e (((c.asDigit)(\u00270\u0027) \u003d 0) \u003d\u003e (((c.asDigit)(\u00271\u0027) \u003d 1) \u003d\u003e pre_((c.asDigit)\u00272\u0027))))))))))))))","legal function application obligation:(((c.isDigit)(\u00270\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00271\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00272\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00273\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00274\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00275\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00276\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00277\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00278\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00279\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u0027a\u0027) \u003d false) \u003d\u003e (((c.asDigit)(\u00270\u0027) \u003d 0) \u003d\u003e (((c.asDigit)(\u00271\u0027) \u003d 1) \u003d\u003e (((c.asDigit)(\u00272\u0027) \u003d 2) \u003d\u003e pre_((c.asDigit)\u00273\u0027)))))))))))))))","legal function application obligation:(((c.isDigit)(\u00270\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00271\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00272\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00273\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00274\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00275\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00276\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00277\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00278\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00279\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u0027a\u0027) \u003d false) \u003d\u003e (((c.asDigit)(\u00270\u0027) \u003d 0) \u003d\u003e (((c.asDigit)(\u00271\u0027) \u003d 1) \u003d\u003e (((c.asDigit)(\u00272\u0027) \u003d 2) \u003d\u003e (((c.asDigit)(\u00273\u0027) \u003d 3) \u003d\u003e pre_((c.asDigit)\u00274\u0027))))))))))))))))","legal function application obligation:(((c.isDigit)(\u00270\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00271\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00272\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00273\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00274\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00275\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00276\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00277\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00278\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00279\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u0027a\u0027) \u003d false) \u003d\u003e (((c.asDigit)(\u00270\u0027) \u003d 0) \u003d\u003e (((c.asDigit)(\u00271\u0027) \u003d 1) \u003d\u003e (((c.asDigit)(\u00272\u0027) \u003d 2) \u003d\u003e (((c.asDigit)(\u00273\u0027) \u003d 3) \u003d\u003e (((c.asDigit)(\u00274\u0027) \u003d 4) \u003d\u003e pre_((c.asDigit)\u00275\u0027)))))))))))))))))","legal function application obligation:(((c.isDigit)(\u00270\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00271\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00272\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00273\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00274\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00275\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00276\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00277\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00278\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00279\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u0027a\u0027) \u003d false) \u003d\u003e (((c.asDigit)(\u00270\u0027) \u003d 0) \u003d\u003e (((c.asDigit)(\u00271\u0027) \u003d 1) \u003d\u003e (((c.asDigit)(\u00272\u0027) \u003d 2) \u003d\u003e (((c.asDigit)(\u00273\u0027) \u003d 3) \u003d\u003e (((c.asDigit)(\u00274\u0027) \u003d 4) \u003d\u003e (((c.asDigit)(\u00275\u0027) \u003d 5) \u003d\u003e pre_((c.asDigit)\u00276\u0027))))))))))))))))))","legal function application obligation:(((c.isDigit)(\u00270\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00271\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00272\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00273\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00274\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00275\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00276\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00277\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00278\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00279\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u0027a\u0027) \u003d false) \u003d\u003e (((c.asDigit)(\u00270\u0027) \u003d 0) \u003d\u003e (((c.asDigit)(\u00271\u0027) \u003d 1) \u003d\u003e (((c.asDigit)(\u00272\u0027) \u003d 2) \u003d\u003e (((c.asDigit)(\u00273\u0027) \u003d 3) \u003d\u003e (((c.asDigit)(\u00274\u0027) \u003d 4) \u003d\u003e (((c.asDigit)(\u00275\u0027) \u003d 5) \u003d\u003e (((c.asDigit)(\u00276\u0027) \u003d 6) \u003d\u003e pre_((c.asDigit)\u00277\u0027)))))))))))))))))))","legal function application obligation:(((c.isDigit)(\u00270\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00271\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00272\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00273\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00274\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00275\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00276\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00277\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00278\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00279\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u0027a\u0027) \u003d false) \u003d\u003e (((c.asDigit)(\u00270\u0027) \u003d 0) \u003d\u003e (((c.asDigit)(\u00271\u0027) \u003d 1) \u003d\u003e (((c.asDigit)(\u00272\u0027) \u003d 2) \u003d\u003e (((c.asDigit)(\u00273\u0027) \u003d 3) \u003d\u003e (((c.asDigit)(\u00274\u0027) \u003d 4) \u003d\u003e (((c.asDigit)(\u00275\u0027) \u003d 5) \u003d\u003e (((c.asDigit)(\u00276\u0027) \u003d 6) \u003d\u003e (((c.asDigit)(\u00277\u0027) \u003d 7) \u003d\u003e pre_((c.asDigit)\u00278\u0027))))))))))))))))))))","legal function application obligation:(((c.isDigit)(\u00270\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00271\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00272\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00273\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00274\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00275\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00276\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00277\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00278\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00279\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u0027a\u0027) \u003d false) \u003d\u003e (((c.asDigit)(\u00270\u0027) \u003d 0) \u003d\u003e (((c.asDigit)(\u00271\u0027) \u003d 1) \u003d\u003e (((c.asDigit)(\u00272\u0027) \u003d 2) \u003d\u003e (((c.asDigit)(\u00273\u0027) \u003d 3) \u003d\u003e (((c.asDigit)(\u00274\u0027) \u003d 4) \u003d\u003e (((c.asDigit)(\u00275\u0027) \u003d 5) \u003d\u003e (((c.asDigit)(\u00276\u0027) \u003d 6) \u003d\u003e (((c.asDigit)(\u00277\u0027) \u003d 7) \u003d\u003e (((c.asDigit)(\u00278\u0027) \u003d 8) \u003d\u003e pre_((c.asDigit)\u00279\u0027)))))))))))))))))))))","legal function application obligation:(((c.isDigit)(\u00270\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00271\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00272\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00273\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00274\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00275\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00276\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00277\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00278\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u00279\u0027) \u003d true) \u003d\u003e (((c.isDigit)(\u0027a\u0027) \u003d false) \u003d\u003e (((c.asDigit)(\u00270\u0027) \u003d 0) \u003d\u003e (((c.asDigit)(\u00271\u0027) \u003d 1) \u003d\u003e (((c.asDigit)(\u00272\u0027) \u003d 2) \u003d\u003e (((c.asDigit)(\u00273\u0027) \u003d 3) \u003d\u003e (((c.asDigit)(\u00274\u0027) \u003d 4) \u003d\u003e (((c.asDigit)(\u00275\u0027) \u003d 5) \u003d\u003e (((c.asDigit)(\u00276\u0027) \u003d 6) \u003d\u003e (((c.asDigit)(\u00277\u0027) \u003d 7) \u003d\u003e (((c.asDigit)(\u00278\u0027) \u003d 8) \u003d\u003e (((c.asDigit)(\u00279\u0027) \u003d 9) \u003d\u003e pre_((c.asDigit)\u0027a\u0027))))))))))))))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((c.asDictOrder)\u00270\u0027)","legal function application obligation:(((c.asDictOrder)(\u00270\u0027) \u003d 1) \u003d\u003e pre_((c.asDictOrder)\u00279\u0027))","legal function application obligation:(((c.asDictOrder)(\u00270\u0027) \u003d 1) \u003d\u003e (((c.asDictOrder)(\u00279\u0027) \u003d 10) \u003d\u003e pre_((c.asDictOrder)\u0027a\u0027)))","legal function application obligation:(((c.asDictOrder)(\u00270\u0027) \u003d 1) \u003d\u003e (((c.asDictOrder)(\u00279\u0027) \u003d 10) \u003d\u003e (((c.asDictOrder)(\u0027a\u0027) \u003d 11) \u003d\u003e pre_((c.asDictOrder)\u0027A\u0027))))","legal function application obligation:(((c.asDictOrder)(\u00270\u0027) \u003d 1) \u003d\u003e (((c.asDictOrder)(\u00279\u0027) \u003d 10) \u003d\u003e (((c.asDictOrder)(\u0027a\u0027) \u003d 11) \u003d\u003e (((c.asDictOrder)(\u0027A\u0027) \u003d 12) \u003d\u003e pre_((c.asDictOrder)\u0027z\u0027)))))","legal function application obligation:(((c.asDictOrder)(\u00270\u0027) \u003d 1) \u003d\u003e (((c.asDictOrder)(\u00279\u0027) \u003d 10) \u003d\u003e (((c.asDictOrder)(\u0027a\u0027) \u003d 11) \u003d\u003e (((c.asDictOrder)(\u0027A\u0027) \u003d 12) \u003d\u003e (((c.asDictOrder)(\u0027z\u0027) \u003d 61) \u003d\u003e pre_((c.asDictOrder)\u0027Z\u0027))))))","legal function application obligation:(((c.asDictOrder)(\u00270\u0027) \u003d 1) \u003d\u003e (((c.asDictOrder)(\u00279\u0027) \u003d 10) \u003d\u003e (((c.asDictOrder)(\u0027a\u0027) \u003d 11) \u003d\u003e (((c.asDictOrder)(\u0027A\u0027) \u003d 12) \u003d\u003e (((c.asDictOrder)(\u0027z\u0027) \u003d 61) \u003d\u003e (((c.asDictOrder)(\u0027Z\u0027) \u003d 62) \u003d\u003e pre_((c.asDictOrder)\u0027\n\u0027)))))))","legal function application obligation:(((c.asDictOrder)(\u00270\u0027) \u003d 1) \u003d\u003e (((c.asDictOrder)(\u00279\u0027) \u003d 10) \u003d\u003e (((c.asDictOrder)(\u0027a\u0027) \u003d 11) \u003d\u003e (((c.asDictOrder)(\u0027A\u0027) \u003d 12) \u003d\u003e (((c.asDictOrder)(\u0027z\u0027) \u003d 61) \u003d\u003e (((c.asDictOrder)(\u0027Z\u0027) \u003d 62) \u003d\u003e (((c.asDictOrder)(\u0027\n\u0027) \u003d 999999) \u003d\u003e pre_((c.asDictOrder)\u0027\t\u0027))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((s.LT)\"123\", \"123\")","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e pre_(LT(\"123\")\"123\"))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e pre_(LT\"123\"))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e pre_((s.GT)\"123\", \"123\")))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e pre_(GT(\"123\")\"123\"))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e pre_(GT\"123\"))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e pre_((s.LT)\"\", \"\")))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e pre_((s.GT)\"\", \"\"))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e pre_((s.LT)\"\", \"123\")))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e pre_((s.GT)\"\", \"123\"))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e pre_((s.LT)\"123\", \"\")))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e pre_((s.GT)\"123\", \"\"))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e pre_((s.LT)\"123\", \"1234\")))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e pre_((s.GT)\"123\", \"1234\"))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e pre_((s.LT)\"1234\", \"123\")))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e pre_((s.GT)\"1234\", \"123\"))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e pre_((s.LT)\"123\", \"223\")))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e pre_((s.GT)\"123\", \"223\"))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e pre_((s.LE)\"123\", \"123\")))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e pre_(LE(\"123\")\"123\"))))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e pre_(LE\"123\"))))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e (LE(\"123\")(\"123\") \u003d\u003e pre_((s.GE)\"123\", \"123\")))))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e (LE(\"123\")(\"123\") \u003d\u003e ((s.GE)(\"123\", \"123\") \u003d\u003e pre_((s.LE)\"123\", \"1234\"))))))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e (LE(\"123\")(\"123\") \u003d\u003e ((s.GE)(\"123\", \"123\") \u003d\u003e ((s.LE)(\"123\", \"1234\") \u003d\u003e pre_(LE(\"123\")\"1234\")))))))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e (LE(\"123\")(\"123\") \u003d\u003e ((s.GE)(\"123\", \"123\") \u003d\u003e ((s.LE)(\"123\", \"1234\") \u003d\u003e pre_(LE\"123\")))))))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e (LE(\"123\")(\"123\") \u003d\u003e ((s.GE)(\"123\", \"123\") \u003d\u003e ((s.LE)(\"123\", \"1234\") \u003d\u003e (LE(\"123\")(\"1234\") \u003d\u003e pre_((s.GE)\"123\", \"1234\"))))))))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e (LE(\"123\")(\"123\") \u003d\u003e ((s.GE)(\"123\", \"123\") \u003d\u003e ((s.LE)(\"123\", \"1234\") \u003d\u003e (LE(\"123\")(\"1234\") \u003d\u003e (((s.GE)(\"123\", \"1234\") \u003d false) \u003d\u003e pre_(GE(\"123\")\"1234\")))))))))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e (LE(\"123\")(\"123\") \u003d\u003e ((s.GE)(\"123\", \"123\") \u003d\u003e ((s.LE)(\"123\", \"1234\") \u003d\u003e (LE(\"123\")(\"1234\") \u003d\u003e (((s.GE)(\"123\", \"1234\") \u003d false) \u003d\u003e pre_(GE\"123\")))))))))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e (LE(\"123\")(\"123\") \u003d\u003e ((s.GE)(\"123\", \"123\") \u003d\u003e ((s.LE)(\"123\", \"1234\") \u003d\u003e (LE(\"123\")(\"1234\") \u003d\u003e (((s.GE)(\"123\", \"1234\") \u003d false) \u003d\u003e ((GE(\"123\")(\"1234\") \u003d false) \u003d\u003e pre_((s.LE)\"1234\", \"123\"))))))))))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e (LE(\"123\")(\"123\") \u003d\u003e ((s.GE)(\"123\", \"123\") \u003d\u003e ((s.LE)(\"123\", \"1234\") \u003d\u003e (LE(\"123\")(\"1234\") \u003d\u003e (((s.GE)(\"123\", \"1234\") \u003d false) \u003d\u003e ((GE(\"123\")(\"1234\") \u003d false) \u003d\u003e (((s.LE)(\"1234\", \"123\") \u003d false) \u003d\u003e pre_(LE(\"1234\")\"123\")))))))))))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e (LE(\"123\")(\"123\") \u003d\u003e ((s.GE)(\"123\", \"123\") \u003d\u003e ((s.LE)(\"123\", \"1234\") \u003d\u003e (LE(\"123\")(\"1234\") \u003d\u003e (((s.GE)(\"123\", \"1234\") \u003d false) \u003d\u003e ((GE(\"123\")(\"1234\") \u003d false) \u003d\u003e (((s.LE)(\"1234\", \"123\") \u003d false) \u003d\u003e pre_(LE\"1234\")))))))))))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e (LE(\"123\")(\"123\") \u003d\u003e ((s.GE)(\"123\", \"123\") \u003d\u003e ((s.LE)(\"123\", \"1234\") \u003d\u003e (LE(\"123\")(\"1234\") \u003d\u003e (((s.GE)(\"123\", \"1234\") \u003d false) \u003d\u003e ((GE(\"123\")(\"1234\") \u003d false) \u003d\u003e (((s.LE)(\"1234\", \"123\") \u003d false) \u003d\u003e ((not LE(\"1234\")(\"123\")) \u003d\u003e pre_((s.GE)\"1234\", \"123\"))))))))))))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e (LE(\"123\")(\"123\") \u003d\u003e ((s.GE)(\"123\", \"123\") \u003d\u003e ((s.LE)(\"123\", \"1234\") \u003d\u003e (LE(\"123\")(\"1234\") \u003d\u003e (((s.GE)(\"123\", \"1234\") \u003d false) \u003d\u003e ((GE(\"123\")(\"1234\") \u003d false) \u003d\u003e (((s.LE)(\"1234\", \"123\") \u003d false) \u003d\u003e ((not LE(\"1234\")(\"123\")) \u003d\u003e ((s.GE)(\"1234\", \"123\") \u003d\u003e pre_((s.LE)\"\", \"\")))))))))))))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e (LE(\"123\")(\"123\") \u003d\u003e ((s.GE)(\"123\", \"123\") \u003d\u003e ((s.LE)(\"123\", \"1234\") \u003d\u003e (LE(\"123\")(\"1234\") \u003d\u003e (((s.GE)(\"123\", \"1234\") \u003d false) \u003d\u003e ((GE(\"123\")(\"1234\") \u003d false) \u003d\u003e (((s.LE)(\"1234\", \"123\") \u003d false) \u003d\u003e ((not LE(\"1234\")(\"123\")) \u003d\u003e ((s.GE)(\"1234\", \"123\") \u003d\u003e ((s.LE)(\"\", \"\") \u003d\u003e pre_(LE(\"\")\"\"))))))))))))))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e (LE(\"123\")(\"123\") \u003d\u003e ((s.GE)(\"123\", \"123\") \u003d\u003e ((s.LE)(\"123\", \"1234\") \u003d\u003e (LE(\"123\")(\"1234\") \u003d\u003e (((s.GE)(\"123\", \"1234\") \u003d false) \u003d\u003e ((GE(\"123\")(\"1234\") \u003d false) \u003d\u003e (((s.LE)(\"1234\", \"123\") \u003d false) \u003d\u003e ((not LE(\"1234\")(\"123\")) \u003d\u003e ((s.GE)(\"1234\", \"123\") \u003d\u003e ((s.LE)(\"\", \"\") \u003d\u003e pre_(LE\"\"))))))))))))))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e (LE(\"123\")(\"123\") \u003d\u003e ((s.GE)(\"123\", \"123\") \u003d\u003e ((s.LE)(\"123\", \"1234\") \u003d\u003e (LE(\"123\")(\"1234\") \u003d\u003e (((s.GE)(\"123\", \"1234\") \u003d false) \u003d\u003e ((GE(\"123\")(\"1234\") \u003d false) \u003d\u003e (((s.LE)(\"1234\", \"123\") \u003d false) \u003d\u003e ((not LE(\"1234\")(\"123\")) \u003d\u003e ((s.GE)(\"1234\", \"123\") \u003d\u003e ((s.LE)(\"\", \"\") \u003d\u003e (LE(\"\")(\"\") \u003d\u003e pre_((Sequence`fmap)[seq of (char), bool](LT(\"123\"))[\"123\", \"1234\", \"\", \"223\"])))))))))))))))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e (LE(\"123\")(\"123\") \u003d\u003e ((s.GE)(\"123\", \"123\") \u003d\u003e ((s.LE)(\"123\", \"1234\") \u003d\u003e (LE(\"123\")(\"1234\") \u003d\u003e (((s.GE)(\"123\", \"1234\") \u003d false) \u003d\u003e ((GE(\"123\")(\"1234\") \u003d false) \u003d\u003e (((s.LE)(\"1234\", \"123\") \u003d false) \u003d\u003e ((not LE(\"1234\")(\"123\")) \u003d\u003e ((s.GE)(\"1234\", \"123\") \u003d\u003e ((s.LE)(\"\", \"\") \u003d\u003e (LE(\"\")(\"\") \u003d\u003e pre_(LT\"123\")))))))))))))))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e (LE(\"123\")(\"123\") \u003d\u003e ((s.GE)(\"123\", \"123\") \u003d\u003e ((s.LE)(\"123\", \"1234\") \u003d\u003e (LE(\"123\")(\"1234\") \u003d\u003e (((s.GE)(\"123\", \"1234\") \u003d false) \u003d\u003e ((GE(\"123\")(\"1234\") \u003d false) \u003d\u003e (((s.LE)(\"1234\", \"123\") \u003d false) \u003d\u003e ((not LE(\"1234\")(\"123\")) \u003d\u003e ((s.GE)(\"1234\", \"123\") \u003d\u003e ((s.LE)(\"\", \"\") \u003d\u003e (LE(\"\")(\"\") \u003d\u003e (((Sequence`fmap)[seq of (char), bool](LT(\"123\"))([\"123\", \"1234\", \"\", \"223\"]) \u003d [false, true, false, true]) \u003d\u003e pre_((Sequence`fmap)[seq of (char), bool](LE(\"123\"))[\"1234\", \"\"]))))))))))))))))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e (LE(\"123\")(\"123\") \u003d\u003e ((s.GE)(\"123\", \"123\") \u003d\u003e ((s.LE)(\"123\", \"1234\") \u003d\u003e (LE(\"123\")(\"1234\") \u003d\u003e (((s.GE)(\"123\", \"1234\") \u003d false) \u003d\u003e ((GE(\"123\")(\"1234\") \u003d false) \u003d\u003e (((s.LE)(\"1234\", \"123\") \u003d false) \u003d\u003e ((not LE(\"1234\")(\"123\")) \u003d\u003e ((s.GE)(\"1234\", \"123\") \u003d\u003e ((s.LE)(\"\", \"\") \u003d\u003e (LE(\"\")(\"\") \u003d\u003e (((Sequence`fmap)[seq of (char), bool](LT(\"123\"))([\"123\", \"1234\", \"\", \"223\"]) \u003d [false, true, false, true]) \u003d\u003e pre_(LE\"123\"))))))))))))))))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e (LE(\"123\")(\"123\") \u003d\u003e ((s.GE)(\"123\", \"123\") \u003d\u003e ((s.LE)(\"123\", \"1234\") \u003d\u003e (LE(\"123\")(\"1234\") \u003d\u003e (((s.GE)(\"123\", \"1234\") \u003d false) \u003d\u003e ((GE(\"123\")(\"1234\") \u003d false) \u003d\u003e (((s.LE)(\"1234\", \"123\") \u003d false) \u003d\u003e ((not LE(\"1234\")(\"123\")) \u003d\u003e ((s.GE)(\"1234\", \"123\") \u003d\u003e ((s.LE)(\"\", \"\") \u003d\u003e (LE(\"\")(\"\") \u003d\u003e (((Sequence`fmap)[seq of (char), bool](LT(\"123\"))([\"123\", \"1234\", \"\", \"223\"]) \u003d [false, true, false, true]) \u003d\u003e (((Sequence`fmap)[seq of (char), bool](LE(\"123\"))([\"1234\", \"\"]) \u003d [true, false]) \u003d\u003e pre_((Sequence`fmap)[seq of (char), bool](GT(\"123\"))[\"123\", \"\", \"23\"])))))))))))))))))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e (LE(\"123\")(\"123\") \u003d\u003e ((s.GE)(\"123\", \"123\") \u003d\u003e ((s.LE)(\"123\", \"1234\") \u003d\u003e (LE(\"123\")(\"1234\") \u003d\u003e (((s.GE)(\"123\", \"1234\") \u003d false) \u003d\u003e ((GE(\"123\")(\"1234\") \u003d false) \u003d\u003e (((s.LE)(\"1234\", \"123\") \u003d false) \u003d\u003e ((not LE(\"1234\")(\"123\")) \u003d\u003e ((s.GE)(\"1234\", \"123\") \u003d\u003e ((s.LE)(\"\", \"\") \u003d\u003e (LE(\"\")(\"\") \u003d\u003e (((Sequence`fmap)[seq of (char), bool](LT(\"123\"))([\"123\", \"1234\", \"\", \"223\"]) \u003d [false, true, false, true]) \u003d\u003e (((Sequence`fmap)[seq of (char), bool](LE(\"123\"))([\"1234\", \"\"]) \u003d [true, false]) \u003d\u003e pre_(GT\"123\")))))))))))))))))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e (LE(\"123\")(\"123\") \u003d\u003e ((s.GE)(\"123\", \"123\") \u003d\u003e ((s.LE)(\"123\", \"1234\") \u003d\u003e (LE(\"123\")(\"1234\") \u003d\u003e (((s.GE)(\"123\", \"1234\") \u003d false) \u003d\u003e ((GE(\"123\")(\"1234\") \u003d false) \u003d\u003e (((s.LE)(\"1234\", \"123\") \u003d false) \u003d\u003e ((not LE(\"1234\")(\"123\")) \u003d\u003e ((s.GE)(\"1234\", \"123\") \u003d\u003e ((s.LE)(\"\", \"\") \u003d\u003e (LE(\"\")(\"\") \u003d\u003e (((Sequence`fmap)[seq of (char), bool](LT(\"123\"))([\"123\", \"1234\", \"\", \"223\"]) \u003d [false, true, false, true]) \u003d\u003e (((Sequence`fmap)[seq of (char), bool](LE(\"123\"))([\"1234\", \"\"]) \u003d [true, false]) \u003d\u003e (((Sequence`fmap)[seq of (char), bool](GT(\"123\"))([\"123\", \"\", \"23\"]) \u003d [false, true, false]) \u003d\u003e pre_((Sequence`fmap)[seq of (char), bool](GE(\"123\"))[\"1234\", \"\"]))))))))))))))))))))))))))))))))","legal function application obligation:(((s.LT)(\"123\", \"123\") \u003d false) \u003d\u003e ((LT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.GT)(\"123\", \"123\") \u003d false) \u003d\u003e ((GT(\"123\")(\"123\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"\") \u003d false) \u003d\u003e (((s.GT)(\"\", \"\") \u003d false) \u003d\u003e (((s.LT)(\"\", \"123\") \u003d true) \u003d\u003e (((s.GT)(\"\", \"123\") \u003d false) \u003d\u003e (((s.LT)(\"123\", \"\") \u003d false) \u003d\u003e ((s.GT)(\"123\", \"\") \u003d\u003e ((s.LT)(\"123\", \"1234\") \u003d\u003e (((s.GT)(\"123\", \"1234\") \u003d false) \u003d\u003e (((s.LT)(\"1234\", \"123\") \u003d false) \u003d\u003e ((s.GT)(\"1234\", \"123\") \u003d\u003e ((s.LT)(\"123\", \"223\") \u003d\u003e (((s.GT)(\"123\", \"223\") \u003d false) \u003d\u003e ((s.LE)(\"123\", \"123\") \u003d\u003e (LE(\"123\")(\"123\") \u003d\u003e ((s.GE)(\"123\", \"123\") \u003d\u003e ((s.LE)(\"123\", \"1234\") \u003d\u003e (LE(\"123\")(\"1234\") \u003d\u003e (((s.GE)(\"123\", \"1234\") \u003d false) \u003d\u003e ((GE(\"123\")(\"1234\") \u003d false) \u003d\u003e (((s.LE)(\"1234\", \"123\") \u003d false) \u003d\u003e ((not LE(\"1234\")(\"123\")) \u003d\u003e ((s.GE)(\"1234\", \"123\") \u003d\u003e ((s.LE)(\"\", \"\") \u003d\u003e (LE(\"\")(\"\") \u003d\u003e (((Sequence`fmap)[seq of (char), bool](LT(\"123\"))([\"123\", \"1234\", \"\", \"223\"]) \u003d [false, true, false, true]) \u003d\u003e (((Sequence`fmap)[seq of (char), bool](LE(\"123\"))([\"1234\", \"\"]) \u003d [true, false]) \u003d\u003e (((Sequence`fmap)[seq of (char), bool](GT(\"123\"))([\"123\", \"\", \"23\"]) \u003d [false, true, false]) \u003d\u003e pre_(GE\"123\"))))))))))))))))))))))))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:((s1234 \u003d \"1234\") \u003d\u003e pre_((s.isSpaces)\"\"))","legal function application obligation:((s1234 \u003d \"1234\") \u003d\u003e (((s.isSpaces)(\"\") \u003d true) \u003d\u003e pre_((s.isSpaces)\" \")))","legal function application obligation:((s1234 \u003d \"1234\") \u003d\u003e (((s.isSpaces)(\"\") \u003d true) \u003d\u003e (((s.isSpaces)(\" \") \u003d true) \u003d\u003e pre_((s.isSpaces)\" \t \"))))","legal function application obligation:((s1234 \u003d \"1234\") \u003d\u003e (((s.isSpaces)(\"\") \u003d true) \u003d\u003e (((s.isSpaces)(\" \") \u003d true) \u003d\u003e (((s.isSpaces)(\" \t \") \u003d true) \u003d\u003e pre_((s.isSpaces)[])))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(LT\u0027a\u0027, \u0027a\u0027)","legal function application obligation:((LT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e pre_(Character`LT2(\u0027a\u0027)\u0027a\u0027))","legal function application obligation:((LT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`LT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e pre_(GT\u0027a\u0027, \u0027a\u0027)))","legal function application obligation:((LT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`LT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e ((GT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e pre_(Character`GT2(\u0027a\u0027)\u0027a\u0027))))","legal function application obligation:((LT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`LT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e ((GT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`GT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e pre_(LT\u00271\u0027, \u00272\u0027)))))","legal function application obligation:((LT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`LT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e ((GT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`GT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e (LT(\u00271\u0027, \u00272\u0027) \u003d\u003e pre_(Character`LT2(\u00271\u0027)\u00272\u0027))))))","legal function application obligation:((LT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`LT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e ((GT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`GT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e (LT(\u00271\u0027, \u00272\u0027) \u003d\u003e (Character`LT2(\u00271\u0027)(\u00272\u0027) \u003d\u003e pre_(GT\u00271\u0027, \u00270\u0027)))))))","legal function application obligation:((LT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`LT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e ((GT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`GT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e (LT(\u00271\u0027, \u00272\u0027) \u003d\u003e (Character`LT2(\u00271\u0027)(\u00272\u0027) \u003d\u003e (GT(\u00271\u0027, \u00270\u0027) \u003d\u003e pre_(Character`GT2(\u00271\u0027)\u00270\u0027))))))))","legal function application obligation:((LT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`LT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e ((GT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`GT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e (LT(\u00271\u0027, \u00272\u0027) \u003d\u003e (Character`LT2(\u00271\u0027)(\u00272\u0027) \u003d\u003e (GT(\u00271\u0027, \u00270\u0027) \u003d\u003e (Character`GT2(\u00271\u0027)(\u00270\u0027) \u003d\u003e pre_(LT\u00279\u0027, \u0027a\u0027)))))))))","legal function application obligation:((LT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`LT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e ((GT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`GT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e (LT(\u00271\u0027, \u00272\u0027) \u003d\u003e (Character`LT2(\u00271\u0027)(\u00272\u0027) \u003d\u003e (GT(\u00271\u0027, \u00270\u0027) \u003d\u003e (Character`GT2(\u00271\u0027)(\u00270\u0027) \u003d\u003e (LT(\u00279\u0027, \u0027a\u0027) \u003d\u003e pre_(Character`LT2(\u00279\u0027)\u0027a\u0027))))))))))","legal function application obligation:((LT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`LT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e ((GT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`GT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e (LT(\u00271\u0027, \u00272\u0027) \u003d\u003e (Character`LT2(\u00271\u0027)(\u00272\u0027) \u003d\u003e (GT(\u00271\u0027, \u00270\u0027) \u003d\u003e (Character`GT2(\u00271\u0027)(\u00270\u0027) \u003d\u003e (LT(\u00279\u0027, \u0027a\u0027) \u003d\u003e (Character`LT2(\u00279\u0027)(\u0027a\u0027) \u003d\u003e pre_(GT\u0027\n\u0027, \u00270\u0027)))))))))))","legal function application obligation:((LT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`LT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e ((GT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`GT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e (LT(\u00271\u0027, \u00272\u0027) \u003d\u003e (Character`LT2(\u00271\u0027)(\u00272\u0027) \u003d\u003e (GT(\u00271\u0027, \u00270\u0027) \u003d\u003e (Character`GT2(\u00271\u0027)(\u00270\u0027) \u003d\u003e (LT(\u00279\u0027, \u0027a\u0027) \u003d\u003e (Character`LT2(\u00279\u0027)(\u0027a\u0027) \u003d\u003e (GT(\u0027\n\u0027, \u00270\u0027) \u003d\u003e pre_(Character`GT2(\u0027\n\u0027)\u00270\u0027))))))))))))","legal function application obligation:((LT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`LT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e ((GT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`GT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e (LT(\u00271\u0027, \u00272\u0027) \u003d\u003e (Character`LT2(\u00271\u0027)(\u00272\u0027) \u003d\u003e (GT(\u00271\u0027, \u00270\u0027) \u003d\u003e (Character`GT2(\u00271\u0027)(\u00270\u0027) \u003d\u003e (LT(\u00279\u0027, \u0027a\u0027) \u003d\u003e (Character`LT2(\u00279\u0027)(\u0027a\u0027) \u003d\u003e (GT(\u0027\n\u0027, \u00270\u0027) \u003d\u003e (Character`GT2(\u0027\n\u0027)(\u00270\u0027) \u003d\u003e pre_(LE\u0027a\u0027, \u00270\u0027)))))))))))))","legal function application obligation:((LT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`LT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e ((GT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`GT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e (LT(\u00271\u0027, \u00272\u0027) \u003d\u003e (Character`LT2(\u00271\u0027)(\u00272\u0027) \u003d\u003e (GT(\u00271\u0027, \u00270\u0027) \u003d\u003e (Character`GT2(\u00271\u0027)(\u00270\u0027) \u003d\u003e (LT(\u00279\u0027, \u0027a\u0027) \u003d\u003e (Character`LT2(\u00279\u0027)(\u0027a\u0027) \u003d\u003e (GT(\u0027\n\u0027, \u00270\u0027) \u003d\u003e (Character`GT2(\u0027\n\u0027)(\u00270\u0027) \u003d\u003e ((LE(\u0027a\u0027, \u00270\u0027) \u003d false) \u003d\u003e pre_(Character`LE2(\u0027a\u0027)\u00270\u0027))))))))))))))","legal function application obligation:((LT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`LT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e ((GT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`GT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e (LT(\u00271\u0027, \u00272\u0027) \u003d\u003e (Character`LT2(\u00271\u0027)(\u00272\u0027) \u003d\u003e (GT(\u00271\u0027, \u00270\u0027) \u003d\u003e (Character`GT2(\u00271\u0027)(\u00270\u0027) \u003d\u003e (LT(\u00279\u0027, \u0027a\u0027) \u003d\u003e (Character`LT2(\u00279\u0027)(\u0027a\u0027) \u003d\u003e (GT(\u0027\n\u0027, \u00270\u0027) \u003d\u003e (Character`GT2(\u0027\n\u0027)(\u00270\u0027) \u003d\u003e ((LE(\u0027a\u0027, \u00270\u0027) \u003d false) \u003d\u003e ((Character`LE2(\u0027a\u0027)(\u00270\u0027) \u003d false) \u003d\u003e pre_(GE\u0027a\u0027, \u00270\u0027)))))))))))))))","legal function application obligation:((LT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`LT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e ((GT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`GT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e (LT(\u00271\u0027, \u00272\u0027) \u003d\u003e (Character`LT2(\u00271\u0027)(\u00272\u0027) \u003d\u003e (GT(\u00271\u0027, \u00270\u0027) \u003d\u003e (Character`GT2(\u00271\u0027)(\u00270\u0027) \u003d\u003e (LT(\u00279\u0027, \u0027a\u0027) \u003d\u003e (Character`LT2(\u00279\u0027)(\u0027a\u0027) \u003d\u003e (GT(\u0027\n\u0027, \u00270\u0027) \u003d\u003e (Character`GT2(\u0027\n\u0027)(\u00270\u0027) \u003d\u003e ((LE(\u0027a\u0027, \u00270\u0027) \u003d false) \u003d\u003e ((Character`LE2(\u0027a\u0027)(\u00270\u0027) \u003d false) \u003d\u003e (GE(\u0027a\u0027, \u00270\u0027) \u003d\u003e pre_(Character`GE2(\u0027a\u0027)\u00270\u0027))))))))))))))))","legal function application obligation:((LT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`LT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e ((GT(\u0027a\u0027, \u0027a\u0027) \u003d false) \u003d\u003e ((Character`GT2(\u0027a\u0027)(\u0027a\u0027) \u003d false) \u003d\u003e (LT(\u00271\u0027, \u00272\u0027) \u003d\u003e (Character`LT2(\u00271\u0027)(\u00272\u0027) \u003d\u003e (GT(\u00271\u0027, \u00270\u0027) \u003d\u003e (Character`GT2(\u00271\u0027)(\u00270\u0027) \u003d\u003e (LT(\u00279\u0027, \u0027a\u0027) \u003d\u003e (Character`LT2(\u00279\u0027)(\u0027a\u0027) \u003d\u003e (GT(\u0027\n\u0027, \u00270\u0027) \u003d\u003e (Character`GT2(\u0027\n\u0027)(\u00270\u0027) \u003d\u003e ((LE(\u0027a\u0027, \u00270\u0027) \u003d false) \u003d\u003e ((Character`LE2(\u0027a\u0027)(\u00270\u0027) \u003d false) \u003d\u003e (GE(\u0027a\u0027, \u00270\u0027) \u003d\u003e (Character`GE2(\u0027a\u0027)(\u00270\u0027) \u003d\u003e pre_((Sequence`fmap)[char, bool](Character`LT2(\u00275\u0027))\"456\")))))))))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((s.subStr)\"Shin Sahara\", 6, 6)","legal function application obligation:(((s.subStr)(\"Shin Sahara\", 6, 6) \u003d \"Sahara\") \u003d\u003e pre_((s.subStr)\"Shin Sahara\", 6, 8))","legal function application obligation:(((s.subStr)(\"Shin Sahara\", 6, 6) \u003d \"Sahara\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 6, 8) \u003d \"Sahara\") \u003d\u003e pre_((s.subStr)\"Shin Sahara\", 6, 3)))","legal function application obligation:(((s.subStr)(\"Shin Sahara\", 6, 6) \u003d \"Sahara\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 6, 8) \u003d \"Sahara\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 6, 3) \u003d \"Sah\") \u003d\u003e pre_((s.subStr)\"Shin Sahara\", 1, 0))))","legal function application obligation:(((s.subStr)(\"Shin Sahara\", 6, 6) \u003d \"Sahara\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 6, 8) \u003d \"Sahara\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 6, 3) \u003d \"Sah\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 1, 0) \u003d \"\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 3, \u0027*\u0027) \u003d \"sah\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 6, \u0027*\u0027) \u003d \"sahara\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 10, \u0027*\u0027) \u003d \"sahara****\") \u003d\u003e (((s.subStrFill)(\"sahara\", 3, 4, \u0027*\u0027) \u003d \"hara\") \u003d\u003e (((s.subStrFill)(\"sahara\", 3, 10, \u0027*\u0027) \u003d \"hara******\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 0, \u0027*\u0027) \u003d \"\") \u003d\u003e (((s.subStrFill)(\"\", 1, 6, \u0027*\u0027) \u003d \"******\") \u003d\u003e pre_(String`SubStr(6)(6)\"Shin Sahara\"))))))))))))","legal function application obligation:(((s.subStr)(\"Shin Sahara\", 6, 6) \u003d \"Sahara\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 6, 8) \u003d \"Sahara\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 6, 3) \u003d \"Sah\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 1, 0) \u003d \"\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 3, \u0027*\u0027) \u003d \"sah\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 6, \u0027*\u0027) \u003d \"sahara\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 10, \u0027*\u0027) \u003d \"sahara****\") \u003d\u003e (((s.subStrFill)(\"sahara\", 3, 4, \u0027*\u0027) \u003d \"hara\") \u003d\u003e (((s.subStrFill)(\"sahara\", 3, 10, \u0027*\u0027) \u003d \"hara******\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 0, \u0027*\u0027) \u003d \"\") \u003d\u003e (((s.subStrFill)(\"\", 1, 6, \u0027*\u0027) \u003d \"******\") \u003d\u003e pre_(String`SubStr(6)6))))))))))))","legal function application obligation:(((s.subStr)(\"Shin Sahara\", 6, 6) \u003d \"Sahara\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 6, 8) \u003d \"Sahara\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 6, 3) \u003d \"Sah\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 1, 0) \u003d \"\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 3, \u0027*\u0027) \u003d \"sah\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 6, \u0027*\u0027) \u003d \"sahara\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 10, \u0027*\u0027) \u003d \"sahara****\") \u003d\u003e (((s.subStrFill)(\"sahara\", 3, 4, \u0027*\u0027) \u003d \"hara\") \u003d\u003e (((s.subStrFill)(\"sahara\", 3, 10, \u0027*\u0027) \u003d \"hara******\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 0, \u0027*\u0027) \u003d \"\") \u003d\u003e (((s.subStrFill)(\"\", 1, 6, \u0027*\u0027) \u003d \"******\") \u003d\u003e ((String`SubStr(6)(6)(\"Shin Sahara\") \u003d \"Sahara\") \u003d\u003e pre_(substr(6)(8)\"Shin Sahara\")))))))))))))","legal function application obligation:(((s.subStr)(\"Shin Sahara\", 6, 6) \u003d \"Sahara\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 6, 8) \u003d \"Sahara\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 6, 3) \u003d \"Sah\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 1, 0) \u003d \"\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 3, \u0027*\u0027) \u003d \"sah\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 6, \u0027*\u0027) \u003d \"sahara\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 10, \u0027*\u0027) \u003d \"sahara****\") \u003d\u003e (((s.subStrFill)(\"sahara\", 3, 4, \u0027*\u0027) \u003d \"hara\") \u003d\u003e (((s.subStrFill)(\"sahara\", 3, 10, \u0027*\u0027) \u003d \"hara******\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 0, \u0027*\u0027) \u003d \"\") \u003d\u003e (((s.subStrFill)(\"\", 1, 6, \u0027*\u0027) \u003d \"******\") \u003d\u003e ((String`SubStr(6)(6)(\"Shin Sahara\") \u003d \"Sahara\") \u003d\u003e pre_(substr(6)8)))))))))))))","legal function application obligation:(((s.subStr)(\"Shin Sahara\", 6, 6) \u003d \"Sahara\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 6, 8) \u003d \"Sahara\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 6, 3) \u003d \"Sah\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 1, 0) \u003d \"\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 3, \u0027*\u0027) \u003d \"sah\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 6, \u0027*\u0027) \u003d \"sahara\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 10, \u0027*\u0027) \u003d \"sahara****\") \u003d\u003e (((s.subStrFill)(\"sahara\", 3, 4, \u0027*\u0027) \u003d \"hara\") \u003d\u003e (((s.subStrFill)(\"sahara\", 3, 10, \u0027*\u0027) \u003d \"hara******\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 0, \u0027*\u0027) \u003d \"\") \u003d\u003e (((s.subStrFill)(\"\", 1, 6, \u0027*\u0027) \u003d \"******\") \u003d\u003e ((String`SubStr(6)(6)(\"Shin Sahara\") \u003d \"Sahara\") \u003d\u003e pre_(substr6)))))))))))))","legal function application obligation:(((s.subStr)(\"Shin Sahara\", 6, 6) \u003d \"Sahara\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 6, 8) \u003d \"Sahara\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 6, 3) \u003d \"Sah\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 1, 0) \u003d \"\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 3, \u0027*\u0027) \u003d \"sah\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 6, \u0027*\u0027) \u003d \"sahara\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 10, \u0027*\u0027) \u003d \"sahara****\") \u003d\u003e (((s.subStrFill)(\"sahara\", 3, 4, \u0027*\u0027) \u003d \"hara\") \u003d\u003e (((s.subStrFill)(\"sahara\", 3, 10, \u0027*\u0027) \u003d \"hara******\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 0, \u0027*\u0027) \u003d \"\") \u003d\u003e (((s.subStrFill)(\"\", 1, 6, \u0027*\u0027) \u003d \"******\") \u003d\u003e ((String`SubStr(6)(6)(\"Shin Sahara\") \u003d \"Sahara\") \u003d\u003e ((substr(6)(8)(\"Shin Sahara\") \u003d \"Sahara\") \u003d\u003e pre_((Sequence`fmap)[seq of (char), seq of (char)](substr(6)(8))[\"1234567890\", \"12345671\"]))))))))))))))","legal function application obligation:(((s.subStr)(\"Shin Sahara\", 6, 6) \u003d \"Sahara\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 6, 8) \u003d \"Sahara\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 6, 3) \u003d \"Sah\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 1, 0) \u003d \"\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 3, \u0027*\u0027) \u003d \"sah\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 6, \u0027*\u0027) \u003d \"sahara\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 10, \u0027*\u0027) \u003d \"sahara****\") \u003d\u003e (((s.subStrFill)(\"sahara\", 3, 4, \u0027*\u0027) \u003d \"hara\") \u003d\u003e (((s.subStrFill)(\"sahara\", 3, 10, \u0027*\u0027) \u003d \"hara******\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 0, \u0027*\u0027) \u003d \"\") \u003d\u003e (((s.subStrFill)(\"\", 1, 6, \u0027*\u0027) \u003d \"******\") \u003d\u003e ((String`SubStr(6)(6)(\"Shin Sahara\") \u003d \"Sahara\") \u003d\u003e ((substr(6)(8)(\"Shin Sahara\") \u003d \"Sahara\") \u003d\u003e pre_(substr(6)8))))))))))))))","legal function application obligation:(((s.subStr)(\"Shin Sahara\", 6, 6) \u003d \"Sahara\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 6, 8) \u003d \"Sahara\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 6, 3) \u003d \"Sah\") \u003d\u003e (((s.subStr)(\"Shin Sahara\", 1, 0) \u003d \"\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 3, \u0027*\u0027) \u003d \"sah\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 6, \u0027*\u0027) \u003d \"sahara\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 10, \u0027*\u0027) \u003d \"sahara****\") \u003d\u003e (((s.subStrFill)(\"sahara\", 3, 4, \u0027*\u0027) \u003d \"hara\") \u003d\u003e (((s.subStrFill)(\"sahara\", 3, 10, \u0027*\u0027) \u003d \"hara******\") \u003d\u003e (((s.subStrFill)(\"sahara\", 1, 0, \u0027*\u0027) \u003d \"\") \u003d\u003e (((s.subStrFill)(\"\", 1, 6, \u0027*\u0027) \u003d \"******\") \u003d\u003e ((String`SubStr(6)(6)(\"Shin Sahara\") \u003d \"Sahara\") \u003d\u003e ((substr(6)(8)(\"Shin Sahara\") \u003d \"Sahara\") \u003d\u003e pre_(substr6))))))))))))))","type compatibility obligation:is_(RESULT, ())","type compatibility obligation:is_(RESULT, ())","legal function application obligation:((String`index(\"1234567890\", \u00271\u0027) \u003d 1) \u003d\u003e ((String`index(\"1234567890\", \u00270\u0027) \u003d 10) \u003d\u003e ((String`index(\"1234567890\", \u0027a\u0027) \u003d 0) \u003d\u003e ((String`indexAll(\"1234567890\", \u00271\u0027) \u003d {1}) \u003d\u003e ((String`indexAll(\"1234567890\", \u00270\u0027) \u003d {10}) \u003d\u003e ((String`indexAll(\"1234567890\", \u0027a\u0027) \u003d {}) \u003d\u003e ((String`indexAll(\"1231567190\", \u00271\u0027) \u003d {1, 4, 8}) \u003d\u003e ((String`indexAll(\"1231567191\", \u00271\u0027) \u003d {1, 4, 8, 10}) \u003d\u003e pre_(String`Index(\u00271\u0027)\"1234567890\")))))))))","legal function application obligation:((String`index(\"1234567890\", \u00271\u0027) \u003d 1) \u003d\u003e ((String`index(\"1234567890\", \u00270\u0027) \u003d 10) \u003d\u003e ((String`index(\"1234567890\", \u0027a\u0027) \u003d 0) \u003d\u003e ((String`indexAll(\"1234567890\", \u00271\u0027) \u003d {1}) \u003d\u003e ((String`indexAll(\"1234567890\", \u00270\u0027) \u003d {10}) \u003d\u003e ((String`indexAll(\"1234567890\", \u0027a\u0027) \u003d {}) \u003d\u003e ((String`indexAll(\"1231567190\", \u00271\u0027) \u003d {1, 4, 8}) \u003d\u003e ((String`indexAll(\"1231567191\", \u00271\u0027) \u003d {1, 4, 8, 10}) \u003d\u003e ((String`Index(\u00271\u0027)(\"1234567890\") \u003d 1) \u003d\u003e pre_(String`Index(\u00270\u0027)\"1234567890\"))))))))))","legal function application obligation:((String`index(\"1234567890\", \u00271\u0027) \u003d 1) \u003d\u003e ((String`index(\"1234567890\", \u00270\u0027) \u003d 10) \u003d\u003e ((String`index(\"1234567890\", \u0027a\u0027) \u003d 0) \u003d\u003e ((String`indexAll(\"1234567890\", \u00271\u0027) \u003d {1}) \u003d\u003e ((String`indexAll(\"1234567890\", \u00270\u0027) \u003d {10}) \u003d\u003e ((String`indexAll(\"1234567890\", \u0027a\u0027) \u003d {}) \u003d\u003e ((String`indexAll(\"1231567190\", \u00271\u0027) \u003d {1, 4, 8}) \u003d\u003e ((String`indexAll(\"1231567191\", \u00271\u0027) \u003d {1, 4, 8, 10}) \u003d\u003e ((String`Index(\u00271\u0027)(\"1234567890\") \u003d 1) \u003d\u003e ((String`Index(\u00270\u0027)(\"1234567890\") \u003d 10) \u003d\u003e pre_(String`Index(\u0027a\u0027)\"1234567890\")))))))))))","legal function application obligation:((String`index(\"1234567890\", \u00271\u0027) \u003d 1) \u003d\u003e ((String`index(\"1234567890\", \u00270\u0027) \u003d 10) \u003d\u003e ((String`index(\"1234567890\", \u0027a\u0027) \u003d 0) \u003d\u003e ((String`indexAll(\"1234567890\", \u00271\u0027) \u003d {1}) \u003d\u003e ((String`indexAll(\"1234567890\", \u00270\u0027) \u003d {10}) \u003d\u003e ((String`indexAll(\"1234567890\", \u0027a\u0027) \u003d {}) \u003d\u003e ((String`indexAll(\"1231567190\", \u00271\u0027) \u003d {1, 4, 8}) \u003d\u003e ((String`indexAll(\"1231567191\", \u00271\u0027) \u003d {1, 4, 8, 10}) \u003d\u003e ((String`Index(\u00271\u0027)(\"1234567890\") \u003d 1) \u003d\u003e ((String`Index(\u00270\u0027)(\"1234567890\") \u003d 10) \u003d\u003e ((String`Index(\u0027a\u0027)(\"1234567890\") \u003d 0) \u003d\u003e pre_(String`IndexAll2(\u00271\u0027)\"1234567890\"))))))))))))","legal function application obligation:((String`index(\"1234567890\", \u00271\u0027) \u003d 1) \u003d\u003e ((String`index(\"1234567890\", \u00270\u0027) \u003d 10) \u003d\u003e ((String`index(\"1234567890\", \u0027a\u0027) \u003d 0) \u003d\u003e ((String`indexAll(\"1234567890\", \u00271\u0027) \u003d {1}) \u003d\u003e ((String`indexAll(\"1234567890\", \u00270\u0027) \u003d {10}) \u003d\u003e ((String`indexAll(\"1234567890\", \u0027a\u0027) \u003d {}) \u003d\u003e ((String`indexAll(\"1231567190\", \u00271\u0027) \u003d {1, 4, 8}) \u003d\u003e ((String`indexAll(\"1231567191\", \u00271\u0027) \u003d {1, 4, 8, 10}) \u003d\u003e ((String`Index(\u00271\u0027)(\"1234567890\") \u003d 1) \u003d\u003e ((String`Index(\u00270\u0027)(\"1234567890\") \u003d 10) \u003d\u003e ((String`Index(\u0027a\u0027)(\"1234567890\") \u003d 0) \u003d\u003e ((String`IndexAll2(\u00271\u0027)(\"1234567890\") \u003d {1}) \u003d\u003e pre_(String`IndexAll2(\u00270\u0027)\"1234567890\")))))))))))))","legal function application obligation:((String`index(\"1234567890\", \u00271\u0027) \u003d 1) \u003d\u003e ((String`index(\"1234567890\", \u00270\u0027) \u003d 10) \u003d\u003e ((String`index(\"1234567890\", \u0027a\u0027) \u003d 0) \u003d\u003e ((String`indexAll(\"1234567890\", \u00271\u0027) \u003d {1}) \u003d\u003e ((String`indexAll(\"1234567890\", \u00270\u0027) \u003d {10}) \u003d\u003e ((String`indexAll(\"1234567890\", \u0027a\u0027) \u003d {}) \u003d\u003e ((String`indexAll(\"1231567190\", \u00271\u0027) \u003d {1, 4, 8}) \u003d\u003e ((String`indexAll(\"1231567191\", \u00271\u0027) \u003d {1, 4, 8, 10}) \u003d\u003e ((String`Index(\u00271\u0027)(\"1234567890\") \u003d 1) \u003d\u003e ((String`Index(\u00270\u0027)(\"1234567890\") \u003d 10) \u003d\u003e ((String`Index(\u0027a\u0027)(\"1234567890\") \u003d 0) \u003d\u003e ((String`IndexAll2(\u00271\u0027)(\"1234567890\") \u003d {1}) \u003d\u003e ((String`IndexAll2(\u00270\u0027)(\"1234567890\") \u003d {10}) \u003d\u003e pre_(String`IndexAll2(\u0027a\u0027)\"1234567890\"))))))))))))))","legal function application obligation:((String`index(\"1234567890\", \u00271\u0027) \u003d 1) \u003d\u003e ((String`index(\"1234567890\", \u00270\u0027) \u003d 10) \u003d\u003e ((String`index(\"1234567890\", \u0027a\u0027) \u003d 0) \u003d\u003e ((String`indexAll(\"1234567890\", \u00271\u0027) \u003d {1}) \u003d\u003e ((String`indexAll(\"1234567890\", \u00270\u0027) \u003d {10}) \u003d\u003e ((String`indexAll(\"1234567890\", \u0027a\u0027) \u003d {}) \u003d\u003e ((String`indexAll(\"1231567190\", \u00271\u0027) \u003d {1, 4, 8}) \u003d\u003e ((String`indexAll(\"1231567191\", \u00271\u0027) \u003d {1, 4, 8, 10}) \u003d\u003e ((String`Index(\u00271\u0027)(\"1234567890\") \u003d 1) \u003d\u003e ((String`Index(\u00270\u0027)(\"1234567890\") \u003d 10) \u003d\u003e ((String`Index(\u0027a\u0027)(\"1234567890\") \u003d 0) \u003d\u003e ((String`IndexAll2(\u00271\u0027)(\"1234567890\") \u003d {1}) \u003d\u003e ((String`IndexAll2(\u00270\u0027)(\"1234567890\") \u003d {10}) \u003d\u003e ((String`IndexAll2(\u0027a\u0027)(\"1234567890\") \u003d {}) \u003d\u003e pre_(String`IndexAll2(\u00271\u0027)\"1231567190\")))))))))))))))","legal function application obligation:((String`index(\"1234567890\", \u00271\u0027) \u003d 1) \u003d\u003e ((String`index(\"1234567890\", \u00270\u0027) \u003d 10) \u003d\u003e ((String`index(\"1234567890\", \u0027a\u0027) \u003d 0) \u003d\u003e ((String`indexAll(\"1234567890\", \u00271\u0027) \u003d {1}) \u003d\u003e ((String`indexAll(\"1234567890\", \u00270\u0027) \u003d {10}) \u003d\u003e ((String`indexAll(\"1234567890\", \u0027a\u0027) \u003d {}) \u003d\u003e ((String`indexAll(\"1231567190\", \u00271\u0027) \u003d {1, 4, 8}) \u003d\u003e ((String`indexAll(\"1231567191\", \u00271\u0027) \u003d {1, 4, 8, 10}) \u003d\u003e ((String`Index(\u00271\u0027)(\"1234567890\") \u003d 1) \u003d\u003e ((String`Index(\u00270\u0027)(\"1234567890\") \u003d 10) \u003d\u003e ((String`Index(\u0027a\u0027)(\"1234567890\") \u003d 0) \u003d\u003e ((String`IndexAll2(\u00271\u0027)(\"1234567890\") \u003d {1}) \u003d\u003e ((String`IndexAll2(\u00270\u0027)(\"1234567890\") \u003d {10}) \u003d\u003e ((String`IndexAll2(\u0027a\u0027)(\"1234567890\") \u003d {}) \u003d\u003e ((String`IndexAll2(\u00271\u0027)(\"1231567190\") \u003d {1, 4, 8}) \u003d\u003e pre_(String`IndexAll2(\u00271\u0027)\"1231567191\"))))))))))))))))","legal function application obligation:((String`index(\"1234567890\", \u00271\u0027) \u003d 1) \u003d\u003e ((String`index(\"1234567890\", \u00270\u0027) \u003d 10) \u003d\u003e ((String`index(\"1234567890\", \u0027a\u0027) \u003d 0) \u003d\u003e ((String`indexAll(\"1234567890\", \u00271\u0027) \u003d {1}) \u003d\u003e ((String`indexAll(\"1234567890\", \u00270\u0027) \u003d {10}) \u003d\u003e ((String`indexAll(\"1234567890\", \u0027a\u0027) \u003d {}) \u003d\u003e ((String`indexAll(\"1231567190\", \u00271\u0027) \u003d {1, 4, 8}) \u003d\u003e ((String`indexAll(\"1231567191\", \u00271\u0027) \u003d {1, 4, 8, 10}) \u003d\u003e ((String`Index(\u00271\u0027)(\"1234567890\") \u003d 1) \u003d\u003e ((String`Index(\u00270\u0027)(\"1234567890\") \u003d 10) \u003d\u003e ((String`Index(\u0027a\u0027)(\"1234567890\") \u003d 0) \u003d\u003e ((String`IndexAll2(\u00271\u0027)(\"1234567890\") \u003d {1}) \u003d\u003e ((String`IndexAll2(\u00270\u0027)(\"1234567890\") \u003d {10}) \u003d\u003e ((String`IndexAll2(\u0027a\u0027)(\"1234567890\") \u003d {}) \u003d\u003e ((String`IndexAll2(\u00271\u0027)(\"1231567190\") \u003d {1, 4, 8}) \u003d\u003e ((String`IndexAll2(\u00271\u0027)(\"1231567191\") \u003d {1, 4, 8, 10}) \u003d\u003e pre_((Sequence`fmap)[seq of (char), int](String`Index(\u00271\u0027))[\"1234567890\", \"2345671\"])))))))))))))))))","legal function application obligation:((String`index(\"1234567890\", \u00271\u0027) \u003d 1) \u003d\u003e ((String`index(\"1234567890\", \u00270\u0027) \u003d 10) \u003d\u003e ((String`index(\"1234567890\", \u0027a\u0027) \u003d 0) \u003d\u003e ((String`indexAll(\"1234567890\", \u00271\u0027) \u003d {1}) \u003d\u003e ((String`indexAll(\"1234567890\", \u00270\u0027) \u003d {10}) \u003d\u003e ((String`indexAll(\"1234567890\", \u0027a\u0027) \u003d {}) \u003d\u003e ((String`indexAll(\"1231567190\", \u00271\u0027) \u003d {1, 4, 8}) \u003d\u003e ((String`indexAll(\"1231567191\", \u00271\u0027) \u003d {1, 4, 8, 10}) \u003d\u003e ((String`Index(\u00271\u0027)(\"1234567890\") \u003d 1) \u003d\u003e ((String`Index(\u00270\u0027)(\"1234567890\") \u003d 10) \u003d\u003e ((String`Index(\u0027a\u0027)(\"1234567890\") \u003d 0) \u003d\u003e ((String`IndexAll2(\u00271\u0027)(\"1234567890\") \u003d {1}) \u003d\u003e ((String`IndexAll2(\u00270\u0027)(\"1234567890\") \u003d {10}) \u003d\u003e ((String`IndexAll2(\u0027a\u0027)(\"1234567890\") \u003d {}) \u003d\u003e ((String`IndexAll2(\u00271\u0027)(\"1231567190\") \u003d {1, 4, 8}) \u003d\u003e ((String`IndexAll2(\u00271\u0027)(\"1231567191\") \u003d {1, 4, 8, 10}) \u003d\u003e (((Sequence`fmap)[seq of (char), int](String`Index(\u00271\u0027))([\"1234567890\", \"2345671\"]) \u003d [1, 7]) \u003d\u003e pre_((Sequence`fmap)[seq of (char), set of (int)](String`IndexAll2(\u00271\u0027))[\"1231567190\", \"1231567191\"]))))))))))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(String`isInclude(\"1234567890\")\"abc\")","legal function application obligation:pre_isInclude(\"1234567890\")","legal function application obligation:((String`isInclude(\"1234567890\")(\"abc\") \u003d false) \u003d\u003e pre_(isInclude(\"Shin\")\"Shin\"))","legal function application obligation:((String`isInclude(\"1234567890\")(\"abc\") \u003d false) \u003d\u003e pre_(isInclude\"Shin\"))","legal function application obligation:((String`isInclude(\"1234567890\")(\"abc\") \u003d false) \u003d\u003e ((isInclude(\"Shin\")(\"Shin\") \u003d true) \u003d\u003e pre_(isInclude(\"Shin\")\"S\")))","legal function application obligation:((String`isInclude(\"1234567890\")(\"abc\") \u003d false) \u003d\u003e ((isInclude(\"Shin\")(\"Shin\") \u003d true) \u003d\u003e pre_(isInclude\"Shin\")))","legal function application obligation:((String`isInclude(\"1234567890\")(\"abc\") \u003d false) \u003d\u003e ((isInclude(\"Shin\")(\"Shin\") \u003d true) \u003d\u003e ((isInclude(\"Shin\")(\"S\") \u003d true) \u003d\u003e pre_(isInclude(\"Shin\")\"h\"))))","legal function application obligation:((String`isInclude(\"1234567890\")(\"abc\") \u003d false) \u003d\u003e ((isInclude(\"Shin\")(\"Shin\") \u003d true) \u003d\u003e ((isInclude(\"Shin\")(\"S\") \u003d true) \u003d\u003e pre_(isInclude\"Shin\"))))","legal function application obligation:((String`isInclude(\"1234567890\")(\"abc\") \u003d false) \u003d\u003e ((isInclude(\"Shin\")(\"Shin\") \u003d true) \u003d\u003e ((isInclude(\"Shin\")(\"S\") \u003d true) \u003d\u003e ((isInclude(\"Shin\")(\"h\") \u003d true) \u003d\u003e pre_(isInclude(\"Shin\")\"n\")))))","legal function application obligation:((String`isInclude(\"1234567890\")(\"abc\") \u003d false) \u003d\u003e ((isInclude(\"Shin\")(\"Shin\") \u003d true) \u003d\u003e ((isInclude(\"Shin\")(\"S\") \u003d true) \u003d\u003e ((isInclude(\"Shin\")(\"h\") \u003d true) \u003d\u003e pre_(isInclude\"Shin\")))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(String`isInclude(\"Shin Sahara\")\"\")","legal function application obligation:pre_isInclude(\"Shin Sahara\")","type compatibility obligation:is_(RESULT, ())","type compatibility obligation:is_(RESULT, ())","legal sequence application obligation:let 対象文字列1:seq1 of (char) \u003d \"private 次状態を得る : () \u003d\u003d\u003e 「状態」\n次状態を得る(aガード, aガード引数, aイベント, aイベント引数, a処理時間) \u003d\u003d (\ncases mk_(aガード, 現在状態, aイベント) :\n\tmk_(-,-,(エラー検知)) -\u003e return エラー中,\n\", ss1:seq of (seq of (char)) \u003d String`getLines(対象文字列1), 対象文字列2:seq1 of (char) \u003d \"佐原\n伸\", ss2:seq of (seq of (char)) \u003d String`getLines(対象文字列2) in (1 in set (inds ss1))","legal sequence application obligation:let 対象文字列1:seq1 of (char) \u003d \"private 次状態を得る : () \u003d\u003d\u003e 「状態」\n次状態を得る(aガード, aガード引数, aイベント, aイベント引数, a処理時間) \u003d\u003d (\ncases mk_(aガード, 現在状態, aイベント) :\n\tmk_(-,-,(エラー検知)) -\u003e return エラー中,\n\", ss1:seq of (seq of (char)) \u003d String`getLines(対象文字列1), 対象文字列2:seq1 of (char) \u003d \"佐原\n伸\", ss2:seq of (seq of (char)) \u003d String`getLines(対象文字列2) in ((ss1(1) \u003d \"private 次状態を得る : () \u003d\u003d\u003e 「状態」\") \u003d\u003e (2 in set (inds ss1)))","legal sequence application obligation:let 対象文字列1:seq1 of (char) \u003d \"private 次状態を得る : () \u003d\u003d\u003e 「状態」\n次状態を得る(aガード, aガード引数, aイベント, aイベント引数, a処理時間) \u003d\u003d (\ncases mk_(aガード, 現在状態, aイベント) :\n\tmk_(-,-,(エラー検知)) -\u003e return エラー中,\n\", ss1:seq of (seq of (char)) \u003d String`getLines(対象文字列1), 対象文字列2:seq1 of (char) \u003d \"佐原\n伸\", ss2:seq of (seq of (char)) \u003d String`getLines(対象文字列2) in ((ss1(1) \u003d \"private 次状態を得る : () \u003d\u003d\u003e 「状態」\") \u003d\u003e ((ss1(2) \u003d \"次状態を得る(aガード, aガード引数, aイベント, aイベント引数, a処理時間) \u003d\u003d (\") \u003d\u003e (3 in set (inds ss1))))","legal sequence application obligation:let 対象文字列1:seq1 of (char) \u003d \"private 次状態を得る : () \u003d\u003d\u003e 「状態」\n次状態を得る(aガード, aガード引数, aイベント, aイベント引数, a処理時間) \u003d\u003d (\ncases mk_(aガード, 現在状態, aイベント) :\n\tmk_(-,-,(エラー検知)) -\u003e return エラー中,\n\", ss1:seq of (seq of (char)) \u003d String`getLines(対象文字列1), 対象文字列2:seq1 of (char) \u003d \"佐原\n伸\", ss2:seq of (seq of (char)) \u003d String`getLines(対象文字列2) in ((ss1(1) \u003d \"private 次状態を得る : () \u003d\u003d\u003e 「状態」\") \u003d\u003e ((ss1(2) \u003d \"次状態を得る(aガード, aガード引数, aイベント, aイベント引数, a処理時間) \u003d\u003d (\") \u003d\u003e ((ss1(3) \u003d \"cases mk_(aガード, 現在状態, aイベント) :\") \u003d\u003e (4 in set (inds ss1)))))","legal sequence application obligation:let 対象文字列1:seq1 of (char) \u003d \"private 次状態を得る : () \u003d\u003d\u003e 「状態」\n次状態を得る(aガード, aガード引数, aイベント, aイベント引数, a処理時間) \u003d\u003d (\ncases mk_(aガード, 現在状態, aイベント) :\n\tmk_(-,-,(エラー検知)) -\u003e return エラー中,\n\", ss1:seq of (seq of (char)) \u003d String`getLines(対象文字列1), 対象文字列2:seq1 of (char) \u003d \"佐原\n伸\", ss2:seq of (seq of (char)) \u003d String`getLines(対象文字列2) in ((ss1(1) \u003d \"private 次状態を得る : () \u003d\u003d\u003e 「状態」\") \u003d\u003e ((ss1(2) \u003d \"次状態を得る(aガード, aガード引数, aイベント, aイベント引数, a処理時間) \u003d\u003d (\") \u003d\u003e ((ss1(3) \u003d \"cases mk_(aガード, 現在状態, aイベント) :\") \u003d\u003e ((ss1(4) \u003d \"\tmk_(-,-,(エラー検知)) -\u003e return エラー中,\") \u003d\u003e (1 in set (inds ss2))))))","legal sequence application obligation:let 対象文字列1:seq1 of (char) \u003d \"private 次状態を得る : () \u003d\u003d\u003e 「状態」\n次状態を得る(aガード, aガード引数, aイベント, aイベント引数, a処理時間) \u003d\u003d (\ncases mk_(aガード, 現在状態, aイベント) :\n\tmk_(-,-,(エラー検知)) -\u003e return エラー中,\n\", ss1:seq of (seq of (char)) \u003d String`getLines(対象文字列1), 対象文字列2:seq1 of (char) \u003d \"佐原\n伸\", ss2:seq of (seq of (char)) \u003d String`getLines(対象文字列2) in ((ss1(1) \u003d \"private 次状態を得る : () \u003d\u003d\u003e 「状態」\") \u003d\u003e ((ss1(2) \u003d \"次状態を得る(aガード, aガード引数, aイベント, aイベント引数, a処理時間) \u003d\u003d (\") \u003d\u003e ((ss1(3) \u003d \"cases mk_(aガード, 現在状態, aイベント) :\") \u003d\u003e ((ss1(4) \u003d \"\tmk_(-,-,(エラー検知)) -\u003e return エラー中,\") \u003d\u003e ((ss2(1) \u003d \"佐原\") \u003d\u003e (2 in set (inds ss2)))))))","type compatibility obligation:is_(RESULT, ())","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(isSomeString(Character`isLetterOrDigit)\"007isTheMmurder\")","legal function application obligation:pre_(isSomeStringCharacter`isLetterOrDigit)","legal function application obligation:(isSomeString(Character`isLetterOrDigit)(\"007isTheMmurder\") \u003d\u003e pre_(isSomeString(Character`isLetterOrDigit)\"007 is the mmurder\"))","legal function application obligation:(isSomeString(Character`isLetterOrDigit)(\"007isTheMmurder\") \u003d\u003e pre_(isSomeStringCharacter`isLetterOrDigit))","legal function application obligation:(isSomeString(Character`isLetterOrDigit)(\"007isTheMmurder\") \u003d\u003e ((not isSomeString(Character`isLetterOrDigit)(\"007 is the mmurder\")) \u003d\u003e pre_(isSomeString(Character`isCapitalLetter)\"SAHARA\")))","legal function application obligation:(isSomeString(Character`isLetterOrDigit)(\"007isTheMmurder\") \u003d\u003e ((not isSomeString(Character`isLetterOrDigit)(\"007 is the mmurder\")) \u003d\u003e pre_(isSomeStringCharacter`isCapitalLetter)))","legal function application obligation:(isSomeString(Character`isLetterOrDigit)(\"007isTheMmurder\") \u003d\u003e ((not isSomeString(Character`isLetterOrDigit)(\"007 is the mmurder\")) \u003d\u003e (isSomeString(Character`isCapitalLetter)(\"SAHARA\") \u003d\u003e pre_(isSomeString(Character`isCapitalLetter)\"Sahara\"))))","legal function application obligation:(isSomeString(Character`isLetterOrDigit)(\"007isTheMmurder\") \u003d\u003e ((not isSomeString(Character`isLetterOrDigit)(\"007 is the mmurder\")) \u003d\u003e (isSomeString(Character`isCapitalLetter)(\"SAHARA\") \u003d\u003e pre_(isSomeStringCharacter`isCapitalLetter))))","legal function application obligation:(isSomeString(Character`isLetterOrDigit)(\"007isTheMmurder\") \u003d\u003e ((not isSomeString(Character`isLetterOrDigit)(\"007 is the mmurder\")) \u003d\u003e (isSomeString(Character`isCapitalLetter)(\"SAHARA\") \u003d\u003e ((not isSomeString(Character`isCapitalLetter)(\"Sahara\")) \u003d\u003e pre_(isSomeString(Character`isLowercaseLetter)\"sahara\")))))","legal function application obligation:(isSomeString(Character`isLetterOrDigit)(\"007isTheMmurder\") \u003d\u003e ((not isSomeString(Character`isLetterOrDigit)(\"007 is the mmurder\")) \u003d\u003e (isSomeString(Character`isCapitalLetter)(\"SAHARA\") \u003d\u003e ((not isSomeString(Character`isCapitalLetter)(\"Sahara\")) \u003d\u003e pre_(isSomeStringCharacter`isLowercaseLetter)))))","legal function application obligation:(isSomeString(Character`isLetterOrDigit)(\"007isTheMmurder\") \u003d\u003e ((not isSomeString(Character`isLetterOrDigit)(\"007 is the mmurder\")) \u003d\u003e (isSomeString(Character`isCapitalLetter)(\"SAHARA\") \u003d\u003e ((not isSomeString(Character`isCapitalLetter)(\"Sahara\")) \u003d\u003e (isSomeString(Character`isLowercaseLetter)(\"sahara\") \u003d\u003e pre_(isSomeString(Character`isLowercaseLetter)\"Sahara\"))))))","legal function application obligation:(isSomeString(Character`isLetterOrDigit)(\"007isTheMmurder\") \u003d\u003e ((not isSomeString(Character`isLetterOrDigit)(\"007 is the mmurder\")) \u003d\u003e (isSomeString(Character`isCapitalLetter)(\"SAHARA\") \u003d\u003e ((not isSomeString(Character`isCapitalLetter)(\"Sahara\")) \u003d\u003e (isSomeString(Character`isLowercaseLetter)(\"sahara\") \u003d\u003e pre_(isSomeStringCharacter`isLowercaseLetter))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:(forall f:(@T1 * @T2 -\u003e @T3), x:@T1, y:@T2 \u0026 pre_(fx, y))","legal function application obligation:(forall f:(@T1 -\u003e (@T2 -\u003e @T3)), x:@T1, y:@T2 \u0026 pre_(f(x)y))","legal function application obligation:(forall f:(@T1 -\u003e (@T2 -\u003e @T3)), x:@T1, y:@T2 \u0026 pre_(fx))","function establishes postcondition obligation:(forall aSet:set of (@T) \u0026 post_asSequence(aSet, (cases aSet :\n{} -\u003e [],\n{x} union xs -\u003e ([x] ^ (asSequence)[@T](xs))\n end)))","recursive function obligation:(forall aSet:set of (@T) \u0026 ((not ({} \u003d aSet)) \u003d\u003e (exists {x} union xs:set of (@T) \u0026 ((({x} union xs) \u003d aSet) \u003d\u003e let {x} union xs \u003d aSet in ((cardinality)[set of (@T)](aSet) \u003e (cardinality)[@T](xs))))))","cases exhaustive obligation:(forall aSet:set of (@T) \u0026 ((aSet \u003d {}) or (exists {x} union xs:set of (@T) \u0026 (aSet \u003d ({x} union xs)))))","legal function application obligation:(forall f:(@T1 -\u003e @T2), aSet:set of (@T1) \u0026 (forall s in set aSet \u0026 pre_(fs)))","legal function application obligation:(forall aSet:set of (@T) \u0026 ((is_(aSet, set of (int)) or (is_(aSet, set of (nat)) or (is_(aSet, set of (nat1)) or (is_(aSet, set of (real)) or is_(aSet, set of (rat)))))) \u003d\u003e pre_((SumAux)[@T](aSet)0)))","legal function application obligation:(forall aSet:set of (@T) \u0026 ((is_(aSet, set of (int)) or (is_(aSet, set of (nat)) or (is_(aSet, set of (nat1)) or (is_(aSet, set of (real)) or is_(aSet, set of (rat)))))) \u003d\u003e pre_SumAux(aSet)))","legal function application obligation:(forall aSet:set of (@T), aSum:@T \u0026 ((pre_Sum)[@T](aSet) \u003d\u003e ((not ({} \u003d aSet)) \u003d\u003e (exists {e} union s:set of (@T) \u0026 ((({e} union s) \u003d aSet) \u003d\u003e let {e} union s \u003d aSet in pre_((SumAux)[@T](s)(if (is_(aSum, real) and is_(e, real))\nthen (aSum + e)\nelse (undefined))))))))","legal function application obligation:(forall aSet:set of (@T), aSum:@T \u0026 ((pre_Sum)[@T](aSet) \u003d\u003e ((not ({} \u003d aSet)) \u003d\u003e (exists {e} union s:set of (@T) \u0026 ((({e} union s) \u003d aSet) \u003d\u003e let {e} union s \u003d aSet in pre_SumAux(s))))))","cases exhaustive obligation:(forall aSet:set of (@T), aSum:@T \u0026 ((pre_Sum)[@T](aSet) \u003d\u003e ((aSet \u003d {}) or (exists {e} union s:set of (@T) \u0026 (aSet \u003d ({e} union s))))))","type compatibility obligation:is_(RESULT, ())","type compatibility obligation:is_(q4, (seq of (int) * seq of (int)))","type compatibility obligation:is_(q7, (seq of (int) * seq of (int)))","type compatibility obligation:is_(q8, (seq of (int) * seq of (int)))","type compatibility obligation:is_(q9, (seq of (int) * seq of (int)))","type compatibility obligation:is_(q10, (seq of (int) * seq of (int)))","type compatibility obligation:is_(q10, (seq of (int) * seq of (int)))","type compatibility obligation:((DoubleListQueue`isEmpty)[int](q0) \u003d\u003e ((q0 \u003d mk_([], [])) \u003d\u003e (((DoubleListQueue`toList)[int](q1) \u003d [1]) \u003d\u003e ((q1 \u003d mk_([], [1])) \u003d\u003e (((DoubleListQueue`toList)[int](q2) \u003d [1, 2]) \u003d\u003e ((q2 \u003d mk_([], [2, 1])) \u003d\u003e (((DoubleListQueue`toList)[int](q3) \u003d [1, 2, 3]) \u003d\u003e ((q3 \u003d mk_([], [3, 2, 1])) \u003d\u003e ((h1 \u003d 1) \u003d\u003e is_(q4, (seq of (int) * seq of (int))))))))))))","type compatibility obligation:((DoubleListQueue`isEmpty)[int](q0) \u003d\u003e ((q0 \u003d mk_([], [])) \u003d\u003e (((DoubleListQueue`toList)[int](q1) \u003d [1]) \u003d\u003e ((q1 \u003d mk_([], [1])) \u003d\u003e (((DoubleListQueue`toList)[int](q2) \u003d [1, 2]) \u003d\u003e ((q2 \u003d mk_([], [2, 1])) \u003d\u003e (((DoubleListQueue`toList)[int](q3) \u003d [1, 2, 3]) \u003d\u003e ((q3 \u003d mk_([], [3, 2, 1])) \u003d\u003e ((h1 \u003d 1) \u003d\u003e (((DoubleListQueue`toList)[int](q4) \u003d [2, 3]) \u003d\u003e ((q4 \u003d mk_([2, 3], [])) \u003d\u003e (((DoubleListQueue`toList)[int](q5) \u003d [2, 3, 4]) \u003d\u003e ((q5 \u003d mk_([2, 3], [4])) \u003d\u003e (((DoubleListQueue`toList)[int](q6) \u003d [2, 3, 4, 5]) \u003d\u003e ((q6 \u003d mk_([2, 3], [5, 4])) \u003d\u003e is_(q7, (seq of (int) * seq of (int))))))))))))))))))","type compatibility obligation:((DoubleListQueue`isEmpty)[int](q0) \u003d\u003e ((q0 \u003d mk_([], [])) \u003d\u003e (((DoubleListQueue`toList)[int](q1) \u003d [1]) \u003d\u003e ((q1 \u003d mk_([], [1])) \u003d\u003e (((DoubleListQueue`toList)[int](q2) \u003d [1, 2]) \u003d\u003e ((q2 \u003d mk_([], [2, 1])) \u003d\u003e (((DoubleListQueue`toList)[int](q3) \u003d [1, 2, 3]) \u003d\u003e ((q3 \u003d mk_([], [3, 2, 1])) \u003d\u003e ((h1 \u003d 1) \u003d\u003e (((DoubleListQueue`toList)[int](q4) \u003d [2, 3]) \u003d\u003e ((q4 \u003d mk_([2, 3], [])) \u003d\u003e (((DoubleListQueue`toList)[int](q5) \u003d [2, 3, 4]) \u003d\u003e ((q5 \u003d mk_([2, 3], [4])) \u003d\u003e (((DoubleListQueue`toList)[int](q6) \u003d [2, 3, 4, 5]) \u003d\u003e ((q6 \u003d mk_([2, 3], [5, 4])) \u003d\u003e (((DoubleListQueue`toList)[int](q7) \u003d [3, 4, 5]) \u003d\u003e ((q7 \u003d mk_([3], [5, 4])) \u003d\u003e is_(q8, (seq of (int) * seq of (int))))))))))))))))))))","type compatibility obligation:((DoubleListQueue`isEmpty)[int](q0) \u003d\u003e ((q0 \u003d mk_([], [])) \u003d\u003e (((DoubleListQueue`toList)[int](q1) \u003d [1]) \u003d\u003e ((q1 \u003d mk_([], [1])) \u003d\u003e (((DoubleListQueue`toList)[int](q2) \u003d [1, 2]) \u003d\u003e ((q2 \u003d mk_([], [2, 1])) \u003d\u003e (((DoubleListQueue`toList)[int](q3) \u003d [1, 2, 3]) \u003d\u003e ((q3 \u003d mk_([], [3, 2, 1])) \u003d\u003e ((h1 \u003d 1) \u003d\u003e (((DoubleListQueue`toList)[int](q4) \u003d [2, 3]) \u003d\u003e ((q4 \u003d mk_([2, 3], [])) \u003d\u003e (((DoubleListQueue`toList)[int](q5) \u003d [2, 3, 4]) \u003d\u003e ((q5 \u003d mk_([2, 3], [4])) \u003d\u003e (((DoubleListQueue`toList)[int](q6) \u003d [2, 3, 4, 5]) \u003d\u003e ((q6 \u003d mk_([2, 3], [5, 4])) \u003d\u003e (((DoubleListQueue`toList)[int](q7) \u003d [3, 4, 5]) \u003d\u003e ((q7 \u003d mk_([3], [5, 4])) \u003d\u003e (((DoubleListQueue`toList)[int](q8) \u003d [4, 5]) \u003d\u003e ((q8 \u003d mk_([], [5, 4])) \u003d\u003e is_(q9, (seq of (int) * seq of (int))))))))))))))))))))))","type compatibility obligation:((DoubleListQueue`isEmpty)[int](q0) \u003d\u003e ((q0 \u003d mk_([], [])) \u003d\u003e (((DoubleListQueue`toList)[int](q1) \u003d [1]) \u003d\u003e ((q1 \u003d mk_([], [1])) \u003d\u003e (((DoubleListQueue`toList)[int](q2) \u003d [1, 2]) \u003d\u003e ((q2 \u003d mk_([], [2, 1])) \u003d\u003e (((DoubleListQueue`toList)[int](q3) \u003d [1, 2, 3]) \u003d\u003e ((q3 \u003d mk_([], [3, 2, 1])) \u003d\u003e ((h1 \u003d 1) \u003d\u003e (((DoubleListQueue`toList)[int](q4) \u003d [2, 3]) \u003d\u003e ((q4 \u003d mk_([2, 3], [])) \u003d\u003e (((DoubleListQueue`toList)[int](q5) \u003d [2, 3, 4]) \u003d\u003e ((q5 \u003d mk_([2, 3], [4])) \u003d\u003e (((DoubleListQueue`toList)[int](q6) \u003d [2, 3, 4, 5]) \u003d\u003e ((q6 \u003d mk_([2, 3], [5, 4])) \u003d\u003e (((DoubleListQueue`toList)[int](q7) \u003d [3, 4, 5]) \u003d\u003e ((q7 \u003d mk_([3], [5, 4])) \u003d\u003e (((DoubleListQueue`toList)[int](q8) \u003d [4, 5]) \u003d\u003e ((q8 \u003d mk_([], [5, 4])) \u003d\u003e (((DoubleListQueue`toList)[int](q9) \u003d [5]) \u003d\u003e ((q9 \u003d mk_([5], [])) \u003d\u003e is_(q10, (seq of (int) * seq of (int))))))))))))))))))))))))","type compatibility obligation:((DoubleListQueue`isEmpty)[int](q0) \u003d\u003e ((q0 \u003d mk_([], [])) \u003d\u003e (((DoubleListQueue`toList)[int](q1) \u003d [1]) \u003d\u003e ((q1 \u003d mk_([], [1])) \u003d\u003e (((DoubleListQueue`toList)[int](q2) \u003d [1, 2]) \u003d\u003e ((q2 \u003d mk_([], [2, 1])) \u003d\u003e (((DoubleListQueue`toList)[int](q3) \u003d [1, 2, 3]) \u003d\u003e ((q3 \u003d mk_([], [3, 2, 1])) \u003d\u003e ((h1 \u003d 1) \u003d\u003e (((DoubleListQueue`toList)[int](q4) \u003d [2, 3]) \u003d\u003e ((q4 \u003d mk_([2, 3], [])) \u003d\u003e (((DoubleListQueue`toList)[int](q5) \u003d [2, 3, 4]) \u003d\u003e ((q5 \u003d mk_([2, 3], [4])) \u003d\u003e (((DoubleListQueue`toList)[int](q6) \u003d [2, 3, 4, 5]) \u003d\u003e ((q6 \u003d mk_([2, 3], [5, 4])) \u003d\u003e (((DoubleListQueue`toList)[int](q7) \u003d [3, 4, 5]) \u003d\u003e ((q7 \u003d mk_([3], [5, 4])) \u003d\u003e (((DoubleListQueue`toList)[int](q8) \u003d [4, 5]) \u003d\u003e ((q8 \u003d mk_([], [5, 4])) \u003d\u003e (((DoubleListQueue`toList)[int](q9) \u003d [5]) \u003d\u003e ((q9 \u003d mk_([5], [])) \u003d\u003e (((DoubleListQueue`toList)[int](q10) \u003d []) \u003d\u003e is_(q10, (seq of (int) * seq of (int)))))))))))))))))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((Function`Fwhile)[int](p11)(f1)1)","legal function application obligation:pre_((Function`Fwhile)[int](p11)f1)","legal function application obligation:(((Function`Fwhile)[int](p11)(f1)(1) \u003d 1024) \u003d\u003e pre_((Function`Fwhile)[seq of (char)](p21)(f2)\"123456\"))","legal function application obligation:(((Function`Fwhile)[int](p11)(f1)(1) \u003d 1024) \u003d\u003e pre_((Function`Fwhile)[seq of (char)](p21)f2))","legal function application obligation:(((Function`Fwhile)[int](p11)(f1)(1) \u003d 1024) \u003d\u003e (((Function`Fwhile)[seq of (char)](p21)(f2)(\"123456\") \u003d \"1234560000\") \u003d\u003e pre_((Function`Funtil)[int](p1)(f1)1)))","legal function application obligation:(((Function`Fwhile)[int](p11)(f1)(1) \u003d 1024) \u003d\u003e (((Function`Fwhile)[seq of (char)](p21)(f2)(\"123456\") \u003d \"1234560000\") \u003d\u003e pre_((Function`Funtil)[int](p1)f1)))","legal function application obligation:(((Function`Fwhile)[int](p11)(f1)(1) \u003d 1024) \u003d\u003e (((Function`Fwhile)[seq of (char)](p21)(f2)(\"123456\") \u003d \"1234560000\") \u003d\u003e (((Function`Funtil)[int](p1)(f1)(1) \u003d 1024) \u003d\u003e pre_((Function`Funtil)[seq of (char)](p2)(f2)\"123456\"))))","legal function application obligation:(((Function`Fwhile)[int](p11)(f1)(1) \u003d 1024) \u003d\u003e (((Function`Fwhile)[seq of (char)](p21)(f2)(\"123456\") \u003d \"1234560000\") \u003d\u003e (((Function`Funtil)[int](p1)(f1)(1) \u003d 1024) \u003d\u003e pre_((Function`Funtil)[seq of (char)](p2)f2))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((Function`Seq)[int](funcSeq1)2)","legal function application obligation:(((Function`Seq)[int](funcSeq1)(2) \u003d (((2 * 2) * 3) ** 2)) \u003d\u003e pre_((Function`Seq)[seq of (char)](funcSeq2)\"12345678\"))","type compatibility obligation:is_(RESULT, ())","type compatibility obligation:is_(let fn:seq1 of (char) \u003d \"./fread-func.txt\" in (Function`readFn)[ReadingFunctionType](fn), (INT -\u003e (INT -\u003e INT)))","legal function application obligation:pre_(ReadingFunction()(3)2)","legal function application obligation:pre_(ReadingFunction()3)","legal function application obligation:((ReadingFunction()(3)(2) \u003d 1) \u003d\u003e pre_(ReadingFunction()(4)4))","legal function application obligation:((ReadingFunction()(3)(2) \u003d 1) \u003d\u003e pre_(ReadingFunction()4))","legal function application obligation:((ReadingFunction()(3)(2) \u003d 1) \u003d\u003e ((ReadingFunction()(4)(4) \u003d 0) \u003d\u003e pre_(ReadingFunction()(4)-3)))","legal function application obligation:((ReadingFunction()(3)(2) \u003d 1) \u003d\u003e ((ReadingFunction()(4)(4) \u003d 0) \u003d\u003e pre_(ReadingFunction()4)))","legal function application obligation:((ReadingFunction()(3)(2) \u003d 1) \u003d\u003e ((ReadingFunction()(4)(4) \u003d 0) \u003d\u003e ((ReadingFunction()(4)(-3) \u003d -2) \u003d\u003e pre_(ReadingFunction()(-4)3))))","legal function application obligation:((ReadingFunction()(3)(2) \u003d 1) \u003d\u003e ((ReadingFunction()(4)(4) \u003d 0) \u003d\u003e ((ReadingFunction()(4)(-3) \u003d -2) \u003d\u003e pre_(ReadingFunction()-4))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((FHashtable`PutAll)[int, seq of (char)]({|-\u003e})(aHashCode){1 |-\u003e \"Sahara\", 2 |-\u003e \"Sato\", 14 |-\u003e \"Sakoh\"})","legal function application obligation:pre_((FHashtable`PutAll)[int, seq of (char)]({|-\u003e})aHashCode)","enumeration map injectivity obligation:(forall m1, m2 in set {{1 |-\u003e \"Sahara\"}, {2 |-\u003e \"Sato\"}, {14 |-\u003e \"Sakoh\"}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","legal function application obligation:let aHashCode:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), p1:map (int) to (map (int) to (seq of (char))) \u003d (FHashtable`PutAll)[int, seq of (char)]({|-\u003e})(aHashCode)({1 |-\u003e \"Sahara\", 2 |-\u003e \"Sato\", 14 |-\u003e \"Sakoh\"}), c1:(seq of (char) +\u003e bool) \u003d (FHashtable`Contains)[int, seq of (char)](p1) in pre_(c1\"Sahara\")","legal function application obligation:let aHashCode:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), p1:map (int) to (map (int) to (seq of (char))) \u003d (FHashtable`PutAll)[int, seq of (char)]({|-\u003e})(aHashCode)({1 |-\u003e \"Sahara\", 2 |-\u003e \"Sato\", 14 |-\u003e \"Sakoh\"}), c1:(seq of (char) +\u003e bool) \u003d (FHashtable`Contains)[int, seq of (char)](p1) in (c1(\"Sahara\") \u003d\u003e pre_(c1\"Sato\"))","legal function application obligation:let aHashCode:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), p1:map (int) to (map (int) to (seq of (char))) \u003d (FHashtable`PutAll)[int, seq of (char)]({|-\u003e})(aHashCode)({1 |-\u003e \"Sahara\", 2 |-\u003e \"Sato\", 14 |-\u003e \"Sakoh\"}), c1:(seq of (char) +\u003e bool) \u003d (FHashtable`Contains)[int, seq of (char)](p1) in (c1(\"Sahara\") \u003d\u003e (c1(\"Sato\") \u003d\u003e pre_(c1\"Sakoh\")))","legal function application obligation:let aHashCode:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), p1:map (int) to (map (int) to (seq of (char))) \u003d (FHashtable`PutAll)[int, seq of (char)]({|-\u003e})(aHashCode)({1 |-\u003e \"Sahara\", 2 |-\u003e \"Sato\", 14 |-\u003e \"Sakoh\"}), c1:(seq of (char) +\u003e bool) \u003d (FHashtable`Contains)[int, seq of (char)](p1) in (c1(\"Sahara\") \u003d\u003e (c1(\"Sato\") \u003d\u003e (c1(\"Sakoh\") \u003d\u003e pre_(c1\"\"))))","legal function application obligation:(forall x:seq of (char) \u0026 ((not (x \u003d \"\")) \u003d\u003e pre_((FSequence`Take)[char](1)x)))","legal function application obligation:pre_((FHashtable`PutAll)[seq of (char), int]({|-\u003e})(aHashCode){\"a\" |-\u003e 1, \"b\" |-\u003e 2, \"c\" |-\u003e 3})","legal function application obligation:pre_((FHashtable`PutAll)[seq of (char), int]({|-\u003e})aHashCode)","enumeration map injectivity obligation:(forall m1, m2 in set {{\"a\" |-\u003e 1}, {\"b\" |-\u003e 2}, {\"c\" |-\u003e 3}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","legal function application obligation:pre_((FHashtable`Remove)[seq of (char), int](h2)(aHashCode)\"b\")","legal function application obligation:pre_((FHashtable`Remove)[seq of (char), int](h2)aHashCode)","legal function application obligation:let aHashCode:(seq of (char) -\u003e seq of (char)) \u003d (lambda [x:seq of (char)] \u0026 (if (x \u003d \"\")\nthen \"\"\nelse (FSequence`Take)[char](1)(x))), h2:map (seq of (char)) to (map (seq of (char)) to (int)) \u003d (FHashtable`PutAll)[seq of (char), int]({|-\u003e})(aHashCode)({\"a\" |-\u003e 1, \"b\" |-\u003e 2, \"c\" |-\u003e 3}), h3:map (int) to (map (int) to (seq of (char))) \u003d (FHashtable`Clear)[int, seq of (char)](), deletedh2:map (seq of (char)) to (map (seq of (char)) to (int)) \u003d (FHashtable`Remove)[seq of (char), int](h2)(aHashCode)(\"b\"), c1:(int +\u003e bool) \u003d (FHashtable`Contains)[seq of (char), int](deletedh2), ck1:(seq of (char) +\u003e bool) \u003d (FHashtable`ContainsKey)[seq of (char), int](deletedh2) in ((h3 \u003d {|-\u003e}) \u003d\u003e pre_((FHashtable`Get)[seq of (char), int](deletedh2)(aHashCode)\"b\"))","legal function application obligation:let aHashCode:(seq of (char) -\u003e seq of (char)) \u003d (lambda [x:seq of (char)] \u0026 (if (x \u003d \"\")\nthen \"\"\nelse (FSequence`Take)[char](1)(x))), h2:map (seq of (char)) to (map (seq of (char)) to (int)) \u003d (FHashtable`PutAll)[seq of (char), int]({|-\u003e})(aHashCode)({\"a\" |-\u003e 1, \"b\" |-\u003e 2, \"c\" |-\u003e 3}), h3:map (int) to (map (int) to (seq of (char))) \u003d (FHashtable`Clear)[int, seq of (char)](), deletedh2:map (seq of (char)) to (map (seq of (char)) to (int)) \u003d (FHashtable`Remove)[seq of (char), int](h2)(aHashCode)(\"b\"), c1:(int +\u003e bool) \u003d (FHashtable`Contains)[seq of (char), int](deletedh2), ck1:(seq of (char) +\u003e bool) \u003d (FHashtable`ContainsKey)[seq of (char), int](deletedh2) in ((h3 \u003d {|-\u003e}) \u003d\u003e pre_((FHashtable`Get)[seq of (char), int](deletedh2)aHashCode))","legal function application obligation:let aHashCode:(seq of (char) -\u003e seq of (char)) \u003d (lambda [x:seq of (char)] \u0026 (if (x \u003d \"\")\nthen \"\"\nelse (FSequence`Take)[char](1)(x))), h2:map (seq of (char)) to (map (seq of (char)) to (int)) \u003d (FHashtable`PutAll)[seq of (char), int]({|-\u003e})(aHashCode)({\"a\" |-\u003e 1, \"b\" |-\u003e 2, \"c\" |-\u003e 3}), h3:map (int) to (map (int) to (seq of (char))) \u003d (FHashtable`Clear)[int, seq of (char)](), deletedh2:map (seq of (char)) to (map (seq of (char)) to (int)) \u003d (FHashtable`Remove)[seq of (char), int](h2)(aHashCode)(\"b\"), c1:(int +\u003e bool) \u003d (FHashtable`Contains)[seq of (char), int](deletedh2), ck1:(seq of (char) +\u003e bool) \u003d (FHashtable`ContainsKey)[seq of (char), int](deletedh2) in ((h3 \u003d {|-\u003e}) \u003d\u003e (((FHashtable`Get)[seq of (char), int](deletedh2)(aHashCode)(\"b\") \u003d nil) \u003d\u003e pre_(c12)))","legal function application obligation:let aHashCode:(seq of (char) -\u003e seq of (char)) \u003d (lambda [x:seq of (char)] \u0026 (if (x \u003d \"\")\nthen \"\"\nelse (FSequence`Take)[char](1)(x))), h2:map (seq of (char)) to (map (seq of (char)) to (int)) \u003d (FHashtable`PutAll)[seq of (char), int]({|-\u003e})(aHashCode)({\"a\" |-\u003e 1, \"b\" |-\u003e 2, \"c\" |-\u003e 3}), h3:map (int) to (map (int) to (seq of (char))) \u003d (FHashtable`Clear)[int, seq of (char)](), deletedh2:map (seq of (char)) to (map (seq of (char)) to (int)) \u003d (FHashtable`Remove)[seq of (char), int](h2)(aHashCode)(\"b\"), c1:(int +\u003e bool) \u003d (FHashtable`Contains)[seq of (char), int](deletedh2), ck1:(seq of (char) +\u003e bool) \u003d (FHashtable`ContainsKey)[seq of (char), int](deletedh2) in ((h3 \u003d {|-\u003e}) \u003d\u003e (((FHashtable`Get)[seq of (char), int](deletedh2)(aHashCode)(\"b\") \u003d nil) \u003d\u003e ((c1(2) \u003d false) \u003d\u003e pre_(c11))))","legal function application obligation:let aHashCode:(seq of (char) -\u003e seq of (char)) \u003d (lambda [x:seq of (char)] \u0026 (if (x \u003d \"\")\nthen \"\"\nelse (FSequence`Take)[char](1)(x))), h2:map (seq of (char)) to (map (seq of (char)) to (int)) \u003d (FHashtable`PutAll)[seq of (char), int]({|-\u003e})(aHashCode)({\"a\" |-\u003e 1, \"b\" |-\u003e 2, \"c\" |-\u003e 3}), h3:map (int) to (map (int) to (seq of (char))) \u003d (FHashtable`Clear)[int, seq of (char)](), deletedh2:map (seq of (char)) to (map (seq of (char)) to (int)) \u003d (FHashtable`Remove)[seq of (char), int](h2)(aHashCode)(\"b\"), c1:(int +\u003e bool) \u003d (FHashtable`Contains)[seq of (char), int](deletedh2), ck1:(seq of (char) +\u003e bool) \u003d (FHashtable`ContainsKey)[seq of (char), int](deletedh2) in ((h3 \u003d {|-\u003e}) \u003d\u003e (((FHashtable`Get)[seq of (char), int](deletedh2)(aHashCode)(\"b\") \u003d nil) \u003d\u003e ((c1(2) \u003d false) \u003d\u003e (c1(1) \u003d\u003e pre_(c13)))))","legal function application obligation:let aHashCode:(seq of (char) -\u003e seq of (char)) \u003d (lambda [x:seq of (char)] \u0026 (if (x \u003d \"\")\nthen \"\"\nelse (FSequence`Take)[char](1)(x))), h2:map (seq of (char)) to (map (seq of (char)) to (int)) \u003d (FHashtable`PutAll)[seq of (char), int]({|-\u003e})(aHashCode)({\"a\" |-\u003e 1, \"b\" |-\u003e 2, \"c\" |-\u003e 3}), h3:map (int) to (map (int) to (seq of (char))) \u003d (FHashtable`Clear)[int, seq of (char)](), deletedh2:map (seq of (char)) to (map (seq of (char)) to (int)) \u003d (FHashtable`Remove)[seq of (char), int](h2)(aHashCode)(\"b\"), c1:(int +\u003e bool) \u003d (FHashtable`Contains)[seq of (char), int](deletedh2), ck1:(seq of (char) +\u003e bool) \u003d (FHashtable`ContainsKey)[seq of (char), int](deletedh2) in ((h3 \u003d {|-\u003e}) \u003d\u003e (((FHashtable`Get)[seq of (char), int](deletedh2)(aHashCode)(\"b\") \u003d nil) \u003d\u003e ((c1(2) \u003d false) \u003d\u003e (c1(1) \u003d\u003e (c1(3) \u003d\u003e pre_(ck1\"b\"))))))","legal function application obligation:let aHashCode:(seq of (char) -\u003e seq of (char)) \u003d (lambda [x:seq of (char)] \u0026 (if (x \u003d \"\")\nthen \"\"\nelse (FSequence`Take)[char](1)(x))), h2:map (seq of (char)) to (map (seq of (char)) to (int)) \u003d (FHashtable`PutAll)[seq of (char), int]({|-\u003e})(aHashCode)({\"a\" |-\u003e 1, \"b\" |-\u003e 2, \"c\" |-\u003e 3}), h3:map (int) to (map (int) to (seq of (char))) \u003d (FHashtable`Clear)[int, seq of (char)](), deletedh2:map (seq of (char)) to (map (seq of (char)) to (int)) \u003d (FHashtable`Remove)[seq of (char), int](h2)(aHashCode)(\"b\"), c1:(int +\u003e bool) \u003d (FHashtable`Contains)[seq of (char), int](deletedh2), ck1:(seq of (char) +\u003e bool) \u003d (FHashtable`ContainsKey)[seq of (char), int](deletedh2) in ((h3 \u003d {|-\u003e}) \u003d\u003e (((FHashtable`Get)[seq of (char), int](deletedh2)(aHashCode)(\"b\") \u003d nil) \u003d\u003e ((c1(2) \u003d false) \u003d\u003e (c1(1) \u003d\u003e (c1(3) \u003d\u003e ((ck1(\"b\") \u003d false) \u003d\u003e pre_(ck1\"a\")))))))","legal function application obligation:let aHashCode:(seq of (char) -\u003e seq of (char)) \u003d (lambda [x:seq of (char)] \u0026 (if (x \u003d \"\")\nthen \"\"\nelse (FSequence`Take)[char](1)(x))), h2:map (seq of (char)) to (map (seq of (char)) to (int)) \u003d (FHashtable`PutAll)[seq of (char), int]({|-\u003e})(aHashCode)({\"a\" |-\u003e 1, \"b\" |-\u003e 2, \"c\" |-\u003e 3}), h3:map (int) to (map (int) to (seq of (char))) \u003d (FHashtable`Clear)[int, seq of (char)](), deletedh2:map (seq of (char)) to (map (seq of (char)) to (int)) \u003d (FHashtable`Remove)[seq of (char), int](h2)(aHashCode)(\"b\"), c1:(int +\u003e bool) \u003d (FHashtable`Contains)[seq of (char), int](deletedh2), ck1:(seq of (char) +\u003e bool) \u003d (FHashtable`ContainsKey)[seq of (char), int](deletedh2) in ((h3 \u003d {|-\u003e}) \u003d\u003e (((FHashtable`Get)[seq of (char), int](deletedh2)(aHashCode)(\"b\") \u003d nil) \u003d\u003e ((c1(2) \u003d false) \u003d\u003e (c1(1) \u003d\u003e (c1(3) \u003d\u003e ((ck1(\"b\") \u003d false) \u003d\u003e (ck1(\"a\") \u003d\u003e pre_(ck1\"c\"))))))))","legal function application obligation:pre_(put({|-\u003e})(aHashCode)(1)\"Sahara\")","legal function application obligation:pre_(put({|-\u003e})(aHashCode)1)","legal function application obligation:pre_(put({|-\u003e})aHashCode)","legal function application obligation:pre_(put{|-\u003e})","legal function application obligation:pre_(put(p1)(aHashCode)(2)\"Bush\")","legal function application obligation:pre_(put(p1)(aHashCode)2)","legal function application obligation:pre_(put(p1)aHashCode)","legal function application obligation:pre_(putp1)","legal function application obligation:pre_(put(p2)(aHashCode)(2)\"Sato\")","legal function application obligation:pre_(put(p2)(aHashCode)2)","legal function application obligation:pre_(put(p2)aHashCode)","legal function application obligation:pre_(putp2)","legal function application obligation:pre_(put(p3)(aHashCode)(14)\"Sakoh\")","legal function application obligation:pre_(put(p3)(aHashCode)14)","legal function application obligation:pre_(put(p3)aHashCode)","legal function application obligation:pre_(putp3)","legal function application obligation:pre_((FHashtable`Get)[int, seq of (char)](p4)aHashCode)","legal function application obligation:let aHashCode:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), put:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e (seq of (char) +\u003e map (int) to (map (int) to (seq of (char))))))) \u003d (FHashtable`Put)[int, seq of (char)], p1:map (int) to (map (int) to (seq of (char))) \u003d put({|-\u003e})(aHashCode)(1)(\"Sahara\"), p2:map (int) to (map (int) to (seq of (char))) \u003d put(p1)(aHashCode)(2)(\"Bush\"), p3:map (int) to (map (int) to (seq of (char))) \u003d put(p2)(aHashCode)(2)(\"Sato\"), p4:map (int) to (map (int) to (seq of (char))) \u003d put(p3)(aHashCode)(14)(\"Sakoh\"), get:((int +\u003e int) +\u003e (int +\u003e [seq of (char)])) \u003d (FHashtable`Get)[int, seq of (char)](p4), g:(int +\u003e [seq of (char)]) \u003d (FHashtable`Get)[int, seq of (char)](p4)(aHashCode) in pre_(get(aHashCode)1)","legal function application obligation:let aHashCode:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), put:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e (seq of (char) +\u003e map (int) to (map (int) to (seq of (char))))))) \u003d (FHashtable`Put)[int, seq of (char)], p1:map (int) to (map (int) to (seq of (char))) \u003d put({|-\u003e})(aHashCode)(1)(\"Sahara\"), p2:map (int) to (map (int) to (seq of (char))) \u003d put(p1)(aHashCode)(2)(\"Bush\"), p3:map (int) to (map (int) to (seq of (char))) \u003d put(p2)(aHashCode)(2)(\"Sato\"), p4:map (int) to (map (int) to (seq of (char))) \u003d put(p3)(aHashCode)(14)(\"Sakoh\"), get:((int +\u003e int) +\u003e (int +\u003e [seq of (char)])) \u003d (FHashtable`Get)[int, seq of (char)](p4), g:(int +\u003e [seq of (char)]) \u003d (FHashtable`Get)[int, seq of (char)](p4)(aHashCode) in pre_(getaHashCode)","legal function application obligation:let aHashCode:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), put:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e (seq of (char) +\u003e map (int) to (map (int) to (seq of (char))))))) \u003d (FHashtable`Put)[int, seq of (char)], p1:map (int) to (map (int) to (seq of (char))) \u003d put({|-\u003e})(aHashCode)(1)(\"Sahara\"), p2:map (int) to (map (int) to (seq of (char))) \u003d put(p1)(aHashCode)(2)(\"Bush\"), p3:map (int) to (map (int) to (seq of (char))) \u003d put(p2)(aHashCode)(2)(\"Sato\"), p4:map (int) to (map (int) to (seq of (char))) \u003d put(p3)(aHashCode)(14)(\"Sakoh\"), get:((int +\u003e int) +\u003e (int +\u003e [seq of (char)])) \u003d (FHashtable`Get)[int, seq of (char)](p4), g:(int +\u003e [seq of (char)]) \u003d (FHashtable`Get)[int, seq of (char)](p4)(aHashCode) in ((get(aHashCode)(1) \u003d \"Sahara\") \u003d\u003e pre_(get(aHashCode)2))","legal function application obligation:let aHashCode:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), put:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e (seq of (char) +\u003e map (int) to (map (int) to (seq of (char))))))) \u003d (FHashtable`Put)[int, seq of (char)], p1:map (int) to (map (int) to (seq of (char))) \u003d put({|-\u003e})(aHashCode)(1)(\"Sahara\"), p2:map (int) to (map (int) to (seq of (char))) \u003d put(p1)(aHashCode)(2)(\"Bush\"), p3:map (int) to (map (int) to (seq of (char))) \u003d put(p2)(aHashCode)(2)(\"Sato\"), p4:map (int) to (map (int) to (seq of (char))) \u003d put(p3)(aHashCode)(14)(\"Sakoh\"), get:((int +\u003e int) +\u003e (int +\u003e [seq of (char)])) \u003d (FHashtable`Get)[int, seq of (char)](p4), g:(int +\u003e [seq of (char)]) \u003d (FHashtable`Get)[int, seq of (char)](p4)(aHashCode) in ((get(aHashCode)(1) \u003d \"Sahara\") \u003d\u003e pre_(getaHashCode))","legal function application obligation:let aHashCode:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), put:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e (seq of (char) +\u003e map (int) to (map (int) to (seq of (char))))))) \u003d (FHashtable`Put)[int, seq of (char)], p1:map (int) to (map (int) to (seq of (char))) \u003d put({|-\u003e})(aHashCode)(1)(\"Sahara\"), p2:map (int) to (map (int) to (seq of (char))) \u003d put(p1)(aHashCode)(2)(\"Bush\"), p3:map (int) to (map (int) to (seq of (char))) \u003d put(p2)(aHashCode)(2)(\"Sato\"), p4:map (int) to (map (int) to (seq of (char))) \u003d put(p3)(aHashCode)(14)(\"Sakoh\"), get:((int +\u003e int) +\u003e (int +\u003e [seq of (char)])) \u003d (FHashtable`Get)[int, seq of (char)](p4), g:(int +\u003e [seq of (char)]) \u003d (FHashtable`Get)[int, seq of (char)](p4)(aHashCode) in ((get(aHashCode)(1) \u003d \"Sahara\") \u003d\u003e ((get(aHashCode)(2) \u003d \"Sato\") \u003d\u003e pre_(get(aHashCode)14)))","legal function application obligation:let aHashCode:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), put:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e (seq of (char) +\u003e map (int) to (map (int) to (seq of (char))))))) \u003d (FHashtable`Put)[int, seq of (char)], p1:map (int) to (map (int) to (seq of (char))) \u003d put({|-\u003e})(aHashCode)(1)(\"Sahara\"), p2:map (int) to (map (int) to (seq of (char))) \u003d put(p1)(aHashCode)(2)(\"Bush\"), p3:map (int) to (map (int) to (seq of (char))) \u003d put(p2)(aHashCode)(2)(\"Sato\"), p4:map (int) to (map (int) to (seq of (char))) \u003d put(p3)(aHashCode)(14)(\"Sakoh\"), get:((int +\u003e int) +\u003e (int +\u003e [seq of (char)])) \u003d (FHashtable`Get)[int, seq of (char)](p4), g:(int +\u003e [seq of (char)]) \u003d (FHashtable`Get)[int, seq of (char)](p4)(aHashCode) in ((get(aHashCode)(1) \u003d \"Sahara\") \u003d\u003e ((get(aHashCode)(2) \u003d \"Sato\") \u003d\u003e pre_(getaHashCode)))","legal function application obligation:let aHashCode:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), put:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e (seq of (char) +\u003e map (int) to (map (int) to (seq of (char))))))) \u003d (FHashtable`Put)[int, seq of (char)], p1:map (int) to (map (int) to (seq of (char))) \u003d put({|-\u003e})(aHashCode)(1)(\"Sahara\"), p2:map (int) to (map (int) to (seq of (char))) \u003d put(p1)(aHashCode)(2)(\"Bush\"), p3:map (int) to (map (int) to (seq of (char))) \u003d put(p2)(aHashCode)(2)(\"Sato\"), p4:map (int) to (map (int) to (seq of (char))) \u003d put(p3)(aHashCode)(14)(\"Sakoh\"), get:((int +\u003e int) +\u003e (int +\u003e [seq of (char)])) \u003d (FHashtable`Get)[int, seq of (char)](p4), g:(int +\u003e [seq of (char)]) \u003d (FHashtable`Get)[int, seq of (char)](p4)(aHashCode) in ((get(aHashCode)(1) \u003d \"Sahara\") \u003d\u003e ((get(aHashCode)(2) \u003d \"Sato\") \u003d\u003e ((get(aHashCode)(14) \u003d \"Sakoh\") \u003d\u003e pre_(get(aHashCode)99))))","legal function application obligation:let aHashCode:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), put:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e (seq of (char) +\u003e map (int) to (map (int) to (seq of (char))))))) \u003d (FHashtable`Put)[int, seq of (char)], p1:map (int) to (map (int) to (seq of (char))) \u003d put({|-\u003e})(aHashCode)(1)(\"Sahara\"), p2:map (int) to (map (int) to (seq of (char))) \u003d put(p1)(aHashCode)(2)(\"Bush\"), p3:map (int) to (map (int) to (seq of (char))) \u003d put(p2)(aHashCode)(2)(\"Sato\"), p4:map (int) to (map (int) to (seq of (char))) \u003d put(p3)(aHashCode)(14)(\"Sakoh\"), get:((int +\u003e int) +\u003e (int +\u003e [seq of (char)])) \u003d (FHashtable`Get)[int, seq of (char)](p4), g:(int +\u003e [seq of (char)]) \u003d (FHashtable`Get)[int, seq of (char)](p4)(aHashCode) in ((get(aHashCode)(1) \u003d \"Sahara\") \u003d\u003e ((get(aHashCode)(2) \u003d \"Sato\") \u003d\u003e ((get(aHashCode)(14) \u003d \"Sakoh\") \u003d\u003e pre_(getaHashCode))))","legal function application obligation:let aHashCode:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), put:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e (seq of (char) +\u003e map (int) to (map (int) to (seq of (char))))))) \u003d (FHashtable`Put)[int, seq of (char)], p1:map (int) to (map (int) to (seq of (char))) \u003d put({|-\u003e})(aHashCode)(1)(\"Sahara\"), p2:map (int) to (map (int) to (seq of (char))) \u003d put(p1)(aHashCode)(2)(\"Bush\"), p3:map (int) to (map (int) to (seq of (char))) \u003d put(p2)(aHashCode)(2)(\"Sato\"), p4:map (int) to (map (int) to (seq of (char))) \u003d put(p3)(aHashCode)(14)(\"Sakoh\"), get:((int +\u003e int) +\u003e (int +\u003e [seq of (char)])) \u003d (FHashtable`Get)[int, seq of (char)](p4), g:(int +\u003e [seq of (char)]) \u003d (FHashtable`Get)[int, seq of (char)](p4)(aHashCode) in ((get(aHashCode)(1) \u003d \"Sahara\") \u003d\u003e ((get(aHashCode)(2) \u003d \"Sato\") \u003d\u003e ((get(aHashCode)(14) \u003d \"Sakoh\") \u003d\u003e ((get(aHashCode)(99) \u003d nil) \u003d\u003e pre_((FSequence`Fmap)[int, seq of (char)](g)[1, 14])))))","type compatibility obligation:let aHashCode:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), put:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e (seq of (char) +\u003e map (int) to (map (int) to (seq of (char))))))) \u003d (FHashtable`Put)[int, seq of (char)], p1:map (int) to (map (int) to (seq of (char))) \u003d put({|-\u003e})(aHashCode)(1)(\"Sahara\"), p2:map (int) to (map (int) to (seq of (char))) \u003d put(p1)(aHashCode)(2)(\"Bush\"), p3:map (int) to (map (int) to (seq of (char))) \u003d put(p2)(aHashCode)(2)(\"Sato\"), p4:map (int) to (map (int) to (seq of (char))) \u003d put(p3)(aHashCode)(14)(\"Sakoh\"), get:((int +\u003e int) +\u003e (int +\u003e [seq of (char)])) \u003d (FHashtable`Get)[int, seq of (char)](p4), g:(int +\u003e [seq of (char)]) \u003d (FHashtable`Get)[int, seq of (char)](p4)(aHashCode) in ((get(aHashCode)(1) \u003d \"Sahara\") \u003d\u003e ((get(aHashCode)(2) \u003d \"Sato\") \u003d\u003e ((get(aHashCode)(14) \u003d \"Sakoh\") \u003d\u003e ((get(aHashCode)(99) \u003d nil) \u003d\u003e is_(g, (int +\u003e seq of (char)))))))","legal function application obligation:let aHashCode:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), put:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e (seq of (char) +\u003e map (int) to (map (int) to (seq of (char))))))) \u003d (FHashtable`Put)[int, seq of (char)], p1:map (int) to (map (int) to (seq of (char))) \u003d put({|-\u003e})(aHashCode)(1)(\"Sahara\"), p2:map (int) to (map (int) to (seq of (char))) \u003d put(p1)(aHashCode)(2)(\"Bush\"), p3:map (int) to (map (int) to (seq of (char))) \u003d put(p2)(aHashCode)(2)(\"Sato\"), p4:map (int) to (map (int) to (seq of (char))) \u003d put(p3)(aHashCode)(14)(\"Sakoh\"), get:((int +\u003e int) +\u003e (int +\u003e [seq of (char)])) \u003d (FHashtable`Get)[int, seq of (char)](p4), g:(int +\u003e [seq of (char)]) \u003d (FHashtable`Get)[int, seq of (char)](p4)(aHashCode) in ((get(aHashCode)(1) \u003d \"Sahara\") \u003d\u003e ((get(aHashCode)(2) \u003d \"Sato\") \u003d\u003e ((get(aHashCode)(14) \u003d \"Sakoh\") \u003d\u003e ((get(aHashCode)(99) \u003d nil) \u003d\u003e (((FSequence`Fmap)[int, seq of (char)](g)([1, 14]) \u003d [\"Sahara\", \"Sakoh\"]) \u003d\u003e pre_((FSequence`Fmap)[int, seq of (char)](g)[1, 2]))))))","type compatibility obligation:let aHashCode:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), put:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e (seq of (char) +\u003e map (int) to (map (int) to (seq of (char))))))) \u003d (FHashtable`Put)[int, seq of (char)], p1:map (int) to (map (int) to (seq of (char))) \u003d put({|-\u003e})(aHashCode)(1)(\"Sahara\"), p2:map (int) to (map (int) to (seq of (char))) \u003d put(p1)(aHashCode)(2)(\"Bush\"), p3:map (int) to (map (int) to (seq of (char))) \u003d put(p2)(aHashCode)(2)(\"Sato\"), p4:map (int) to (map (int) to (seq of (char))) \u003d put(p3)(aHashCode)(14)(\"Sakoh\"), get:((int +\u003e int) +\u003e (int +\u003e [seq of (char)])) \u003d (FHashtable`Get)[int, seq of (char)](p4), g:(int +\u003e [seq of (char)]) \u003d (FHashtable`Get)[int, seq of (char)](p4)(aHashCode) in ((get(aHashCode)(1) \u003d \"Sahara\") \u003d\u003e ((get(aHashCode)(2) \u003d \"Sato\") \u003d\u003e ((get(aHashCode)(14) \u003d \"Sakoh\") \u003d\u003e ((get(aHashCode)(99) \u003d nil) \u003d\u003e (((FSequence`Fmap)[int, seq of (char)](g)([1, 14]) \u003d [\"Sahara\", \"Sakoh\"]) \u003d\u003e is_(g, (int +\u003e seq of (char))))))))","legal function application obligation:pre_(put({|-\u003e})(aHashCode)(1)\"Sahara\")","legal function application obligation:pre_(put({|-\u003e})(aHashCode)1)","legal function application obligation:pre_(put({|-\u003e})aHashCode)","legal function application obligation:pre_(put{|-\u003e})","legal function application obligation:pre_(put(p1)(aHashCode)(2)\"Bush\")","legal function application obligation:pre_(put(p1)(aHashCode)2)","legal function application obligation:pre_(put(p1)aHashCode)","legal function application obligation:pre_(putp1)","legal function application obligation:pre_(put(p2)(aHashCode)(2)\"Sato\")","legal function application obligation:pre_(put(p2)(aHashCode)2)","legal function application obligation:pre_(put(p2)aHashCode)","legal function application obligation:pre_(putp2)","legal function application obligation:pre_(put(p3)(aHashCode)(14)\"Sakoh\")","legal function application obligation:pre_(put(p3)(aHashCode)14)","legal function application obligation:pre_(put(p3)aHashCode)","legal function application obligation:pre_(putp3)","legal function application obligation:let aHashCode:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), put:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e (seq of (char) +\u003e map (int) to (map (int) to (seq of (char))))))) \u003d (FHashtable`Put)[int, seq of (char)], p1:map (int) to (map (int) to (seq of (char))) \u003d put({|-\u003e})(aHashCode)(1)(\"Sahara\"), p2:map (int) to (map (int) to (seq of (char))) \u003d put(p1)(aHashCode)(2)(\"Bush\"), p3:map (int) to (map (int) to (seq of (char))) \u003d put(p2)(aHashCode)(2)(\"Sato\"), p4:map (int) to (map (int) to (seq of (char))) \u003d put(p3)(aHashCode)(14)(\"Sakoh\"), k:(map (int) to (map (int) to (seq of (char))) +\u003e set of (int)) \u003d (FHashtable`KeySet)[int, seq of (char)], v:(map (int) to (map (int) to (seq of (char))) +\u003e set of (seq of (char))) \u003d (FHashtable`ValueSet)[int, seq of (char)] in pre_(kp1)","legal function application obligation:let aHashCode:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), put:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e (seq of (char) +\u003e map (int) to (map (int) to (seq of (char))))))) \u003d (FHashtable`Put)[int, seq of (char)], p1:map (int) to (map (int) to (seq of (char))) \u003d put({|-\u003e})(aHashCode)(1)(\"Sahara\"), p2:map (int) to (map (int) to (seq of (char))) \u003d put(p1)(aHashCode)(2)(\"Bush\"), p3:map (int) to (map (int) to (seq of (char))) \u003d put(p2)(aHashCode)(2)(\"Sato\"), p4:map (int) to (map (int) to (seq of (char))) \u003d put(p3)(aHashCode)(14)(\"Sakoh\"), k:(map (int) to (map (int) to (seq of (char))) +\u003e set of (int)) \u003d (FHashtable`KeySet)[int, seq of (char)], v:(map (int) to (map (int) to (seq of (char))) +\u003e set of (seq of (char))) \u003d (FHashtable`ValueSet)[int, seq of (char)] in ((k(p1) \u003d {1}) \u003d\u003e pre_(vp1))","legal function application obligation:let aHashCode:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), put:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e (seq of (char) +\u003e map (int) to (map (int) to (seq of (char))))))) \u003d (FHashtable`Put)[int, seq of (char)], p1:map (int) to (map (int) to (seq of (char))) \u003d put({|-\u003e})(aHashCode)(1)(\"Sahara\"), p2:map (int) to (map (int) to (seq of (char))) \u003d put(p1)(aHashCode)(2)(\"Bush\"), p3:map (int) to (map (int) to (seq of (char))) \u003d put(p2)(aHashCode)(2)(\"Sato\"), p4:map (int) to (map (int) to (seq of (char))) \u003d put(p3)(aHashCode)(14)(\"Sakoh\"), k:(map (int) to (map (int) to (seq of (char))) +\u003e set of (int)) \u003d (FHashtable`KeySet)[int, seq of (char)], v:(map (int) to (map (int) to (seq of (char))) +\u003e set of (seq of (char))) \u003d (FHashtable`ValueSet)[int, seq of (char)] in ((k(p1) \u003d {1}) \u003d\u003e ((v(p1) \u003d {\"Sahara\"}) \u003d\u003e pre_(kp2)))","legal function application obligation:let aHashCode:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), put:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e (seq of (char) +\u003e map (int) to (map (int) to (seq of (char))))))) \u003d (FHashtable`Put)[int, seq of (char)], p1:map (int) to (map (int) to (seq of (char))) \u003d put({|-\u003e})(aHashCode)(1)(\"Sahara\"), p2:map (int) to (map (int) to (seq of (char))) \u003d put(p1)(aHashCode)(2)(\"Bush\"), p3:map (int) to (map (int) to (seq of (char))) \u003d put(p2)(aHashCode)(2)(\"Sato\"), p4:map (int) to (map (int) to (seq of (char))) \u003d put(p3)(aHashCode)(14)(\"Sakoh\"), k:(map (int) to (map (int) to (seq of (char))) +\u003e set of (int)) \u003d (FHashtable`KeySet)[int, seq of (char)], v:(map (int) to (map (int) to (seq of (char))) +\u003e set of (seq of (char))) \u003d (FHashtable`ValueSet)[int, seq of (char)] in ((k(p1) \u003d {1}) \u003d\u003e ((v(p1) \u003d {\"Sahara\"}) \u003d\u003e ((k(p2) \u003d {1, 2}) \u003d\u003e pre_(vp2))))","legal function application obligation:let aHashCode:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), put:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e (seq of (char) +\u003e map (int) to (map (int) to (seq of (char))))))) \u003d (FHashtable`Put)[int, seq of (char)], p1:map (int) to (map (int) to (seq of (char))) \u003d put({|-\u003e})(aHashCode)(1)(\"Sahara\"), p2:map (int) to (map (int) to (seq of (char))) \u003d put(p1)(aHashCode)(2)(\"Bush\"), p3:map (int) to (map (int) to (seq of (char))) \u003d put(p2)(aHashCode)(2)(\"Sato\"), p4:map (int) to (map (int) to (seq of (char))) \u003d put(p3)(aHashCode)(14)(\"Sakoh\"), k:(map (int) to (map (int) to (seq of (char))) +\u003e set of (int)) \u003d (FHashtable`KeySet)[int, seq of (char)], v:(map (int) to (map (int) to (seq of (char))) +\u003e set of (seq of (char))) \u003d (FHashtable`ValueSet)[int, seq of (char)] in ((k(p1) \u003d {1}) \u003d\u003e ((v(p1) \u003d {\"Sahara\"}) \u003d\u003e ((k(p2) \u003d {1, 2}) \u003d\u003e ((v(p2) \u003d {\"Sahara\", \"Bush\"}) \u003d\u003e pre_(kp4)))))","legal function application obligation:let aHashCode:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), put:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e (seq of (char) +\u003e map (int) to (map (int) to (seq of (char))))))) \u003d (FHashtable`Put)[int, seq of (char)], p1:map (int) to (map (int) to (seq of (char))) \u003d put({|-\u003e})(aHashCode)(1)(\"Sahara\"), p2:map (int) to (map (int) to (seq of (char))) \u003d put(p1)(aHashCode)(2)(\"Bush\"), p3:map (int) to (map (int) to (seq of (char))) \u003d put(p2)(aHashCode)(2)(\"Sato\"), p4:map (int) to (map (int) to (seq of (char))) \u003d put(p3)(aHashCode)(14)(\"Sakoh\"), k:(map (int) to (map (int) to (seq of (char))) +\u003e set of (int)) \u003d (FHashtable`KeySet)[int, seq of (char)], v:(map (int) to (map (int) to (seq of (char))) +\u003e set of (seq of (char))) \u003d (FHashtable`ValueSet)[int, seq of (char)] in ((k(p1) \u003d {1}) \u003d\u003e ((v(p1) \u003d {\"Sahara\"}) \u003d\u003e ((k(p2) \u003d {1, 2}) \u003d\u003e ((v(p2) \u003d {\"Sahara\", \"Bush\"}) \u003d\u003e ((k(p4) \u003d {1, 2, 14}) \u003d\u003e pre_(vp4))))))","legal function application obligation:pre_((FHashtable`PutAll)[int, seq of (char)]({|-\u003e})(aHashCode1){1 |-\u003e \"SaharaShin\", 2 |-\u003e \"SatoKei\", 14 |-\u003e \"SakohHiroshi\", 27 |-\u003e \"NishikawaNoriko\"})","legal function application obligation:pre_((FHashtable`PutAll)[int, seq of (char)]({|-\u003e})aHashCode1)","enumeration map injectivity obligation:(forall m1, m2 in set {{1 |-\u003e \"SaharaShin\"}, {2 |-\u003e \"SatoKei\"}, {14 |-\u003e \"SakohHiroshi\"}, {27 |-\u003e \"NishikawaNoriko\"}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","legal function application obligation:pre_((FHashtable`Remove)[int, seq of (char)](h1)(aHashCode1)14)","legal function application obligation:pre_((FHashtable`Remove)[int, seq of (char)](h1)aHashCode1)","legal function application obligation:pre_((FHashtable`PutAll)[int, seq of (char)]({|-\u003e})(aHashCode1){1 |-\u003e \"SaharaShin\", 2 |-\u003e \"SatoKei\", 14 |-\u003e \"SakohHiroshi\"})","legal function application obligation:pre_((FHashtable`PutAll)[int, seq of (char)]({|-\u003e})aHashCode1)","enumeration map injectivity obligation:(forall m1, m2 in set {{1 |-\u003e \"SaharaShin\"}, {2 |-\u003e \"SatoKei\"}, {14 |-\u003e \"SakohHiroshi\"}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","legal function application obligation:pre_(remove(h1)(aHashCode1)1)","legal function application obligation:pre_(remove(h1)aHashCode1)","legal function application obligation:pre_(removeh1)","legal function application obligation:pre_(remove(h2)(aHashCode1)2)","legal function application obligation:pre_(remove(h2)aHashCode1)","legal function application obligation:pre_(removeh2)","legal function application obligation:pre_(remove(h3)(aHashCode1)14)","legal function application obligation:pre_(remove(h3)aHashCode1)","legal function application obligation:pre_(removeh3)","legal function application obligation:let aHashCode1:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), remove:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e map (int) to (map (int) to (seq of (char)))))) \u003d (FHashtable`Remove)[int, seq of (char)], h1:map (int) to (map (int) to (seq of (char))) \u003d (FHashtable`PutAll)[int, seq of (char)]({|-\u003e})(aHashCode1)({1 |-\u003e \"SaharaShin\", 2 |-\u003e \"SatoKei\", 14 |-\u003e \"SakohHiroshi\"}), h2:map (int) to (map (int) to (seq of (char))) \u003d remove(h1)(aHashCode1)(1), h3:map (int) to (map (int) to (seq of (char))) \u003d remove(h2)(aHashCode1)(2), h4:map (int) to (map (int) to (seq of (char))) \u003d remove(h3)(aHashCode1)(14), isempty:(map (int) to (map (int) to (seq of (char))) +\u003e bool) \u003d (FHashtable`IsEmpty)[int, seq of (char)], size:(map (int) to (map (int) to (seq of (char))) +\u003e nat) \u003d (FHashtable`Size)[int, seq of (char)] in pre_(isemptyh4)","legal function application obligation:let aHashCode1:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), remove:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e map (int) to (map (int) to (seq of (char)))))) \u003d (FHashtable`Remove)[int, seq of (char)], h1:map (int) to (map (int) to (seq of (char))) \u003d (FHashtable`PutAll)[int, seq of (char)]({|-\u003e})(aHashCode1)({1 |-\u003e \"SaharaShin\", 2 |-\u003e \"SatoKei\", 14 |-\u003e \"SakohHiroshi\"}), h2:map (int) to (map (int) to (seq of (char))) \u003d remove(h1)(aHashCode1)(1), h3:map (int) to (map (int) to (seq of (char))) \u003d remove(h2)(aHashCode1)(2), h4:map (int) to (map (int) to (seq of (char))) \u003d remove(h3)(aHashCode1)(14), isempty:(map (int) to (map (int) to (seq of (char))) +\u003e bool) \u003d (FHashtable`IsEmpty)[int, seq of (char)], size:(map (int) to (map (int) to (seq of (char))) +\u003e nat) \u003d (FHashtable`Size)[int, seq of (char)] in (isempty(h4) \u003d\u003e pre_(sizeh4))","legal function application obligation:let aHashCode1:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), remove:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e map (int) to (map (int) to (seq of (char)))))) \u003d (FHashtable`Remove)[int, seq of (char)], h1:map (int) to (map (int) to (seq of (char))) \u003d (FHashtable`PutAll)[int, seq of (char)]({|-\u003e})(aHashCode1)({1 |-\u003e \"SaharaShin\", 2 |-\u003e \"SatoKei\", 14 |-\u003e \"SakohHiroshi\"}), h2:map (int) to (map (int) to (seq of (char))) \u003d remove(h1)(aHashCode1)(1), h3:map (int) to (map (int) to (seq of (char))) \u003d remove(h2)(aHashCode1)(2), h4:map (int) to (map (int) to (seq of (char))) \u003d remove(h3)(aHashCode1)(14), isempty:(map (int) to (map (int) to (seq of (char))) +\u003e bool) \u003d (FHashtable`IsEmpty)[int, seq of (char)], size:(map (int) to (map (int) to (seq of (char))) +\u003e nat) \u003d (FHashtable`Size)[int, seq of (char)] in (isempty(h4) \u003d\u003e ((size(h4) \u003d 0) \u003d\u003e pre_(isemptyh3)))","legal function application obligation:let aHashCode1:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), remove:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e map (int) to (map (int) to (seq of (char)))))) \u003d (FHashtable`Remove)[int, seq of (char)], h1:map (int) to (map (int) to (seq of (char))) \u003d (FHashtable`PutAll)[int, seq of (char)]({|-\u003e})(aHashCode1)({1 |-\u003e \"SaharaShin\", 2 |-\u003e \"SatoKei\", 14 |-\u003e \"SakohHiroshi\"}), h2:map (int) to (map (int) to (seq of (char))) \u003d remove(h1)(aHashCode1)(1), h3:map (int) to (map (int) to (seq of (char))) \u003d remove(h2)(aHashCode1)(2), h4:map (int) to (map (int) to (seq of (char))) \u003d remove(h3)(aHashCode1)(14), isempty:(map (int) to (map (int) to (seq of (char))) +\u003e bool) \u003d (FHashtable`IsEmpty)[int, seq of (char)], size:(map (int) to (map (int) to (seq of (char))) +\u003e nat) \u003d (FHashtable`Size)[int, seq of (char)] in (isempty(h4) \u003d\u003e ((size(h4) \u003d 0) \u003d\u003e ((isempty(h3) \u003d false) \u003d\u003e pre_(sizeh3))))","legal function application obligation:let aHashCode1:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), remove:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e map (int) to (map (int) to (seq of (char)))))) \u003d (FHashtable`Remove)[int, seq of (char)], h1:map (int) to (map (int) to (seq of (char))) \u003d (FHashtable`PutAll)[int, seq of (char)]({|-\u003e})(aHashCode1)({1 |-\u003e \"SaharaShin\", 2 |-\u003e \"SatoKei\", 14 |-\u003e \"SakohHiroshi\"}), h2:map (int) to (map (int) to (seq of (char))) \u003d remove(h1)(aHashCode1)(1), h3:map (int) to (map (int) to (seq of (char))) \u003d remove(h2)(aHashCode1)(2), h4:map (int) to (map (int) to (seq of (char))) \u003d remove(h3)(aHashCode1)(14), isempty:(map (int) to (map (int) to (seq of (char))) +\u003e bool) \u003d (FHashtable`IsEmpty)[int, seq of (char)], size:(map (int) to (map (int) to (seq of (char))) +\u003e nat) \u003d (FHashtable`Size)[int, seq of (char)] in (isempty(h4) \u003d\u003e ((size(h4) \u003d 0) \u003d\u003e ((isempty(h3) \u003d false) \u003d\u003e ((size(h3) \u003d 1) \u003d\u003e pre_(sizeh2)))))","legal function application obligation:let aHashCode1:(int -\u003e int) \u003d (lambda [x:int] \u0026 (x mod 13)), remove:(map (int) to (map (int) to (seq of (char))) +\u003e ((int +\u003e int) +\u003e (int +\u003e map (int) to (map (int) to (seq of (char)))))) \u003d (FHashtable`Remove)[int, seq of (char)], h1:map (int) to (map (int) to (seq of (char))) \u003d (FHashtable`PutAll)[int, seq of (char)]({|-\u003e})(aHashCode1)({1 |-\u003e \"SaharaShin\", 2 |-\u003e \"SatoKei\", 14 |-\u003e \"SakohHiroshi\"}), h2:map (int) to (map (int) to (seq of (char))) \u003d remove(h1)(aHashCode1)(1), h3:map (int) to (map (int) to (seq of (char))) \u003d remove(h2)(aHashCode1)(2), h4:map (int) to (map (int) to (seq of (char))) \u003d remove(h3)(aHashCode1)(14), isempty:(map (int) to (map (int) to (seq of (char))) +\u003e bool) \u003d (FHashtable`IsEmpty)[int, seq of (char)], size:(map (int) to (map (int) to (seq of (char))) +\u003e nat) \u003d (FHashtable`Size)[int, seq of (char)] in (isempty(h4) \u003d\u003e ((size(h4) \u003d 0) \u003d\u003e ((isempty(h3) \u003d false) \u003d\u003e ((size(h3) \u003d 1) \u003d\u003e ((size(h2) \u003d 2) \u003d\u003e pre_(sizeh1))))))","legal function application obligation:(forall akey:Object, aValue:Object \u0026 pre_((akey.hashCode)))","legal map application obligation:(forall akey:Object, aValue:Object \u0026 (hashcode in set (dom buckets)))","map compatible obligation:(forall akey:Object, aValue:Object \u0026 (forall ldom1 in set (dom buckets), rdom2 in set (dom {hashcode |-\u003e {akey |-\u003e aValue}}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (buckets(ldom1) \u003d {hashcode |-\u003e {akey |-\u003e aValue}}(rdom2)))))","legal map application obligation:(forall aContents:Contents \u0026 (key in set (dom aContents)))","legal function application obligation:(forall key:Object \u0026 pre_((key.hashCode)))","legal map application obligation:(forall key:Object \u0026 (hashcode in set (dom buckets)))","legal function application obligation:(forall key:Object \u0026 pre_((key.equals)aKey))","legal map application obligation:(forall key:Object \u0026 (aKey in set (dom aContents)))","legal function application obligation:(forall key:Object \u0026 pre_((key.hashCode)))","legal map application obligation:(forall key:Object \u0026 (hashcode in set (dom buckets)))","legal map application obligation:(forall anObject:Object \u0026 let buckets:Bucket \u003d (self.getBuckets)() in (forall hashcode in set (dom buckets) \u0026 (hashcode in set (dom buckets))))","legal function application obligation:(forall anObject:Object \u0026 let buckets:Bucket \u003d (self.getBuckets)() in (forall hashcode in set (dom buckets) \u0026 let aContents:Contents \u003d buckets(hashcode) in (forall key in set (dom aContents) \u0026 pre_((aContents(key).equals)anObject))))","legal map application obligation:(forall anObject:Object \u0026 let buckets:Bucket \u003d (self.getBuckets)() in (forall hashcode in set (dom buckets) \u0026 let aContents:Contents \u003d buckets(hashcode) in (forall key in set (dom aContents) \u0026 (key in set (dom aContents)))))","legal map application obligation:(forall aKey:Object \u0026 let buckets:Bucket \u003d (self.getBuckets)() in (forall hashcode in set (dom buckets) \u0026 (hashcode in set (dom buckets))))","legal function application obligation:(forall aKey:Object \u0026 let buckets:Bucket \u003d (self.getBuckets)() in (forall hashcode in set (dom buckets) \u0026 (forall key in set (dom buckets(hashcode)) \u0026 pre_((aKey.equals)key))))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aKey:@T1, aValue:@T2 \u0026 pre_(aHashCodeaKey))","legal map application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aKey:@T1, aValue:@T2 \u0026 let hashcode:@T1 \u003d aHashCode(aKey) in ((hashcode in set (dom aHashtable)) \u003d\u003e (hashcode in set (dom aHashtable))))","map compatible obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aKey:@T1, aValue:@T2 \u0026 let hashcode:@T1 \u003d aHashCode(aKey) in ((not (hashcode in set (dom aHashtable))) \u003d\u003e (forall ldom1 in set (dom aHashtable), rdom2 in set (dom {hashcode |-\u003e {aKey |-\u003e aValue}}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (aHashtable(ldom1) \u003d {hashcode |-\u003e {aKey |-\u003e aValue}}(rdom2))))))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aMap:map (@T1) to (@T2) \u0026 pre_((PutAllAux)[@T1, @T2](aHashtable)(aHashCode)(aMap)(dom aMap)))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aMap:map (@T1) to (@T2) \u0026 pre_((PutAllAux)[@T1, @T2](aHashtable)(aHashCode)aMap))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aMap:map (@T1) to (@T2) \u0026 pre_((PutAllAux)[@T1, @T2](aHashtable)aHashCode))","let be st existence obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aMap:map (@T1) to (@T2), aKeySet:set of (@T1) \u0026 ((not (aKeySet \u003d {})) \u003d\u003e (exists aKey in set aKeySet \u0026 true)))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aMap:map (@T1) to (@T2), aKeySet:set of (@T1) \u0026 ((not (aKeySet \u003d {})) \u003d\u003e (forall aKey in set aKeySet \u0026 pre_((Put)[@T1, @T2](aHashtable)(aHashCode)(aKey)aMap(aKey)))))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aMap:map (@T1) to (@T2), aKeySet:set of (@T1) \u0026 ((not (aKeySet \u003d {})) \u003d\u003e (forall aKey in set aKeySet \u0026 pre_((Put)[@T1, @T2](aHashtable)(aHashCode)aKey))))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aMap:map (@T1) to (@T2), aKeySet:set of (@T1) \u0026 ((not (aKeySet \u003d {})) \u003d\u003e (forall aKey in set aKeySet \u0026 pre_((Put)[@T1, @T2](aHashtable)aHashCode))))","legal map application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aMap:map (@T1) to (@T2), aKeySet:set of (@T1) \u0026 ((not (aKeySet \u003d {})) \u003d\u003e (forall aKey in set aKeySet \u0026 (aKey in set (dom aMap)))))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aMap:map (@T1) to (@T2), aKeySet:set of (@T1) \u0026 ((not (aKeySet \u003d {})) \u003d\u003e (forall aKey in set aKeySet \u0026 let newHashtable:map (@T1) to (map (@T1) to (@T2)) \u003d (Put)[@T1, @T2](aHashtable)(aHashCode)(aKey)(aMap(aKey)) in pre_((PutAllAux)[@T1, @T2](newHashtable)(aHashCode)(aMap)(aKeySet \\ {aKey})))))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aMap:map (@T1) to (@T2), aKeySet:set of (@T1) \u0026 ((not (aKeySet \u003d {})) \u003d\u003e (forall aKey in set aKeySet \u0026 let newHashtable:map (@T1) to (map (@T1) to (@T2)) \u003d (Put)[@T1, @T2](aHashtable)(aHashCode)(aKey)(aMap(aKey)) in pre_((PutAllAux)[@T1, @T2](newHashtable)(aHashCode)aMap))))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aMap:map (@T1) to (@T2), aKeySet:set of (@T1) \u0026 ((not (aKeySet \u003d {})) \u003d\u003e (forall aKey in set aKeySet \u0026 let newHashtable:map (@T1) to (map (@T1) to (@T2)) \u003d (Put)[@T1, @T2](aHashtable)(aHashCode)(aKey)(aMap(aKey)) in pre_((PutAllAux)[@T1, @T2](newHashtable)aHashCode))))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aKey:@T1 \u0026 pre_(aHashCodeaKey))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aKey:@T1 \u0026 let hashcode:@T1 \u003d aHashCode(aKey) in ((hashcode in set (dom aHashtable)) \u003d\u003e pre_((Map`Get)[@T1, @T2](aHashtable(hashcode))aKey)))","legal map application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aKey:@T1 \u0026 let hashcode:@T1 \u003d aHashCode(aKey) in ((hashcode in set (dom aHashtable)) \u003d\u003e (hashcode in set (dom aHashtable))))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aKey:@T1 \u0026 pre_(aHashCodeaKey))","comprehension map injectivity obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aKey:@T1 \u0026 let hashcode:@T1 \u003d aHashCode(aKey) in (forall m1, m2 in set {{h |-\u003e ({aKey} \u003c-: aHashtable(hashcode))} | h in set {hashcode}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4))))))","legal map application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aKey:@T1 \u0026 let hashcode:@T1 \u003d aHashCode(aKey) in (forall h in set {hashcode} \u0026 (hashcode in set (dom aHashtable))))","map compatible obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aKey:@T1 \u0026 let hashcode:@T1 \u003d aHashCode(aKey) in (forall ldom1 in set (dom {h |-\u003e ({aKey} \u003c-: aHashtable(hashcode)) | h in set {hashcode}}), rdom2 in set (dom ({hashcode} \u003c-: aHashtable)) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e ({h |-\u003e ({aKey} \u003c-: aHashtable(hashcode)) | h in set {hashcode}}(ldom1) \u003d ({hashcode} \u003c-: aHashtable)(rdom2)))))","legal function application obligation:pre_(((sq.Sum))[int][1, 2, 3, 4, 5, 6, 7, 8, 9])","legal function application obligation:((((sq.Sum))[int]([1, 2, 3, 4, 5, 6, 7, 8, 9]) \u003d 45) \u003d\u003e pre_(((sq.Sum))[int][]))","legal function application obligation:(((((sq.Sum))[int]([1, 2, 3, 4, 5, 6, 7, 8, 9]) \u003d 45) and (((sq.Sum))[int]([]) \u003d 0)) \u003d\u003e pre_Product([2, 3, 4]))","legal function application obligation:(((((sq.Sum))[int]([1, 2, 3, 4, 5, 6, 7, 8, 9]) \u003d 45) and (((sq.Sum))[int]([]) \u003d 0)) \u003d\u003e (((Sequence`Product)[int]([2, 3, 4]) \u003d 24) \u003d\u003e pre_Product([])))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(((sq.Sum))[real][0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9])","legal function application obligation:((((sq.Sum))[real]([0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]) \u003d 4.5) \u003d\u003e pre_(((sq.Sum))[real][]))","legal function application obligation:((((sq.Sum))[real]([0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]) \u003d 4.5) \u003d\u003e ((((sq.Sum))[real]([]) \u003d 0.0) \u003d\u003e pre_Product([2.0, 3.0, 4.0])))","legal function application obligation:((((sq.Sum))[real]([0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]) \u003d 4.5) \u003d\u003e ((((sq.Sum))[real]([]) \u003d 0.0) \u003d\u003e (((Sequence`Product)[real]([2.0, 3.0, 4.0]) \u003d 24.0) \u003d\u003e pre_Product([]))))","legal function application obligation:((((sq.Sum))[real]([0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]) \u003d 4.5) \u003d\u003e ((((sq.Sum))[real]([]) \u003d 0.0) \u003d\u003e (((Sequence`Product)[real]([2.0, 3.0, 4.0]) \u003d 24.0) \u003d\u003e (((Sequence`Product)[real]([]) \u003d 1.0) \u003d\u003e pre_Product([2.1, 3.2, 4.3])))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(((sq.isAscendingOrder))[int][1, 2, 4, 4, 7, 8, 8, 8])","legal function application obligation:(((sq.isAscendingOrder))[int]([1, 2, 4, 4, 7, 8, 8, 8]) \u003d\u003e pre_(((sq.isAscendingOrder))[real][1.0, 2.0, 3.0, 1.5]))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(((sq.isDescendingOrder))[int][3, 2, 2, 1, 1])","legal function application obligation:(((sq.isDescendingOrder))[int]([3, 2, 2, 1, 1]) \u003d\u003e pre_((Sequence`isDescendingTotalOrder)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))[3, 2, 2, 1, 1]))","legal function application obligation:(((sq.isDescendingOrder))[int]([3, 2, 2, 1, 1]) \u003d\u003e ((Sequence`isDescendingTotalOrder)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))([3, 2, 2, 1, 1]) \u003d\u003e pre_((Sequence`isDescendingTotalOrder)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))[3, 2, 2, 1, 2])))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:(forall x:(unresolved SequenceT05`RecordType), y:(unresolved SequenceT05`RecordType) \u0026 pre_((Sequence`isOrdered)[TestType](decideOrderFuncSeq)([(x.val), (x.str), (x.chr)])[(y.val), (y.str), (y.chr)]))","legal function application obligation:(forall x:(unresolved SequenceT05`RecordType), y:(unresolved SequenceT05`RecordType) \u0026 pre_((Sequence`isOrdered)[TestType](decideOrderFuncSeq)[(x.val), (x.str), (x.chr)]))","legal function application obligation:pre_((Sequence`sort)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))[3, 1, 5, 4])","legal function application obligation:(((Sequence`sort)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))([3, 1, 5, 4]) \u003d [1, 3, 4, 5]) \u003d\u003e pre_((Sequence`sort)[seq of (char)]((lambda [x:seq of (char), y:seq of (char)] \u0026 String`LT(x, y)))[\"12\", \"111\", \"01\"]))","legal function application obligation:(((Sequence`sort)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))([3, 1, 5, 4]) \u003d [1, 3, 4, 5]) \u003d\u003e (((Sequence`sort)[seq of (char)]((lambda [x:seq of (char), y:seq of (char)] \u0026 String`LT(x, y)))([\"12\", \"111\", \"01\"]) \u003d [\"01\", \"111\", \"12\"]) \u003d\u003e pre_((Sequence`sort)[RecordType](decideOrderFunc)[mk_RecordType(10, \"sahara\", \u0027c\u0027), mk_RecordType(10, \"sahara\", \u0027a\u0027)])))","legal function application obligation:(((Sequence`sort)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))([3, 1, 5, 4]) \u003d [1, 3, 4, 5]) \u003d\u003e (((Sequence`sort)[seq of (char)]((lambda [x:seq of (char), y:seq of (char)] \u0026 String`LT(x, y)))([\"12\", \"111\", \"01\"]) \u003d [\"01\", \"111\", \"12\"]) \u003d\u003e (((Sequence`sort)[RecordType](decideOrderFunc)([mk_RecordType(10, \"sahara\", \u0027c\u0027), mk_RecordType(10, \"sahara\", \u0027a\u0027)]) \u003d [mk_RecordType(10, \"sahara\", \u0027a\u0027), mk_RecordType(10, \"sahara\", \u0027c\u0027)]) \u003d\u003e pre_(((sq.isOrdered))[TestType](decideOrderFuncSeq)([3, \"123\", \u0027a\u0027])[3, \"123\", \u0027A\u0027]))))","legal function application obligation:(((Sequence`sort)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))([3, 1, 5, 4]) \u003d [1, 3, 4, 5]) \u003d\u003e (((Sequence`sort)[seq of (char)]((lambda [x:seq of (char), y:seq of (char)] \u0026 String`LT(x, y)))([\"12\", \"111\", \"01\"]) \u003d [\"01\", \"111\", \"12\"]) \u003d\u003e (((Sequence`sort)[RecordType](decideOrderFunc)([mk_RecordType(10, \"sahara\", \u0027c\u0027), mk_RecordType(10, \"sahara\", \u0027a\u0027)]) \u003d [mk_RecordType(10, \"sahara\", \u0027a\u0027), mk_RecordType(10, \"sahara\", \u0027c\u0027)]) \u003d\u003e pre_(((sq.isOrdered))[TestType](decideOrderFuncSeq)[3, \"123\", \u0027a\u0027]))))","legal function application obligation:(((Sequence`sort)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))([3, 1, 5, 4]) \u003d [1, 3, 4, 5]) \u003d\u003e (((Sequence`sort)[seq of (char)]((lambda [x:seq of (char), y:seq of (char)] \u0026 String`LT(x, y)))([\"12\", \"111\", \"01\"]) \u003d [\"01\", \"111\", \"12\"]) \u003d\u003e (((Sequence`sort)[RecordType](decideOrderFunc)([mk_RecordType(10, \"sahara\", \u0027c\u0027), mk_RecordType(10, \"sahara\", \u0027a\u0027)]) \u003d [mk_RecordType(10, \"sahara\", \u0027a\u0027), mk_RecordType(10, \"sahara\", \u0027c\u0027)]) \u003d\u003e pre_(((sq.isOrdered))[TestType]decideOrderFuncSeq))))","legal function application obligation:(((Sequence`sort)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))([3, 1, 5, 4]) \u003d [1, 3, 4, 5]) \u003d\u003e (((Sequence`sort)[seq of (char)]((lambda [x:seq of (char), y:seq of (char)] \u0026 String`LT(x, y)))([\"12\", \"111\", \"01\"]) \u003d [\"01\", \"111\", \"12\"]) \u003d\u003e (((Sequence`sort)[RecordType](decideOrderFunc)([mk_RecordType(10, \"sahara\", \u0027c\u0027), mk_RecordType(10, \"sahara\", \u0027a\u0027)]) \u003d [mk_RecordType(10, \"sahara\", \u0027a\u0027), mk_RecordType(10, \"sahara\", \u0027c\u0027)]) \u003d\u003e ((((sq.isOrdered))[TestType](decideOrderFuncSeq)([3, \"123\", \u0027a\u0027])([3, \"123\", \u0027A\u0027]) \u003d true) \u003d\u003e pre_(((sq.isOrdered))[TestType](decideOrderFuncSeq)([3, \"123\", \u0027a\u0027])[3, \"123\", \u00270\u0027])))))","legal function application obligation:(((Sequence`sort)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))([3, 1, 5, 4]) \u003d [1, 3, 4, 5]) \u003d\u003e (((Sequence`sort)[seq of (char)]((lambda [x:seq of (char), y:seq of (char)] \u0026 String`LT(x, y)))([\"12\", \"111\", \"01\"]) \u003d [\"01\", \"111\", \"12\"]) \u003d\u003e (((Sequence`sort)[RecordType](decideOrderFunc)([mk_RecordType(10, \"sahara\", \u0027c\u0027), mk_RecordType(10, \"sahara\", \u0027a\u0027)]) \u003d [mk_RecordType(10, \"sahara\", \u0027a\u0027), mk_RecordType(10, \"sahara\", \u0027c\u0027)]) \u003d\u003e ((((sq.isOrdered))[TestType](decideOrderFuncSeq)([3, \"123\", \u0027a\u0027])([3, \"123\", \u0027A\u0027]) \u003d true) \u003d\u003e pre_(((sq.isOrdered))[TestType](decideOrderFuncSeq)[3, \"123\", \u0027a\u0027])))))","legal function application obligation:(((Sequence`sort)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))([3, 1, 5, 4]) \u003d [1, 3, 4, 5]) \u003d\u003e (((Sequence`sort)[seq of (char)]((lambda [x:seq of (char), y:seq of (char)] \u0026 String`LT(x, y)))([\"12\", \"111\", \"01\"]) \u003d [\"01\", \"111\", \"12\"]) \u003d\u003e (((Sequence`sort)[RecordType](decideOrderFunc)([mk_RecordType(10, \"sahara\", \u0027c\u0027), mk_RecordType(10, \"sahara\", \u0027a\u0027)]) \u003d [mk_RecordType(10, \"sahara\", \u0027a\u0027), mk_RecordType(10, \"sahara\", \u0027c\u0027)]) \u003d\u003e ((((sq.isOrdered))[TestType](decideOrderFuncSeq)([3, \"123\", \u0027a\u0027])([3, \"123\", \u0027A\u0027]) \u003d true) \u003d\u003e pre_(((sq.isOrdered))[TestType]decideOrderFuncSeq)))))","legal function application obligation:(((Sequence`sort)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))([3, 1, 5, 4]) \u003d [1, 3, 4, 5]) \u003d\u003e (((Sequence`sort)[seq of (char)]((lambda [x:seq of (char), y:seq of (char)] \u0026 String`LT(x, y)))([\"12\", \"111\", \"01\"]) \u003d [\"01\", \"111\", \"12\"]) \u003d\u003e (((Sequence`sort)[RecordType](decideOrderFunc)([mk_RecordType(10, \"sahara\", \u0027c\u0027), mk_RecordType(10, \"sahara\", \u0027a\u0027)]) \u003d [mk_RecordType(10, \"sahara\", \u0027a\u0027), mk_RecordType(10, \"sahara\", \u0027c\u0027)]) \u003d\u003e ((((sq.isOrdered))[TestType](decideOrderFuncSeq)([3, \"123\", \u0027a\u0027])([3, \"123\", \u0027A\u0027]) \u003d true) \u003d\u003e ((((sq.isOrdered))[TestType](decideOrderFuncSeq)([3, \"123\", \u0027a\u0027])([3, \"123\", \u00270\u0027]) \u003d false) \u003d\u003e pre_(((sq.isOrdered))[(char | int | seq of (char))](decideOrderFuncSeq)([])[]))))))","legal function application obligation:(((Sequence`sort)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))([3, 1, 5, 4]) \u003d [1, 3, 4, 5]) \u003d\u003e (((Sequence`sort)[seq of (char)]((lambda [x:seq of (char), y:seq of (char)] \u0026 String`LT(x, y)))([\"12\", \"111\", \"01\"]) \u003d [\"01\", \"111\", \"12\"]) \u003d\u003e (((Sequence`sort)[RecordType](decideOrderFunc)([mk_RecordType(10, \"sahara\", \u0027c\u0027), mk_RecordType(10, \"sahara\", \u0027a\u0027)]) \u003d [mk_RecordType(10, \"sahara\", \u0027a\u0027), mk_RecordType(10, \"sahara\", \u0027c\u0027)]) \u003d\u003e ((((sq.isOrdered))[TestType](decideOrderFuncSeq)([3, \"123\", \u0027a\u0027])([3, \"123\", \u0027A\u0027]) \u003d true) \u003d\u003e ((((sq.isOrdered))[TestType](decideOrderFuncSeq)([3, \"123\", \u0027a\u0027])([3, \"123\", \u00270\u0027]) \u003d false) \u003d\u003e pre_(((sq.isOrdered))[(char | int | seq of (char))](decideOrderFuncSeq)[]))))))","legal function application obligation:(((Sequence`sort)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))([3, 1, 5, 4]) \u003d [1, 3, 4, 5]) \u003d\u003e (((Sequence`sort)[seq of (char)]((lambda [x:seq of (char), y:seq of (char)] \u0026 String`LT(x, y)))([\"12\", \"111\", \"01\"]) \u003d [\"01\", \"111\", \"12\"]) \u003d\u003e (((Sequence`sort)[RecordType](decideOrderFunc)([mk_RecordType(10, \"sahara\", \u0027c\u0027), mk_RecordType(10, \"sahara\", \u0027a\u0027)]) \u003d [mk_RecordType(10, \"sahara\", \u0027a\u0027), mk_RecordType(10, \"sahara\", \u0027c\u0027)]) \u003d\u003e ((((sq.isOrdered))[TestType](decideOrderFuncSeq)([3, \"123\", \u0027a\u0027])([3, \"123\", \u0027A\u0027]) \u003d true) \u003d\u003e ((((sq.isOrdered))[TestType](decideOrderFuncSeq)([3, \"123\", \u0027a\u0027])([3, \"123\", \u00270\u0027]) \u003d false) \u003d\u003e pre_(((sq.isOrdered))[(char | int | seq of (char))]decideOrderFuncSeq))))))","legal function application obligation:(((Sequence`sort)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))([3, 1, 5, 4]) \u003d [1, 3, 4, 5]) \u003d\u003e (((Sequence`sort)[seq of (char)]((lambda [x:seq of (char), y:seq of (char)] \u0026 String`LT(x, y)))([\"12\", \"111\", \"01\"]) \u003d [\"01\", \"111\", \"12\"]) \u003d\u003e (((Sequence`sort)[RecordType](decideOrderFunc)([mk_RecordType(10, \"sahara\", \u0027c\u0027), mk_RecordType(10, \"sahara\", \u0027a\u0027)]) \u003d [mk_RecordType(10, \"sahara\", \u0027a\u0027), mk_RecordType(10, \"sahara\", \u0027c\u0027)]) \u003d\u003e ((((sq.isOrdered))[TestType](decideOrderFuncSeq)([3, \"123\", \u0027a\u0027])([3, \"123\", \u0027A\u0027]) \u003d true) \u003d\u003e ((((sq.isOrdered))[TestType](decideOrderFuncSeq)([3, \"123\", \u0027a\u0027])([3, \"123\", \u00270\u0027]) \u003d false) \u003d\u003e ((((sq.isOrdered))[(char | int | seq of (char))](decideOrderFuncSeq)([])([]) \u003d false) \u003d\u003e pre_(((sq.isOrdered))[(char | int | seq of (char))](decideOrderFuncSeq)([])[3, \"123\", \u00270\u0027])))))))","legal function application obligation:(((Sequence`sort)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))([3, 1, 5, 4]) \u003d [1, 3, 4, 5]) \u003d\u003e (((Sequence`sort)[seq of (char)]((lambda [x:seq of (char), y:seq of (char)] \u0026 String`LT(x, y)))([\"12\", \"111\", \"01\"]) \u003d [\"01\", \"111\", \"12\"]) \u003d\u003e (((Sequence`sort)[RecordType](decideOrderFunc)([mk_RecordType(10, \"sahara\", \u0027c\u0027), mk_RecordType(10, \"sahara\", \u0027a\u0027)]) \u003d [mk_RecordType(10, \"sahara\", \u0027a\u0027), mk_RecordType(10, \"sahara\", \u0027c\u0027)]) \u003d\u003e ((((sq.isOrdered))[TestType](decideOrderFuncSeq)([3, \"123\", \u0027a\u0027])([3, \"123\", \u0027A\u0027]) \u003d true) \u003d\u003e ((((sq.isOrdered))[TestType](decideOrderFuncSeq)([3, \"123\", \u0027a\u0027])([3, \"123\", \u00270\u0027]) \u003d false) \u003d\u003e ((((sq.isOrdered))[(char | int | seq of (char))](decideOrderFuncSeq)([])([]) \u003d false) \u003d\u003e pre_(((sq.isOrdered))[(char | int | seq of (char))](decideOrderFuncSeq)[])))))))","legal function application obligation:(((Sequence`sort)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))([3, 1, 5, 4]) \u003d [1, 3, 4, 5]) \u003d\u003e (((Sequence`sort)[seq of (char)]((lambda [x:seq of (char), y:seq of (char)] \u0026 String`LT(x, y)))([\"12\", \"111\", \"01\"]) \u003d [\"01\", \"111\", \"12\"]) \u003d\u003e (((Sequence`sort)[RecordType](decideOrderFunc)([mk_RecordType(10, \"sahara\", \u0027c\u0027), mk_RecordType(10, \"sahara\", \u0027a\u0027)]) \u003d [mk_RecordType(10, \"sahara\", \u0027a\u0027), mk_RecordType(10, \"sahara\", \u0027c\u0027)]) \u003d\u003e ((((sq.isOrdered))[TestType](decideOrderFuncSeq)([3, \"123\", \u0027a\u0027])([3, \"123\", \u0027A\u0027]) \u003d true) \u003d\u003e ((((sq.isOrdered))[TestType](decideOrderFuncSeq)([3, \"123\", \u0027a\u0027])([3, \"123\", \u00270\u0027]) \u003d false) \u003d\u003e ((((sq.isOrdered))[(char | int | seq of (char))](decideOrderFuncSeq)([])([]) \u003d false) \u003d\u003e pre_(((sq.isOrdered))[(char | int | seq of (char))]decideOrderFuncSeq)))))))","legal function application obligation:(((Sequence`sort)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))([3, 1, 5, 4]) \u003d [1, 3, 4, 5]) \u003d\u003e (((Sequence`sort)[seq of (char)]((lambda [x:seq of (char), y:seq of (char)] \u0026 String`LT(x, y)))([\"12\", \"111\", \"01\"]) \u003d [\"01\", \"111\", \"12\"]) \u003d\u003e (((Sequence`sort)[RecordType](decideOrderFunc)([mk_RecordType(10, \"sahara\", \u0027c\u0027), mk_RecordType(10, \"sahara\", \u0027a\u0027)]) \u003d [mk_RecordType(10, \"sahara\", \u0027a\u0027), mk_RecordType(10, \"sahara\", \u0027c\u0027)]) \u003d\u003e ((((sq.isOrdered))[TestType](decideOrderFuncSeq)([3, \"123\", \u0027a\u0027])([3, \"123\", \u0027A\u0027]) \u003d true) \u003d\u003e ((((sq.isOrdered))[TestType](decideOrderFuncSeq)([3, \"123\", \u0027a\u0027])([3, \"123\", \u00270\u0027]) \u003d false) \u003d\u003e ((((sq.isOrdered))[(char | int | seq of (char))](decideOrderFuncSeq)([])([]) \u003d false) \u003d\u003e ((((sq.isOrdered))[(char | int | seq of (char))](decideOrderFuncSeq)([])([3, \"123\", \u00270\u0027]) \u003d true) \u003d\u003e pre_(((sq.isOrdered))[(char | int | seq of (char))](decideOrderFuncSeq)([3, \"123\", \u00270\u0027])[]))))))))","legal function application obligation:(((Sequence`sort)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))([3, 1, 5, 4]) \u003d [1, 3, 4, 5]) \u003d\u003e (((Sequence`sort)[seq of (char)]((lambda [x:seq of (char), y:seq of (char)] \u0026 String`LT(x, y)))([\"12\", \"111\", \"01\"]) \u003d [\"01\", \"111\", \"12\"]) \u003d\u003e (((Sequence`sort)[RecordType](decideOrderFunc)([mk_RecordType(10, \"sahara\", \u0027c\u0027), mk_RecordType(10, \"sahara\", \u0027a\u0027)]) \u003d [mk_RecordType(10, \"sahara\", \u0027a\u0027), mk_RecordType(10, \"sahara\", \u0027c\u0027)]) \u003d\u003e ((((sq.isOrdered))[TestType](decideOrderFuncSeq)([3, \"123\", \u0027a\u0027])([3, \"123\", \u0027A\u0027]) \u003d true) \u003d\u003e ((((sq.isOrdered))[TestType](decideOrderFuncSeq)([3, \"123\", \u0027a\u0027])([3, \"123\", \u00270\u0027]) \u003d false) \u003d\u003e ((((sq.isOrdered))[(char | int | seq of (char))](decideOrderFuncSeq)([])([]) \u003d false) \u003d\u003e ((((sq.isOrdered))[(char | int | seq of (char))](decideOrderFuncSeq)([])([3, \"123\", \u00270\u0027]) \u003d true) \u003d\u003e pre_(((sq.isOrdered))[(char | int | seq of (char))](decideOrderFuncSeq)[3, \"123\", \u00270\u0027]))))))))","legal function application obligation:(((Sequence`sort)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))([3, 1, 5, 4]) \u003d [1, 3, 4, 5]) \u003d\u003e (((Sequence`sort)[seq of (char)]((lambda [x:seq of (char), y:seq of (char)] \u0026 String`LT(x, y)))([\"12\", \"111\", \"01\"]) \u003d [\"01\", \"111\", \"12\"]) \u003d\u003e (((Sequence`sort)[RecordType](decideOrderFunc)([mk_RecordType(10, \"sahara\", \u0027c\u0027), mk_RecordType(10, \"sahara\", \u0027a\u0027)]) \u003d [mk_RecordType(10, \"sahara\", \u0027a\u0027), mk_RecordType(10, \"sahara\", \u0027c\u0027)]) \u003d\u003e ((((sq.isOrdered))[TestType](decideOrderFuncSeq)([3, \"123\", \u0027a\u0027])([3, \"123\", \u0027A\u0027]) \u003d true) \u003d\u003e ((((sq.isOrdered))[TestType](decideOrderFuncSeq)([3, \"123\", \u0027a\u0027])([3, \"123\", \u00270\u0027]) \u003d false) \u003d\u003e ((((sq.isOrdered))[(char | int | seq of (char))](decideOrderFuncSeq)([])([]) \u003d false) \u003d\u003e ((((sq.isOrdered))[(char | int | seq of (char))](decideOrderFuncSeq)([])([3, \"123\", \u00270\u0027]) \u003d true) \u003d\u003e pre_(((sq.isOrdered))[(char | int | seq of (char))]decideOrderFuncSeq))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(((sq.Merge))[int](decideOrderFunc1)([1, 4, 6])[2, 3, 4, 5])","legal function application obligation:pre_(((sq.Merge))[int](decideOrderFunc1)[1, 4, 6])","legal function application obligation:pre_(((sq.Merge))[int]decideOrderFunc1)","legal function application obligation:((((sq.Merge))[int](decideOrderFunc1)([1, 4, 6])([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 4, 5, 6]) \u003d\u003e pre_(((sq.Merge))[char](decideOrderFunc2)(\"146\")\"2345\"))","legal function application obligation:((((sq.Merge))[int](decideOrderFunc1)([1, 4, 6])([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 4, 5, 6]) \u003d\u003e pre_(((sq.Merge))[char](decideOrderFunc2)\"146\"))","legal function application obligation:((((sq.Merge))[int](decideOrderFunc1)([1, 4, 6])([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 4, 5, 6]) \u003d\u003e pre_(((sq.Merge))[char]decideOrderFunc2))","legal function application obligation:((((sq.Merge))[int](decideOrderFunc1)([1, 4, 6])([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 4, 5, 6]) \u003d\u003e ((((sq.Merge))[char](decideOrderFunc2)(\"146\")(\"2345\") \u003d \"1234456\") \u003d\u003e pre_(((sq.Merge))[char](decideOrderFunc2)(\"\")\"2345\")))","legal function application obligation:((((sq.Merge))[int](decideOrderFunc1)([1, 4, 6])([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 4, 5, 6]) \u003d\u003e ((((sq.Merge))[char](decideOrderFunc2)(\"146\")(\"2345\") \u003d \"1234456\") \u003d\u003e pre_(((sq.Merge))[char](decideOrderFunc2)\"\")))","legal function application obligation:((((sq.Merge))[int](decideOrderFunc1)([1, 4, 6])([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 4, 5, 6]) \u003d\u003e ((((sq.Merge))[char](decideOrderFunc2)(\"146\")(\"2345\") \u003d \"1234456\") \u003d\u003e pre_(((sq.Merge))[char]decideOrderFunc2)))","legal function application obligation:((((sq.Merge))[int](decideOrderFunc1)([1, 4, 6])([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 4, 5, 6]) \u003d\u003e ((((sq.Merge))[char](decideOrderFunc2)(\"146\")(\"2345\") \u003d \"1234456\") \u003d\u003e ((((sq.Merge))[char](decideOrderFunc2)(\"\")(\"2345\") \u003d \"2345\") \u003d\u003e pre_(((sq.Merge))[char](decideOrderFunc2)(\"146\")\"\"))))","legal function application obligation:((((sq.Merge))[int](decideOrderFunc1)([1, 4, 6])([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 4, 5, 6]) \u003d\u003e ((((sq.Merge))[char](decideOrderFunc2)(\"146\")(\"2345\") \u003d \"1234456\") \u003d\u003e ((((sq.Merge))[char](decideOrderFunc2)(\"\")(\"2345\") \u003d \"2345\") \u003d\u003e pre_(((sq.Merge))[char](decideOrderFunc2)\"146\"))))","legal function application obligation:((((sq.Merge))[int](decideOrderFunc1)([1, 4, 6])([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 4, 5, 6]) \u003d\u003e ((((sq.Merge))[char](decideOrderFunc2)(\"146\")(\"2345\") \u003d \"1234456\") \u003d\u003e ((((sq.Merge))[char](decideOrderFunc2)(\"\")(\"2345\") \u003d \"2345\") \u003d\u003e pre_(((sq.Merge))[char]decideOrderFunc2))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(((sq.take))[int](2)[2, 3, 4, 5])","legal function application obligation:pre_(((sq.take))[int]2)","legal function application obligation:((((sq.take))[int](2)([2, 3, 4, 5]) \u003d [2, 3]) \u003d\u003e pre_(((sq.drop))[char](5)\"Shin Sahara\"))","legal function application obligation:((((sq.take))[int](2)([2, 3, 4, 5]) \u003d [2, 3]) \u003d\u003e pre_(((sq.drop))[char]5))","legal function application obligation:((((sq.take))[int](2)([2, 3, 4, 5]) \u003d [2, 3]) \u003d\u003e ((((sq.drop))[char](5)(\"Shin Sahara\") \u003d \"Sahara\") \u003d\u003e pre_(((sq.last))[int][1, 2, 3])))","legal function application obligation:((((sq.take))[int](2)([2, 3, 4, 5]) \u003d [2, 3]) \u003d\u003e ((((sq.drop))[char](5)(\"Shin Sahara\") \u003d \"Sahara\") \u003d\u003e ((((sq.last))[int]([1, 2, 3]) \u003d 3) \u003d\u003e pre_(((sq.filter))[int]((lambda [x:int] \u0026 ((x mod 2) \u003d 0)))[1, 2, 3, 4, 5, 6]))))","legal function application obligation:((((sq.take))[int](2)([2, 3, 4, 5]) \u003d [2, 3]) \u003d\u003e ((((sq.drop))[char](5)(\"Shin Sahara\") \u003d \"Sahara\") \u003d\u003e ((((sq.last))[int]([1, 2, 3]) \u003d 3) \u003d\u003e pre_(((sq.filter))[int](lambda [x:int] \u0026 ((x mod 2) \u003d 0))))))","legal function application obligation:((((sq.take))[int](2)([2, 3, 4, 5]) \u003d [2, 3]) \u003d\u003e ((((sq.drop))[char](5)(\"Shin Sahara\") \u003d \"Sahara\") \u003d\u003e ((((sq.last))[int]([1, 2, 3]) \u003d 3) \u003d\u003e ((((sq.filter))[int]((lambda [x:int] \u0026 ((x mod 2) \u003d 0)))([1, 2, 3, 4, 5, 6]) \u003d [2, 4, 6]) \u003d\u003e pre_((Sequence`SubSeq)[char](4)(3)\"1234567890\")))))","legal function application obligation:((((sq.take))[int](2)([2, 3, 4, 5]) \u003d [2, 3]) \u003d\u003e ((((sq.drop))[char](5)(\"Shin Sahara\") \u003d \"Sahara\") \u003d\u003e ((((sq.last))[int]([1, 2, 3]) \u003d 3) \u003d\u003e ((((sq.filter))[int]((lambda [x:int] \u0026 ((x mod 2) \u003d 0)))([1, 2, 3, 4, 5, 6]) \u003d [2, 4, 6]) \u003d\u003e pre_((Sequence`SubSeq)[char](4)3)))))","type compatibility obligation:is_(RESULT, ())","type compatibility obligation:is_(RESULT, ())","type compatibility obligation:is_(RESULT, ())","type compatibility obligation:is_(RESULT, ())","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((Sequence`isMember)[int](2)[1, 2, 3, 4, 5, 6])","legal function application obligation:((Sequence`isMember)[int](2)([1, 2, 3, 4, 5, 6]) \u003d\u003e pre_((Sequence`isMember)[int](0)[1, 2, 3, 4, 5, 6]))","legal function application obligation:((Sequence`isMember)[int](2)([1, 2, 3, 4, 5, 6]) \u003d\u003e (((Sequence`isMember)[int](0)([1, 2, 3, 4, 5, 6]) \u003d false) \u003d\u003e pre_((Sequence`isMember)[int](6)[1, 2, 3, 4, 5, 6])))","legal function application obligation:((Sequence`isMember)[int](2)([1, 2, 3, 4, 5, 6]) \u003d\u003e (((Sequence`isMember)[int](0)([1, 2, 3, 4, 5, 6]) \u003d false) \u003d\u003e ((Sequence`isMember)[int](6)([1, 2, 3, 4, 5, 6]) \u003d\u003e pre_((Sequence`isAnyMember)[int]([6])[1, 2, 3, 4, 5, 6]))))","legal function application obligation:((Sequence`isMember)[int](2)([1, 2, 3, 4, 5, 6]) \u003d\u003e (((Sequence`isMember)[int](0)([1, 2, 3, 4, 5, 6]) \u003d false) \u003d\u003e ((Sequence`isMember)[int](6)([1, 2, 3, 4, 5, 6]) \u003d\u003e ((Sequence`isAnyMember)[int]([6])([1, 2, 3, 4, 5, 6]) \u003d\u003e pre_((Sequence`isAnyMember)[int]([0, 7])[1, 2, 3, 4, 5, 6])))))","legal function application obligation:((Sequence`isMember)[int](2)([1, 2, 3, 4, 5, 6]) \u003d\u003e (((Sequence`isMember)[int](0)([1, 2, 3, 4, 5, 6]) \u003d false) \u003d\u003e ((Sequence`isMember)[int](6)([1, 2, 3, 4, 5, 6]) \u003d\u003e ((Sequence`isAnyMember)[int]([6])([1, 2, 3, 4, 5, 6]) \u003d\u003e (((Sequence`isAnyMember)[int]([0, 7])([1, 2, 3, 4, 5, 6]) \u003d false) \u003d\u003e pre_((Sequence`isAnyMember)[int]([4, 6])[1, 2, 3, 4, 5, 6]))))))","legal function application obligation:((Sequence`isMember)[int](2)([1, 2, 3, 4, 5, 6]) \u003d\u003e (((Sequence`isMember)[int](0)([1, 2, 3, 4, 5, 6]) \u003d false) \u003d\u003e ((Sequence`isMember)[int](6)([1, 2, 3, 4, 5, 6]) \u003d\u003e ((Sequence`isAnyMember)[int]([6])([1, 2, 3, 4, 5, 6]) \u003d\u003e (((Sequence`isAnyMember)[int]([0, 7])([1, 2, 3, 4, 5, 6]) \u003d false) \u003d\u003e ((Sequence`isAnyMember)[int]([4, 6])([1, 2, 3, 4, 5, 6]) \u003d\u003e pre_((Sequence`isAnyMember)[int]([])[1, 2, 3, 4, 5, 6])))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((Sequence`fmap)[int, int]((lambda [x:int] \u0026 (x mod 3)))[1, 2, 3, 4, 5])","legal function application obligation:(((Sequence`fmap)[int, int]((lambda [x:int] \u0026 (x mod 3)))([1, 2, 3, 4, 5]) \u003d [1, 2, 0, 1, 2]) \u003d\u003e pre_((Sequence`fmap)[seq of (char), seq of (char)]((Sequence`take)[char](2))[\"Shin Sahara\", \"Hiroshi Sakoh\"]))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((index)[int](1)[1, 2, 3, 4, 5])","legal function application obligation:pre_((index)[int]1)","legal function application obligation:(((index)[int](1)([1, 2, 3, 4, 5]) \u003d 1) \u003d\u003e pre_((index)[int](5)[1, 2, 3, 4, 5]))","legal function application obligation:(((index)[int](1)([1, 2, 3, 4, 5]) \u003d 1) \u003d\u003e pre_((index)[int]5))","legal function application obligation:(((index)[int](1)([1, 2, 3, 4, 5]) \u003d 1) \u003d\u003e (((index)[int](5)([1, 2, 3, 4, 5]) \u003d 5) \u003d\u003e pre_((index)[int](9)[1, 2, 3, 4, 5])))","legal function application obligation:(((index)[int](1)([1, 2, 3, 4, 5]) \u003d 1) \u003d\u003e (((index)[int](5)([1, 2, 3, 4, 5]) \u003d 5) \u003d\u003e pre_((index)[int]9)))","legal function application obligation:(((index)[int](1)([1, 2, 3, 4, 5]) \u003d 1) \u003d\u003e (((index)[int](5)([1, 2, 3, 4, 5]) \u003d 5) \u003d\u003e (((index)[int](9)([1, 2, 3, 4, 5]) \u003d 0) \u003d\u003e pre_((index)[char](\u0027b\u0027)[\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]))))","legal function application obligation:(((index)[int](1)([1, 2, 3, 4, 5]) \u003d 1) \u003d\u003e (((index)[int](5)([1, 2, 3, 4, 5]) \u003d 5) \u003d\u003e (((index)[int](9)([1, 2, 3, 4, 5]) \u003d 0) \u003d\u003e pre_((index)[char]\u0027b\u0027))))","legal function application obligation:(((index)[int](1)([1, 2, 3, 4, 5]) \u003d 1) \u003d\u003e (((index)[int](5)([1, 2, 3, 4, 5]) \u003d 5) \u003d\u003e (((index)[int](9)([1, 2, 3, 4, 5]) \u003d 0) \u003d\u003e (((index)[char](\u0027b\u0027)([\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d 2) \u003d\u003e pre_((index)[char](\u0027z\u0027)[\u0027a\u0027, \u0027b\u0027, \u0027c\u0027])))))","legal function application obligation:(((index)[int](1)([1, 2, 3, 4, 5]) \u003d 1) \u003d\u003e (((index)[int](5)([1, 2, 3, 4, 5]) \u003d 5) \u003d\u003e (((index)[int](9)([1, 2, 3, 4, 5]) \u003d 0) \u003d\u003e (((index)[char](\u0027b\u0027)([\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d 2) \u003d\u003e pre_((index)[char]\u0027z\u0027)))))","legal function application obligation:(((index)[int](1)([1, 2, 3, 4, 5]) \u003d 1) \u003d\u003e (((index)[int](5)([1, 2, 3, 4, 5]) \u003d 5) \u003d\u003e (((index)[int](9)([1, 2, 3, 4, 5]) \u003d 0) \u003d\u003e (((index)[char](\u0027b\u0027)([\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d 2) \u003d\u003e (((index)[char](\u0027z\u0027)([\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d 0) \u003d\u003e pre_((indexAll)[int](9)[1, 2, 3, 4, 5]))))))","legal function application obligation:(((index)[int](1)([1, 2, 3, 4, 5]) \u003d 1) \u003d\u003e (((index)[int](5)([1, 2, 3, 4, 5]) \u003d 5) \u003d\u003e (((index)[int](9)([1, 2, 3, 4, 5]) \u003d 0) \u003d\u003e (((index)[char](\u0027b\u0027)([\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d 2) \u003d\u003e (((index)[char](\u0027z\u0027)([\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d 0) \u003d\u003e pre_((indexAll)[int]9))))))","legal function application obligation:(((index)[int](1)([1, 2, 3, 4, 5]) \u003d 1) \u003d\u003e (((index)[int](5)([1, 2, 3, 4, 5]) \u003d 5) \u003d\u003e (((index)[int](9)([1, 2, 3, 4, 5]) \u003d 0) \u003d\u003e (((index)[char](\u0027b\u0027)([\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d 2) \u003d\u003e (((index)[char](\u0027z\u0027)([\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d 0) \u003d\u003e (((indexAll)[int](9)([1, 2, 3, 4, 5]) \u003d {}) \u003d\u003e pre_((indexAll)[int](9)[])))))))","legal function application obligation:(((index)[int](1)([1, 2, 3, 4, 5]) \u003d 1) \u003d\u003e (((index)[int](5)([1, 2, 3, 4, 5]) \u003d 5) \u003d\u003e (((index)[int](9)([1, 2, 3, 4, 5]) \u003d 0) \u003d\u003e (((index)[char](\u0027b\u0027)([\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d 2) \u003d\u003e (((index)[char](\u0027z\u0027)([\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d 0) \u003d\u003e (((indexAll)[int](9)([1, 2, 3, 4, 5]) \u003d {}) \u003d\u003e pre_((indexAll)[int]9)))))))","legal function application obligation:(((index)[int](1)([1, 2, 3, 4, 5]) \u003d 1) \u003d\u003e (((index)[int](5)([1, 2, 3, 4, 5]) \u003d 5) \u003d\u003e (((index)[int](9)([1, 2, 3, 4, 5]) \u003d 0) \u003d\u003e (((index)[char](\u0027b\u0027)([\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d 2) \u003d\u003e (((index)[char](\u0027z\u0027)([\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d 0) \u003d\u003e (((indexAll)[int](9)([1, 2, 3, 4, 5]) \u003d {}) \u003d\u003e (((indexAll)[int](9)([]) \u003d {}) \u003d\u003e pre_((indexAll)[int](1)[1, 2, 3, 4, 1]))))))))","legal function application obligation:(((index)[int](1)([1, 2, 3, 4, 5]) \u003d 1) \u003d\u003e (((index)[int](5)([1, 2, 3, 4, 5]) \u003d 5) \u003d\u003e (((index)[int](9)([1, 2, 3, 4, 5]) \u003d 0) \u003d\u003e (((index)[char](\u0027b\u0027)([\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d 2) \u003d\u003e (((index)[char](\u0027z\u0027)([\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d 0) \u003d\u003e (((indexAll)[int](9)([1, 2, 3, 4, 5]) \u003d {}) \u003d\u003e (((indexAll)[int](9)([]) \u003d {}) \u003d\u003e pre_((indexAll)[int]1))))))))","legal function application obligation:(((index)[int](1)([1, 2, 3, 4, 5]) \u003d 1) \u003d\u003e (((index)[int](5)([1, 2, 3, 4, 5]) \u003d 5) \u003d\u003e (((index)[int](9)([1, 2, 3, 4, 5]) \u003d 0) \u003d\u003e (((index)[char](\u0027b\u0027)([\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d 2) \u003d\u003e (((index)[char](\u0027z\u0027)([\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d 0) \u003d\u003e (((indexAll)[int](9)([1, 2, 3, 4, 5]) \u003d {}) \u003d\u003e (((indexAll)[int](9)([]) \u003d {}) \u003d\u003e (((indexAll)[int](1)([1, 2, 3, 4, 1]) \u003d {1, 5}) \u003d\u003e pre_((indexAll)[int](1)[1, 2, 3, 4, 1, 1])))))))))","legal function application obligation:(((index)[int](1)([1, 2, 3, 4, 5]) \u003d 1) \u003d\u003e (((index)[int](5)([1, 2, 3, 4, 5]) \u003d 5) \u003d\u003e (((index)[int](9)([1, 2, 3, 4, 5]) \u003d 0) \u003d\u003e (((index)[char](\u0027b\u0027)([\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d 2) \u003d\u003e (((index)[char](\u0027z\u0027)([\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d 0) \u003d\u003e (((indexAll)[int](9)([1, 2, 3, 4, 5]) \u003d {}) \u003d\u003e (((indexAll)[int](9)([]) \u003d {}) \u003d\u003e (((indexAll)[int](1)([1, 2, 3, 4, 1]) \u003d {1, 5}) \u003d\u003e pre_((indexAll)[int]1)))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(avg1[])","legal function application obligation:((avg1([]) \u003d nil) \u003d\u003e pre_(avg1[1, 2, 3, 4]))","legal function application obligation:((avg1([]) \u003d nil) \u003d\u003e ((avg1([1, 2, 3, 4]) \u003d ((((1 + 2) + 3) + 4) / 4)) \u003d\u003e pre_(avg2[1.3, 2.4, 3.5])))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(ins1(1)(1)[2, 3, 4, 5])","legal function application obligation:pre_(ins1(1)1)","legal function application obligation:pre_(ins11)","legal function application obligation:((ins1(1)(1)([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e pre_(ins1(3)(3)[1, 2, 4, 5]))","legal function application obligation:((ins1(1)(1)([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e pre_(ins1(3)3))","legal function application obligation:((ins1(1)(1)([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e pre_(ins13))","legal function application obligation:((ins1(1)(1)([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e pre_(ins1(3)(3)[1, 2])))","legal function application obligation:((ins1(1)(1)([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e pre_(ins1(3)3)))","legal function application obligation:((ins1(1)(1)([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e pre_(ins13)))","legal function application obligation:((ins1(1)(1)([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e pre_(ins1(4)(3)[1, 2]))))","legal function application obligation:((ins1(1)(1)([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e pre_(ins1(4)3))))","legal function application obligation:((ins1(1)(1)([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e pre_(ins14))))","legal function application obligation:((ins1(1)(1)([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins1(4)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e pre_(ins1(5)(3)[1, 2])))))","legal function application obligation:((ins1(1)(1)([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins1(4)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e pre_(ins1(5)3)))))","legal function application obligation:((ins1(1)(1)([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins1(4)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e pre_(ins15)))))","legal function application obligation:((ins1(1)(1)([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins1(4)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins1(5)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e pre_(ins2(1)(\u00271\u0027)\"2345\"))))))","legal function application obligation:((ins1(1)(1)([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins1(4)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins1(5)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e pre_(ins2(1)\u00271\u0027))))))","legal function application obligation:((ins1(1)(1)([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins1(4)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins1(5)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e pre_(ins21))))))","legal function application obligation:((ins1(1)(1)([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins1(4)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins1(5)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins2(1)(\u00271\u0027)(\"2345\") \u003d \"12345\") \u003d\u003e pre_(ins2(3)(\u00273\u0027)\"1245\")))))))","legal function application obligation:((ins1(1)(1)([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins1(4)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins1(5)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins2(1)(\u00271\u0027)(\"2345\") \u003d \"12345\") \u003d\u003e pre_(ins2(3)\u00273\u0027)))))))","legal function application obligation:((ins1(1)(1)([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins1(4)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins1(5)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins2(1)(\u00271\u0027)(\"2345\") \u003d \"12345\") \u003d\u003e pre_(ins23)))))))","legal function application obligation:((ins1(1)(1)([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins1(4)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins1(5)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins2(1)(\u00271\u0027)(\"2345\") \u003d \"12345\") \u003d\u003e ((ins2(3)(\u00273\u0027)(\"1245\") \u003d \"12345\") \u003d\u003e pre_(ins2(3)(\u00273\u0027)\"12\"))))))))","legal function application obligation:((ins1(1)(1)([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins1(4)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins1(5)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins2(1)(\u00271\u0027)(\"2345\") \u003d \"12345\") \u003d\u003e ((ins2(3)(\u00273\u0027)(\"1245\") \u003d \"12345\") \u003d\u003e pre_(ins2(3)\u00273\u0027))))))))","legal function application obligation:((ins1(1)(1)([2, 3, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2, 4, 5]) \u003d [1, 2, 3, 4, 5]) \u003d\u003e ((ins1(3)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins1(4)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins1(5)(3)([1, 2]) \u003d [1, 2, 3]) \u003d\u003e ((ins2(1)(\u00271\u0027)(\"2345\") \u003d \"12345\") \u003d\u003e ((ins2(3)(\u00273\u0027)(\"1245\") \u003d \"12345\") \u003d\u003e pre_(ins23))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(rm1(1)[1, 2, 3, 4, 5])","legal function application obligation:pre_(rm11)","legal function application obligation:((rm1(1)([1, 2, 3, 4, 5]) \u003d [2, 3, 4, 5]) \u003d\u003e pre_(rm1(3)[1, 2, 4, 3]))","legal function application obligation:((rm1(1)([1, 2, 3, 4, 5]) \u003d [2, 3, 4, 5]) \u003d\u003e pre_(rm13))","legal function application obligation:((rm1(1)([1, 2, 3, 4, 5]) \u003d [2, 3, 4, 5]) \u003d\u003e ((rm1(3)([1, 2, 4, 3]) \u003d [1, 2, 3]) \u003d\u003e pre_(rm1(3)[1, 2])))","legal function application obligation:((rm1(1)([1, 2, 3, 4, 5]) \u003d [2, 3, 4, 5]) \u003d\u003e ((rm1(3)([1, 2, 4, 3]) \u003d [1, 2, 3]) \u003d\u003e pre_(rm13)))","legal function application obligation:((rm1(1)([1, 2, 3, 4, 5]) \u003d [2, 3, 4, 5]) \u003d\u003e ((rm1(3)([1, 2, 4, 3]) \u003d [1, 2, 3]) \u003d\u003e ((rm1(3)([1, 2]) \u003d [1, 2]) \u003d\u003e pre_(rm1(4)[1, 2]))))","legal function application obligation:((rm1(1)([1, 2, 3, 4, 5]) \u003d [2, 3, 4, 5]) \u003d\u003e ((rm1(3)([1, 2, 4, 3]) \u003d [1, 2, 3]) \u003d\u003e ((rm1(3)([1, 2]) \u003d [1, 2]) \u003d\u003e pre_(rm14))))","legal function application obligation:((rm1(1)([1, 2, 3, 4, 5]) \u003d [2, 3, 4, 5]) \u003d\u003e ((rm1(3)([1, 2, 4, 3]) \u003d [1, 2, 3]) \u003d\u003e ((rm1(3)([1, 2]) \u003d [1, 2]) \u003d\u003e ((rm1(4)([1, 2]) \u003d [1, 2]) \u003d\u003e pre_(rm1(5)[1, 2])))))","legal function application obligation:((rm1(1)([1, 2, 3, 4, 5]) \u003d [2, 3, 4, 5]) \u003d\u003e ((rm1(3)([1, 2, 4, 3]) \u003d [1, 2, 3]) \u003d\u003e ((rm1(3)([1, 2]) \u003d [1, 2]) \u003d\u003e ((rm1(4)([1, 2]) \u003d [1, 2]) \u003d\u003e pre_(rm15)))))","legal function application obligation:((rm1(1)([1, 2, 3, 4, 5]) \u003d [2, 3, 4, 5]) \u003d\u003e ((rm1(3)([1, 2, 4, 3]) \u003d [1, 2, 3]) \u003d\u003e ((rm1(3)([1, 2]) \u003d [1, 2]) \u003d\u003e ((rm1(4)([1, 2]) \u003d [1, 2]) \u003d\u003e ((rm1(5)([1, 2]) \u003d [1, 2]) \u003d\u003e pre_(rm2(1)\"12345\"))))))","legal function application obligation:((rm1(1)([1, 2, 3, 4, 5]) \u003d [2, 3, 4, 5]) \u003d\u003e ((rm1(3)([1, 2, 4, 3]) \u003d [1, 2, 3]) \u003d\u003e ((rm1(3)([1, 2]) \u003d [1, 2]) \u003d\u003e ((rm1(4)([1, 2]) \u003d [1, 2]) \u003d\u003e ((rm1(5)([1, 2]) \u003d [1, 2]) \u003d\u003e pre_(rm21))))))","legal function application obligation:((rm1(1)([1, 2, 3, 4, 5]) \u003d [2, 3, 4, 5]) \u003d\u003e ((rm1(3)([1, 2, 4, 3]) \u003d [1, 2, 3]) \u003d\u003e ((rm1(3)([1, 2]) \u003d [1, 2]) \u003d\u003e ((rm1(4)([1, 2]) \u003d [1, 2]) \u003d\u003e ((rm1(5)([1, 2]) \u003d [1, 2]) \u003d\u003e ((rm2(1)(\"12345\") \u003d \"2345\") \u003d\u003e pre_(rm2(3)\"1243\")))))))","legal function application obligation:((rm1(1)([1, 2, 3, 4, 5]) \u003d [2, 3, 4, 5]) \u003d\u003e ((rm1(3)([1, 2, 4, 3]) \u003d [1, 2, 3]) \u003d\u003e ((rm1(3)([1, 2]) \u003d [1, 2]) \u003d\u003e ((rm1(4)([1, 2]) \u003d [1, 2]) \u003d\u003e ((rm1(5)([1, 2]) \u003d [1, 2]) \u003d\u003e ((rm2(1)(\"12345\") \u003d \"2345\") \u003d\u003e pre_(rm23)))))))","legal function application obligation:((rm1(1)([1, 2, 3, 4, 5]) \u003d [2, 3, 4, 5]) \u003d\u003e ((rm1(3)([1, 2, 4, 3]) \u003d [1, 2, 3]) \u003d\u003e ((rm1(3)([1, 2]) \u003d [1, 2]) \u003d\u003e ((rm1(4)([1, 2]) \u003d [1, 2]) \u003d\u003e ((rm1(5)([1, 2]) \u003d [1, 2]) \u003d\u003e ((rm2(1)(\"12345\") \u003d \"2345\") \u003d\u003e ((rm2(3)(\"1243\") \u003d \"123\") \u003d\u003e pre_(rm2(3)\"12\"))))))))","legal function application obligation:((rm1(1)([1, 2, 3, 4, 5]) \u003d [2, 3, 4, 5]) \u003d\u003e ((rm1(3)([1, 2, 4, 3]) \u003d [1, 2, 3]) \u003d\u003e ((rm1(3)([1, 2]) \u003d [1, 2]) \u003d\u003e ((rm1(4)([1, 2]) \u003d [1, 2]) \u003d\u003e ((rm1(5)([1, 2]) \u003d [1, 2]) \u003d\u003e ((rm2(1)(\"12345\") \u003d \"2345\") \u003d\u003e ((rm2(3)(\"1243\") \u003d \"123\") \u003d\u003e pre_(rm23))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(up1(1)(10)[1, 2, 3, 4, 5])","legal function application obligation:pre_(up1(1)10)","legal function application obligation:pre_(up11)","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e pre_(up1(3)(40)[1, 2, 4, 3]))","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e pre_(up1(3)40))","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e pre_(up13))","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e ((up1(3)(40)([1, 2, 4, 3]) \u003d [1, 2, 40, 3]) \u003d\u003e pre_(up1(2)(30)[1, 2])))","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e ((up1(3)(40)([1, 2, 4, 3]) \u003d [1, 2, 40, 3]) \u003d\u003e pre_(up1(2)30)))","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e ((up1(3)(40)([1, 2, 4, 3]) \u003d [1, 2, 40, 3]) \u003d\u003e pre_(up12)))","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e ((up1(3)(40)([1, 2, 4, 3]) \u003d [1, 2, 40, 3]) \u003d\u003e ((up1(2)(30)([1, 2]) \u003d [1, 30]) \u003d\u003e pre_(up1(3)(30)[1, 2]))))","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e ((up1(3)(40)([1, 2, 4, 3]) \u003d [1, 2, 40, 3]) \u003d\u003e ((up1(2)(30)([1, 2]) \u003d [1, 30]) \u003d\u003e pre_(up1(3)30))))","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e ((up1(3)(40)([1, 2, 4, 3]) \u003d [1, 2, 40, 3]) \u003d\u003e ((up1(2)(30)([1, 2]) \u003d [1, 30]) \u003d\u003e pre_(up13))))","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e ((up1(3)(40)([1, 2, 4, 3]) \u003d [1, 2, 40, 3]) \u003d\u003e ((up1(2)(30)([1, 2]) \u003d [1, 30]) \u003d\u003e ((up1(3)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e pre_(up1(4)(30)[1, 2])))))","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e ((up1(3)(40)([1, 2, 4, 3]) \u003d [1, 2, 40, 3]) \u003d\u003e ((up1(2)(30)([1, 2]) \u003d [1, 30]) \u003d\u003e ((up1(3)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e pre_(up1(4)30)))))","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e ((up1(3)(40)([1, 2, 4, 3]) \u003d [1, 2, 40, 3]) \u003d\u003e ((up1(2)(30)([1, 2]) \u003d [1, 30]) \u003d\u003e ((up1(3)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e pre_(up14)))))","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e ((up1(3)(40)([1, 2, 4, 3]) \u003d [1, 2, 40, 3]) \u003d\u003e ((up1(2)(30)([1, 2]) \u003d [1, 30]) \u003d\u003e ((up1(3)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e ((up1(4)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e pre_(up2(1)(\u0027a\u0027)\"12345\"))))))","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e ((up1(3)(40)([1, 2, 4, 3]) \u003d [1, 2, 40, 3]) \u003d\u003e ((up1(2)(30)([1, 2]) \u003d [1, 30]) \u003d\u003e ((up1(3)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e ((up1(4)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e pre_(up2(1)\u0027a\u0027))))))","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e ((up1(3)(40)([1, 2, 4, 3]) \u003d [1, 2, 40, 3]) \u003d\u003e ((up1(2)(30)([1, 2]) \u003d [1, 30]) \u003d\u003e ((up1(3)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e ((up1(4)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e pre_(up21))))))","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e ((up1(3)(40)([1, 2, 4, 3]) \u003d [1, 2, 40, 3]) \u003d\u003e ((up1(2)(30)([1, 2]) \u003d [1, 30]) \u003d\u003e ((up1(3)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e ((up1(4)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e ((up2(1)(\u0027a\u0027)(\"12345\") \u003d \"a2345\") \u003d\u003e pre_(up2(3)(\u0027b\u0027)\"1243\")))))))","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e ((up1(3)(40)([1, 2, 4, 3]) \u003d [1, 2, 40, 3]) \u003d\u003e ((up1(2)(30)([1, 2]) \u003d [1, 30]) \u003d\u003e ((up1(3)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e ((up1(4)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e ((up2(1)(\u0027a\u0027)(\"12345\") \u003d \"a2345\") \u003d\u003e pre_(up2(3)\u0027b\u0027)))))))","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e ((up1(3)(40)([1, 2, 4, 3]) \u003d [1, 2, 40, 3]) \u003d\u003e ((up1(2)(30)([1, 2]) \u003d [1, 30]) \u003d\u003e ((up1(3)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e ((up1(4)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e ((up2(1)(\u0027a\u0027)(\"12345\") \u003d \"a2345\") \u003d\u003e pre_(up23)))))))","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e ((up1(3)(40)([1, 2, 4, 3]) \u003d [1, 2, 40, 3]) \u003d\u003e ((up1(2)(30)([1, 2]) \u003d [1, 30]) \u003d\u003e ((up1(3)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e ((up1(4)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e ((up2(1)(\u0027a\u0027)(\"12345\") \u003d \"a2345\") \u003d\u003e ((up2(3)(\u0027b\u0027)(\"1243\") \u003d \"12b3\") \u003d\u003e pre_(up2(3)(\u0027c\u0027)\"123\"))))))))","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e ((up1(3)(40)([1, 2, 4, 3]) \u003d [1, 2, 40, 3]) \u003d\u003e ((up1(2)(30)([1, 2]) \u003d [1, 30]) \u003d\u003e ((up1(3)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e ((up1(4)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e ((up2(1)(\u0027a\u0027)(\"12345\") \u003d \"a2345\") \u003d\u003e ((up2(3)(\u0027b\u0027)(\"1243\") \u003d \"12b3\") \u003d\u003e pre_(up2(3)\u0027c\u0027))))))))","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e ((up1(3)(40)([1, 2, 4, 3]) \u003d [1, 2, 40, 3]) \u003d\u003e ((up1(2)(30)([1, 2]) \u003d [1, 30]) \u003d\u003e ((up1(3)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e ((up1(4)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e ((up2(1)(\u0027a\u0027)(\"12345\") \u003d \"a2345\") \u003d\u003e ((up2(3)(\u0027b\u0027)(\"1243\") \u003d \"12b3\") \u003d\u003e pre_(up23))))))))","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e ((up1(3)(40)([1, 2, 4, 3]) \u003d [1, 2, 40, 3]) \u003d\u003e ((up1(2)(30)([1, 2]) \u003d [1, 30]) \u003d\u003e ((up1(3)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e ((up1(4)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e ((up2(1)(\u0027a\u0027)(\"12345\") \u003d \"a2345\") \u003d\u003e ((up2(3)(\u0027b\u0027)(\"1243\") \u003d \"12b3\") \u003d\u003e ((up2(3)(\u0027c\u0027)(\"123\") \u003d \"12c\") \u003d\u003e pre_(up2(3)(\u0027c\u0027)\"12\")))))))))","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e ((up1(3)(40)([1, 2, 4, 3]) \u003d [1, 2, 40, 3]) \u003d\u003e ((up1(2)(30)([1, 2]) \u003d [1, 30]) \u003d\u003e ((up1(3)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e ((up1(4)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e ((up2(1)(\u0027a\u0027)(\"12345\") \u003d \"a2345\") \u003d\u003e ((up2(3)(\u0027b\u0027)(\"1243\") \u003d \"12b3\") \u003d\u003e ((up2(3)(\u0027c\u0027)(\"123\") \u003d \"12c\") \u003d\u003e pre_(up2(3)\u0027c\u0027)))))))))","legal function application obligation:((up1(1)(10)([1, 2, 3, 4, 5]) \u003d [10, 2, 3, 4, 5]) \u003d\u003e ((up1(3)(40)([1, 2, 4, 3]) \u003d [1, 2, 40, 3]) \u003d\u003e ((up1(2)(30)([1, 2]) \u003d [1, 30]) \u003d\u003e ((up1(3)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e ((up1(4)(30)([1, 2]) \u003d [1, 2]) \u003d\u003e ((up2(1)(\u0027a\u0027)(\"12345\") \u003d \"a2345\") \u003d\u003e ((up2(3)(\u0027b\u0027)(\"1243\") \u003d \"12b3\") \u003d\u003e ((up2(3)(\u0027c\u0027)(\"123\") \u003d \"12c\") \u003d\u003e pre_(up23)))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(removeDup[])","legal function application obligation:((removeDup([]) \u003d []) \u003d\u003e pre_(removeDup[1, 1, 2, 2, 2, 3, 4, 4, 4, 4]))","legal function application obligation:((removeDup([]) \u003d []) \u003d\u003e ((removeDup([1, 1, 2, 2, 2, 3, 4, 4, 4, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e pre_(removeDup[1, 2, 3, 4])))","legal function application obligation:((removeDup([]) \u003d []) \u003d\u003e ((removeDup([1, 1, 2, 2, 2, 3, 4, 4, 4, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeDup([1, 2, 3, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e pre_(removeMember(1)[]))))","legal function application obligation:((removeDup([]) \u003d []) \u003d\u003e ((removeDup([1, 1, 2, 2, 2, 3, 4, 4, 4, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeDup([1, 2, 3, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e pre_(removeMember1))))","legal function application obligation:((removeDup([]) \u003d []) \u003d\u003e ((removeDup([1, 1, 2, 2, 2, 3, 4, 4, 4, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeDup([1, 2, 3, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeMember(1)([]) \u003d []) \u003d\u003e pre_(removeMember(1)[1, 2, 3])))))","legal function application obligation:((removeDup([]) \u003d []) \u003d\u003e ((removeDup([1, 1, 2, 2, 2, 3, 4, 4, 4, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeDup([1, 2, 3, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeMember(1)([]) \u003d []) \u003d\u003e pre_(removeMember1)))))","legal function application obligation:((removeDup([]) \u003d []) \u003d\u003e ((removeDup([1, 1, 2, 2, 2, 3, 4, 4, 4, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeDup([1, 2, 3, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeMember(1)([]) \u003d []) \u003d\u003e ((removeMember(1)([1, 2, 3]) \u003d [2, 3]) \u003d\u003e pre_(removeMember(4)[1, 2, 3]))))))","legal function application obligation:((removeDup([]) \u003d []) \u003d\u003e ((removeDup([1, 1, 2, 2, 2, 3, 4, 4, 4, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeDup([1, 2, 3, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeMember(1)([]) \u003d []) \u003d\u003e ((removeMember(1)([1, 2, 3]) \u003d [2, 3]) \u003d\u003e pre_(removeMember4))))))","legal function application obligation:((removeDup([]) \u003d []) \u003d\u003e ((removeDup([1, 1, 2, 2, 2, 3, 4, 4, 4, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeDup([1, 2, 3, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeMember(1)([]) \u003d []) \u003d\u003e ((removeMember(1)([1, 2, 3]) \u003d [2, 3]) \u003d\u003e ((removeMember(4)([1, 2, 3]) \u003d [1, 2, 3]) \u003d\u003e pre_(removeMembers([])[])))))))","legal function application obligation:((removeDup([]) \u003d []) \u003d\u003e ((removeDup([1, 1, 2, 2, 2, 3, 4, 4, 4, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeDup([1, 2, 3, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeMember(1)([]) \u003d []) \u003d\u003e ((removeMember(1)([1, 2, 3]) \u003d [2, 3]) \u003d\u003e ((removeMember(4)([1, 2, 3]) \u003d [1, 2, 3]) \u003d\u003e pre_(removeMembers[])))))))","legal function application obligation:((removeDup([]) \u003d []) \u003d\u003e ((removeDup([1, 1, 2, 2, 2, 3, 4, 4, 4, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeDup([1, 2, 3, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeMember(1)([]) \u003d []) \u003d\u003e ((removeMember(1)([1, 2, 3]) \u003d [2, 3]) \u003d\u003e ((removeMember(4)([1, 2, 3]) \u003d [1, 2, 3]) \u003d\u003e ((removeMembers([])([]) \u003d []) \u003d\u003e pre_(removeMembers([])[1, 2, 3]))))))))","legal function application obligation:((removeDup([]) \u003d []) \u003d\u003e ((removeDup([1, 1, 2, 2, 2, 3, 4, 4, 4, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeDup([1, 2, 3, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeMember(1)([]) \u003d []) \u003d\u003e ((removeMember(1)([1, 2, 3]) \u003d [2, 3]) \u003d\u003e ((removeMember(4)([1, 2, 3]) \u003d [1, 2, 3]) \u003d\u003e ((removeMembers([])([]) \u003d []) \u003d\u003e pre_(removeMembers[]))))))))","legal function application obligation:((removeDup([]) \u003d []) \u003d\u003e ((removeDup([1, 1, 2, 2, 2, 3, 4, 4, 4, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeDup([1, 2, 3, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeMember(1)([]) \u003d []) \u003d\u003e ((removeMember(1)([1, 2, 3]) \u003d [2, 3]) \u003d\u003e ((removeMember(4)([1, 2, 3]) \u003d [1, 2, 3]) \u003d\u003e ((removeMembers([])([]) \u003d []) \u003d\u003e ((removeMembers([])([1, 2, 3]) \u003d [1, 2, 3]) \u003d\u003e pre_(removeMembers([1, 2, 3])[])))))))))","legal function application obligation:((removeDup([]) \u003d []) \u003d\u003e ((removeDup([1, 1, 2, 2, 2, 3, 4, 4, 4, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeDup([1, 2, 3, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeMember(1)([]) \u003d []) \u003d\u003e ((removeMember(1)([1, 2, 3]) \u003d [2, 3]) \u003d\u003e ((removeMember(4)([1, 2, 3]) \u003d [1, 2, 3]) \u003d\u003e ((removeMembers([])([]) \u003d []) \u003d\u003e ((removeMembers([])([1, 2, 3]) \u003d [1, 2, 3]) \u003d\u003e pre_(removeMembers[1, 2, 3])))))))))","legal function application obligation:((removeDup([]) \u003d []) \u003d\u003e ((removeDup([1, 1, 2, 2, 2, 3, 4, 4, 4, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeDup([1, 2, 3, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeMember(1)([]) \u003d []) \u003d\u003e ((removeMember(1)([1, 2, 3]) \u003d [2, 3]) \u003d\u003e ((removeMember(4)([1, 2, 3]) \u003d [1, 2, 3]) \u003d\u003e ((removeMembers([])([]) \u003d []) \u003d\u003e ((removeMembers([])([1, 2, 3]) \u003d [1, 2, 3]) \u003d\u003e ((removeMembers([1, 2, 3])([]) \u003d []) \u003d\u003e pre_(removeMembers([1, 2, 3])[1, 2, 3]))))))))))","legal function application obligation:((removeDup([]) \u003d []) \u003d\u003e ((removeDup([1, 1, 2, 2, 2, 3, 4, 4, 4, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeDup([1, 2, 3, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeMember(1)([]) \u003d []) \u003d\u003e ((removeMember(1)([1, 2, 3]) \u003d [2, 3]) \u003d\u003e ((removeMember(4)([1, 2, 3]) \u003d [1, 2, 3]) \u003d\u003e ((removeMembers([])([]) \u003d []) \u003d\u003e ((removeMembers([])([1, 2, 3]) \u003d [1, 2, 3]) \u003d\u003e ((removeMembers([1, 2, 3])([]) \u003d []) \u003d\u003e pre_(removeMembers[1, 2, 3]))))))))))","legal function application obligation:((removeDup([]) \u003d []) \u003d\u003e ((removeDup([1, 1, 2, 2, 2, 3, 4, 4, 4, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeDup([1, 2, 3, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeMember(1)([]) \u003d []) \u003d\u003e ((removeMember(1)([1, 2, 3]) \u003d [2, 3]) \u003d\u003e ((removeMember(4)([1, 2, 3]) \u003d [1, 2, 3]) \u003d\u003e ((removeMembers([])([]) \u003d []) \u003d\u003e ((removeMembers([])([1, 2, 3]) \u003d [1, 2, 3]) \u003d\u003e ((removeMembers([1, 2, 3])([]) \u003d []) \u003d\u003e ((removeMembers([1, 2, 3])([1, 2, 3]) \u003d []) \u003d\u003e pre_(removeMembers([1, 4, 5])[1, 2, 3, 4])))))))))))","legal function application obligation:((removeDup([]) \u003d []) \u003d\u003e ((removeDup([1, 1, 2, 2, 2, 3, 4, 4, 4, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeDup([1, 2, 3, 4]) \u003d [1, 2, 3, 4]) \u003d\u003e ((removeMember(1)([]) \u003d []) \u003d\u003e ((removeMember(1)([1, 2, 3]) \u003d [2, 3]) \u003d\u003e ((removeMember(4)([1, 2, 3]) \u003d [1, 2, 3]) \u003d\u003e ((removeMembers([])([]) \u003d []) \u003d\u003e ((removeMembers([])([1, 2, 3]) \u003d [1, 2, 3]) \u003d\u003e ((removeMembers([1, 2, 3])([]) \u003d []) \u003d\u003e ((removeMembers([1, 2, 3])([1, 2, 3]) \u003d []) \u003d\u003e pre_(removeMembers[1, 4, 5])))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(zip[], [])","legal function application obligation:((zip([], []) \u003d []) \u003d\u003e pre_(zip[1, 2, 3], [\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]))","legal function application obligation:((zip([], []) \u003d []) \u003d\u003e ((zip([1, 2, 3], [\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d [mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027), mk_(3, \u0027c\u0027)]) \u003d\u003e pre_(zip[1, 2], [\u0027a\u0027, \u0027b\u0027, \u0027c\u0027])))","legal function application obligation:((zip([], []) \u003d []) \u003d\u003e ((zip([1, 2, 3], [\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d [mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027), mk_(3, \u0027c\u0027)]) \u003d\u003e ((zip([1, 2], [\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d [mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027)]) \u003d\u003e pre_(zip[1, 2, 3], [\u0027a\u0027, \u0027b\u0027]))))","legal function application obligation:((zip([], []) \u003d []) \u003d\u003e ((zip([1, 2, 3], [\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d [mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027), mk_(3, \u0027c\u0027)]) \u003d\u003e ((zip([1, 2], [\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d [mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027)]) \u003d\u003e ((zip([1, 2, 3], [\u0027a\u0027, \u0027b\u0027]) \u003d [mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027)]) \u003d\u003e pre_(zip2([])[])))))","legal function application obligation:((zip([], []) \u003d []) \u003d\u003e ((zip([1, 2, 3], [\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d [mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027), mk_(3, \u0027c\u0027)]) \u003d\u003e ((zip([1, 2], [\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d [mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027)]) \u003d\u003e ((zip([1, 2, 3], [\u0027a\u0027, \u0027b\u0027]) \u003d [mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027)]) \u003d\u003e pre_(zip2[])))))","legal function application obligation:((zip([], []) \u003d []) \u003d\u003e ((zip([1, 2, 3], [\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d [mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027), mk_(3, \u0027c\u0027)]) \u003d\u003e ((zip([1, 2], [\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d [mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027)]) \u003d\u003e ((zip([1, 2, 3], [\u0027a\u0027, \u0027b\u0027]) \u003d [mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027)]) \u003d\u003e ((zip2([])([]) \u003d []) \u003d\u003e pre_(zip2([1, 2, 3])[\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]))))))","legal function application obligation:((zip([], []) \u003d []) \u003d\u003e ((zip([1, 2, 3], [\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d [mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027), mk_(3, \u0027c\u0027)]) \u003d\u003e ((zip([1, 2], [\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d [mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027)]) \u003d\u003e ((zip([1, 2, 3], [\u0027a\u0027, \u0027b\u0027]) \u003d [mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027)]) \u003d\u003e ((zip2([])([]) \u003d []) \u003d\u003e pre_(zip2[1, 2, 3]))))))","legal function application obligation:((zip([], []) \u003d []) \u003d\u003e ((zip([1, 2, 3], [\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d [mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027), mk_(3, \u0027c\u0027)]) \u003d\u003e ((zip([1, 2], [\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d [mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027)]) \u003d\u003e ((zip([1, 2, 3], [\u0027a\u0027, \u0027b\u0027]) \u003d [mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027)]) \u003d\u003e ((zip2([])([]) \u003d []) \u003d\u003e ((zip2([1, 2, 3])([\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d [mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027), mk_(3, \u0027c\u0027)]) \u003d\u003e pre_(unzip[])))))))","legal function application obligation:((zip([], []) \u003d []) \u003d\u003e ((zip([1, 2, 3], [\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d [mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027), mk_(3, \u0027c\u0027)]) \u003d\u003e ((zip([1, 2], [\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d [mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027)]) \u003d\u003e ((zip([1, 2, 3], [\u0027a\u0027, \u0027b\u0027]) \u003d [mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027)]) \u003d\u003e ((zip2([])([]) \u003d []) \u003d\u003e ((zip2([1, 2, 3])([\u0027a\u0027, \u0027b\u0027, \u0027c\u0027]) \u003d [mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027), mk_(3, \u0027c\u0027)]) \u003d\u003e ((unzip([]) \u003d mk_([], [])) \u003d\u003e pre_(unzip[mk_(1, \u0027a\u0027), mk_(2, \u0027b\u0027), mk_(3, \u0027c\u0027)]))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(span(p1)[])","legal function application obligation:pre_(spanp1)","legal function application obligation:((span(p1)([]) \u003d mk_([], [])) \u003d\u003e pre_(span(p1)[2, 4, 6, 1, 3]))","legal function application obligation:((span(p1)([]) \u003d mk_([], [])) \u003d\u003e pre_(spanp1))","legal function application obligation:((span(p1)([]) \u003d mk_([], [])) \u003d\u003e ((span(p1)([2, 4, 6, 1, 3]) \u003d mk_([2, 4, 6], [1, 3])) \u003d\u003e pre_(span(p2)[1, 2, 3, 4, 5])))","legal function application obligation:((span(p1)([]) \u003d mk_([], [])) \u003d\u003e ((span(p1)([2, 4, 6, 1, 3]) \u003d mk_([2, 4, 6], [1, 3])) \u003d\u003e pre_(spanp2)))","legal function application obligation:((span(p1)([]) \u003d mk_([], [])) \u003d\u003e ((span(p1)([2, 4, 6, 1, 3]) \u003d mk_([2, 4, 6], [1, 3])) \u003d\u003e ((span(p2)([1, 2, 3, 4, 5]) \u003d mk_([1, 2, 3, 4, 5], [])) \u003d\u003e pre_(span(p2)[1, 2, 12, 13, 4, 15]))))","legal function application obligation:((span(p1)([]) \u003d mk_([], [])) \u003d\u003e ((span(p1)([2, 4, 6, 1, 3]) \u003d mk_([2, 4, 6], [1, 3])) \u003d\u003e ((span(p2)([1, 2, 3, 4, 5]) \u003d mk_([1, 2, 3, 4, 5], [])) \u003d\u003e pre_(spanp2))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(takeWhile(p1)[])","legal function application obligation:pre_(takeWhilep1)","legal function application obligation:((takeWhile(p1)([]) \u003d []) \u003d\u003e pre_(takeWhile(p1)[2, 4, 6, 8, 1, 3, 5, 2, 4]))","legal function application obligation:((takeWhile(p1)([]) \u003d []) \u003d\u003e pre_(takeWhilep1))","legal function application obligation:((takeWhile(p1)([]) \u003d []) \u003d\u003e ((takeWhile(p1)([2, 4, 6, 8, 1, 3, 5, 2, 4]) \u003d [2, 4, 6, 8]) \u003d\u003e pre_(dropWhile(p1)[])))","legal function application obligation:((takeWhile(p1)([]) \u003d []) \u003d\u003e ((takeWhile(p1)([2, 4, 6, 8, 1, 3, 5, 2, 4]) \u003d [2, 4, 6, 8]) \u003d\u003e pre_(dropWhilep1)))","legal function application obligation:((takeWhile(p1)([]) \u003d []) \u003d\u003e ((takeWhile(p1)([2, 4, 6, 8, 1, 3, 5, 2, 4]) \u003d [2, 4, 6, 8]) \u003d\u003e ((dropWhile(p1)([]) \u003d []) \u003d\u003e pre_(dropWhile(p1)[2, 4, 6, 8, 1, 2, 3, 4, 5]))))","legal function application obligation:((takeWhile(p1)([]) \u003d []) \u003d\u003e ((takeWhile(p1)([2, 4, 6, 8, 1, 3, 5, 2, 4]) \u003d [2, 4, 6, 8]) \u003d\u003e ((dropWhile(p1)([]) \u003d []) \u003d\u003e pre_(dropWhilep1))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(foldl(plus)(0)[1, 2, 3])","legal function application obligation:pre_(foldl(plus)0)","legal function application obligation:pre_(foldlplus)","legal function application obligation:((foldl(plus)(0)([1, 2, 3]) \u003d 6) \u003d\u003e pre_(foldl(product)(1)[2, 3, 4]))","legal function application obligation:((foldl(plus)(0)([1, 2, 3]) \u003d 6) \u003d\u003e pre_(foldl(product)1))","legal function application obligation:((foldl(plus)(0)([1, 2, 3]) \u003d 6) \u003d\u003e pre_(foldlproduct))","legal function application obligation:((foldl(plus)(0)([1, 2, 3]) \u003d 6) \u003d\u003e ((foldl(product)(1)([2, 3, 4]) \u003d 24) \u003d\u003e pre_(f2(append)([])\"abc\")))","legal function application obligation:((foldl(plus)(0)([1, 2, 3]) \u003d 6) \u003d\u003e ((foldl(product)(1)([2, 3, 4]) \u003d 24) \u003d\u003e pre_(f2(append)[])))","legal function application obligation:((foldl(plus)(0)([1, 2, 3]) \u003d 6) \u003d\u003e ((foldl(product)(1)([2, 3, 4]) \u003d 24) \u003d\u003e pre_(f2append)))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(foldr(plus)(0)[1, 2, 3])","legal function application obligation:pre_(foldr(plus)0)","legal function application obligation:pre_(foldrplus)","legal function application obligation:((foldr(plus)(0)([1, 2, 3]) \u003d 6) \u003d\u003e pre_(foldr(product)(1)[2, 3, 4]))","legal function application obligation:((foldr(plus)(0)([1, 2, 3]) \u003d 6) \u003d\u003e pre_(foldr(product)1))","legal function application obligation:((foldr(plus)(0)([1, 2, 3]) \u003d 6) \u003d\u003e pre_(foldrproduct))","legal function application obligation:((foldr(plus)(0)([1, 2, 3]) \u003d 6) \u003d\u003e ((foldr(product)(1)([2, 3, 4]) \u003d 24) \u003d\u003e pre_(f3(removeAt)(\"12345\")[1, 3, 5])))","legal function application obligation:((foldr(plus)(0)([1, 2, 3]) \u003d 6) \u003d\u003e ((foldr(product)(1)([2, 3, 4]) \u003d 24) \u003d\u003e pre_(f3(removeAt)\"12345\")))","legal function application obligation:((foldr(plus)(0)([1, 2, 3]) \u003d 6) \u003d\u003e ((foldr(product)(1)([2, 3, 4]) \u003d 24) \u003d\u003e pre_(f3removeAt)))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(Real`EQ(((sq.GetAverage))[real]([1.1, 2.2, 3.3]))2.2)","type compatibility obligation:is_(((sq.GetAverage))[real]([1.1, 2.2, 3.3]), real)","legal function application obligation:pre_(((sq.GetAverage))[real][1.1, 2.2, 3.3])","legal function application obligation:(Real`EQ(((sq.GetAverage))[real]([1.1, 2.2, 3.3]))(2.2) \u003d\u003e pre_(Real`EQ(((sq.GetAverage))[real]([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]))5.5))","type compatibility obligation:(Real`EQ(((sq.GetAverage))[real]([1.1, 2.2, 3.3]))(2.2) \u003d\u003e is_(((sq.GetAverage))[real]([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]), real))","legal function application obligation:(Real`EQ(((sq.GetAverage))[real]([1.1, 2.2, 3.3]))(2.2) \u003d\u003e pre_(((sq.GetAverage))[real][1, 2, 3, 4, 5, 6, 7, 8, 9, 10]))","type compatibility obligation:is_(RESULT, ())","type compatibility obligation:is_(RESULT, ())","type compatibility obligation:is_(RESULT, ())","enumeration map injectivity obligation:(forall m1, m2 in set {{\u00270\u0027 |-\u003e 1}, {\u00271\u0027 |-\u003e 2}, {\u00272\u0027 |-\u003e 3}, {\u00273\u0027 |-\u003e 4}, {\u00274\u0027 |-\u003e 5}, {\u00275\u0027 |-\u003e 6}, {\u00276\u0027 |-\u003e 7}, {\u00277\u0027 |-\u003e 8}, {\u00278\u0027 |-\u003e 9}, {\u00279\u0027 |-\u003e 10}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","enumeration map injectivity obligation:(forall m1, m2 in set {{\u0027A\u0027 |-\u003e 12}, {\u0027B\u0027 |-\u003e 14}, {\u0027C\u0027 |-\u003e 16}, {\u0027D\u0027 |-\u003e 18}, {\u0027E\u0027 |-\u003e 20}, {\u0027F\u0027 |-\u003e 22}, {\u0027G\u0027 |-\u003e 24}, {\u0027H\u0027 |-\u003e 26}, {\u0027I\u0027 |-\u003e 28}, {\u0027J\u0027 |-\u003e 30}, {\u0027K\u0027 |-\u003e 32}, {\u0027L\u0027 |-\u003e 34}, {\u0027M\u0027 |-\u003e 36}, {\u0027N\u0027 |-\u003e 38}, {\u0027O\u0027 |-\u003e 40}, {\u0027P\u0027 |-\u003e 42}, {\u0027Q\u0027 |-\u003e 44}, {\u0027R\u0027 |-\u003e 46}, {\u0027S\u0027 |-\u003e 48}, {\u0027T\u0027 |-\u003e 50}, {\u0027U\u0027 |-\u003e 52}, {\u0027V\u0027 |-\u003e 54}, {\u0027W\u0027 |-\u003e 56}, {\u0027X\u0027 |-\u003e 58}, {\u0027Y\u0027 |-\u003e 60}, {\u0027Z\u0027 |-\u003e 62}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","enumeration map injectivity obligation:(forall m1, m2 in set {{\u0027a\u0027 |-\u003e 11}, {\u0027b\u0027 |-\u003e 13}, {\u0027c\u0027 |-\u003e 15}, {\u0027d\u0027 |-\u003e 17}, {\u0027e\u0027 |-\u003e 19}, {\u0027f\u0027 |-\u003e 21}, {\u0027g\u0027 |-\u003e 23}, {\u0027h\u0027 |-\u003e 25}, {\u0027i\u0027 |-\u003e 27}, {\u0027j\u0027 |-\u003e 29}, {\u0027k\u0027 |-\u003e 31}, {\u0027l\u0027 |-\u003e 33}, {\u0027m\u0027 |-\u003e 35}, {\u0027n\u0027 |-\u003e 37}, {\u0027o\u0027 |-\u003e 39}, {\u0027p\u0027 |-\u003e 41}, {\u0027q\u0027 |-\u003e 43}, {\u0027r\u0027 |-\u003e 45}, {\u0027s\u0027 |-\u003e 47}, {\u0027t\u0027 |-\u003e 49}, {\u0027u\u0027 |-\u003e 51}, {\u0027v\u0027 |-\u003e 53}, {\u0027w\u0027 |-\u003e 55}, {\u0027x\u0027 |-\u003e 57}, {\u0027y\u0027 |-\u003e 59}, {\u0027z\u0027 |-\u003e 61}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","map compatible obligation:(forall ldom1 in set (dom vNumOrderMap), rdom2 in set (dom vChapitalCharOrderMap) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (vNumOrderMap(ldom1) \u003d vChapitalCharOrderMap(rdom2))))","map compatible obligation:(forall ldom1 in set (dom (vNumOrderMap munion vChapitalCharOrderMap)), rdom2 in set (dom vSmallCharOrderMap) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e ((vNumOrderMap munion vChapitalCharOrderMap)(ldom1) \u003d vSmallCharOrderMap(rdom2))))","type compatibility obligation:(forall c:char \u0026 (is_((if isDigit(c)\nthen let s:seq1 of (char) \u003d [c] in let mk_(-, i):(bool * [int]) \u003d (VDMUtil`seq_of_char2val)[int](s) in i\nelse false), bool) or is_((if isDigit(c)\nthen let s:seq1 of (char) \u003d [c] in let mk_(-, i):(bool * [int]) \u003d (VDMUtil`seq_of_char2val)[int](s) in i\nelse false), int)))","legal map application obligation:(forall c:char \u0026 ((c in set (dom vCharOrderMap)) \u003d\u003e (c in set (dom vCharOrderMap))))","map compatible obligation:(forall c:char \u0026 (forall ldom1 in set (dom vChapitalCharOrderMap), rdom2 in set (dom vSmallCharOrderMap) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (vChapitalCharOrderMap(ldom1) \u003d vSmallCharOrderMap(rdom2)))))","legal function application obligation:(forall c1:char, c2:char \u0026 pre_(Character`LT2(c1)c2))","legal function application obligation:(forall c1:char, c2:char \u0026 pre_(Character`LE2(c1)c2))","legal function application obligation:(forall c1:char, c2:char \u0026 pre_(Character`LT2(c1)c2))","legal function application obligation:(forall c1:char, c2:char \u0026 pre_(Character`GT2(c1)c2))","legal function application obligation:(forall c1:char, c2:char \u0026 pre_(Character`LT2(c2)c1))","legal function application obligation:(forall c1:char, c2:char \u0026 pre_(Character`GE2(c1)c2))","legal function application obligation:(forall c1:char, c2:char \u0026 pre_(Character`LT2(c1)c2))","legal map application obligation:(forall aMap:map (@T1) to (@T2), aKey:@T1 \u0026 ((aKey in set (dom aMap)) \u003d\u003e (aKey in set (dom aMap))))","legal function application obligation:pre_((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(-3)4)","legal function application obligation:pre_((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))-3)","legal function application obligation:(((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(-3)(4) \u003d -3) \u003d\u003e pre_((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(4)-3))","legal function application obligation:(((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(-3)(4) \u003d -3) \u003d\u003e pre_((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))4))","legal function application obligation:(((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(-3)(4) \u003d -3) \u003d\u003e (((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(4)(-3) \u003d -3) \u003d\u003e pre_((Number`min)[nat]((lambda [x:nat, y:nat] \u0026 (x \u003c y)))(2)10)))","legal function application obligation:(((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(-3)(4) \u003d -3) \u003d\u003e (((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(4)(-3) \u003d -3) \u003d\u003e pre_((Number`min)[nat]((lambda [x:nat, y:nat] \u0026 (x \u003c y)))2)))","legal function application obligation:(((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(-3)(4) \u003d -3) \u003d\u003e (((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(4)(-3) \u003d -3) \u003d\u003e (((Number`min)[nat]((lambda [x:nat, y:nat] \u0026 (x \u003c y)))(2)(10) \u003d 2) \u003d\u003e pre_((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(0)0))))","legal function application obligation:(((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(-3)(4) \u003d -3) \u003d\u003e (((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(4)(-3) \u003d -3) \u003d\u003e (((Number`min)[nat]((lambda [x:nat, y:nat] \u0026 (x \u003c y)))(2)(10) \u003d 2) \u003d\u003e pre_((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))0))))","legal function application obligation:(((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(-3)(4) \u003d -3) \u003d\u003e (((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(4)(-3) \u003d -3) \u003d\u003e (((Number`min)[nat]((lambda [x:nat, y:nat] \u0026 (x \u003c y)))(2)(10) \u003d 2) \u003d\u003e (((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(0)(0) \u003d 0) \u003d\u003e pre_((Number`max)[real]((lambda [x:real, y:real] \u0026 (x \u003c y)))(0.001)-0.001)))))","legal function application obligation:(((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(-3)(4) \u003d -3) \u003d\u003e (((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(4)(-3) \u003d -3) \u003d\u003e (((Number`min)[nat]((lambda [x:nat, y:nat] \u0026 (x \u003c y)))(2)(10) \u003d 2) \u003d\u003e (((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(0)(0) \u003d 0) \u003d\u003e pre_((Number`max)[real]((lambda [x:real, y:real] \u0026 (x \u003c y)))0.001)))))","legal function application obligation:(((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(-3)(4) \u003d -3) \u003d\u003e (((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(4)(-3) \u003d -3) \u003d\u003e (((Number`min)[nat]((lambda [x:nat, y:nat] \u0026 (x \u003c y)))(2)(10) \u003d 2) \u003d\u003e (((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(0)(0) \u003d 0) \u003d\u003e (((Number`max)[real]((lambda [x:real, y:real] \u0026 (x \u003c y)))(0.001)(-0.001) \u003d 0.001) \u003d\u003e pre_((Number`max)[real]((lambda [x:real, y:real] \u0026 (x \u003c y)))(-0.001)0.001))))))","legal function application obligation:(((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(-3)(4) \u003d -3) \u003d\u003e (((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(4)(-3) \u003d -3) \u003d\u003e (((Number`min)[nat]((lambda [x:nat, y:nat] \u0026 (x \u003c y)))(2)(10) \u003d 2) \u003d\u003e (((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(0)(0) \u003d 0) \u003d\u003e (((Number`max)[real]((lambda [x:real, y:real] \u0026 (x \u003c y)))(0.001)(-0.001) \u003d 0.001) \u003d\u003e pre_((Number`max)[real]((lambda [x:real, y:real] \u0026 (x \u003c y)))-0.001))))))","legal function application obligation:(((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(-3)(4) \u003d -3) \u003d\u003e (((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(4)(-3) \u003d -3) \u003d\u003e (((Number`min)[nat]((lambda [x:nat, y:nat] \u0026 (x \u003c y)))(2)(10) \u003d 2) \u003d\u003e (((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(0)(0) \u003d 0) \u003d\u003e (((Number`max)[real]((lambda [x:real, y:real] \u0026 (x \u003c y)))(0.001)(-0.001) \u003d 0.001) \u003d\u003e (((Number`max)[real]((lambda [x:real, y:real] \u0026 (x \u003c y)))(-0.001)(0.001) \u003d 0.001) \u003d\u003e pre_((Number`max)[real]((lambda [x:real, y:real] \u0026 (x \u003c y)))(0.0)0.0)))))))","legal function application obligation:(((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(-3)(4) \u003d -3) \u003d\u003e (((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(4)(-3) \u003d -3) \u003d\u003e (((Number`min)[nat]((lambda [x:nat, y:nat] \u0026 (x \u003c y)))(2)(10) \u003d 2) \u003d\u003e (((Number`min)[int]((lambda [x:int, y:int] \u0026 (x \u003c y)))(0)(0) \u003d 0) \u003d\u003e (((Number`max)[real]((lambda [x:real, y:real] \u0026 (x \u003c y)))(0.001)(-0.001) \u003d 0.001) \u003d\u003e (((Number`max)[real]((lambda [x:real, y:real] \u0026 (x \u003c y)))(-0.001)(0.001) \u003d 0.001) \u003d\u003e pre_((Number`max)[real]((lambda [x:real, y:real] \u0026 (x \u003c y)))0.0)))))))","type compatibility obligation:is_(RESULT, ())","type compatibility obligation:(((Number`isComputable)[char](\u0027a\u0027) \u003d false) \u003d\u003e (((Number`isComputable)[int](-9) \u003d true) \u003d\u003e (((Number`isComputable)[nat](0) \u003d true) \u003d\u003e (((Number`isComputable)[nat1](1) \u003d true) \u003d\u003e (((Number`isComputable)[real](1.234) \u003d true) \u003d\u003e is_(1.234, rat))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((Number`min)[seq of (int)]((lambda [s1:seq of (int), s2:seq of (int)] \u0026 ((len s1) \u003c (len s2))))([1, 2])[1, 2, 3])","legal function application obligation:pre_((Number`min)[seq of (int)]((lambda [s1:seq of (int), s2:seq of (int)] \u0026 ((len s1) \u003c (len s2))))[1, 2])","legal function application obligation:(((Number`min)[seq of (int)]((lambda [s1:seq of (int), s2:seq of (int)] \u0026 ((len s1) \u003c (len s2))))([1, 2])([1, 2, 3]) \u003d [1, 2]) \u003d\u003e pre_((Number`max)[seq of (int)]((lambda [s1:seq of (int), s2:seq of (int)] \u0026 ((len s1) \u003c (len s2))))([1, 2])[1, 2, 3]))","legal function application obligation:(((Number`min)[seq of (int)]((lambda [s1:seq of (int), s2:seq of (int)] \u0026 ((len s1) \u003c (len s2))))([1, 2])([1, 2, 3]) \u003d [1, 2]) \u003d\u003e pre_((Number`max)[seq of (int)]((lambda [s1:seq of (int), s2:seq of (int)] \u0026 ((len s1) \u003c (len s2))))[1, 2]))","type compatibility obligation:is_(RESULT, ())","type invariant satisfiable obligation:(exists d:NumberOfDayOfTheWeek \u0026 (d \u003c\u003d 6))","type compatibility obligation:(forall date:Date \u0026 (inv_NumberOfDayOfTheWeek(let modifiedJulianDate:int \u003d (floor (date.getModifiedJulianDate)()) in ((modifiedJulianDate - 4) mod daysInWeek)) and is_(let modifiedJulianDate:int \u003d (floor (date.getModifiedJulianDate)()) in ((modifiedJulianDate - 4) mod daysInWeek), nat)))","legal sequence application obligation:(forall date:Date \u0026 ((getNumberOfDayOfTheWeek(date) + 1) in set (inds namesOfDayOfTheWeek)))","legal function application obligation:(forall nameOfDayOfTheWeek:NameOfDayOfTheWeek \u0026 pre_((Sequence`Index)[NameOfDayOfTheWeek](nameOfDayOfTheWeek)namesOfDayOfTheWeek))","type compatibility obligation:(forall nameOfDayOfTheWeek:NameOfDayOfTheWeek \u0026 (inv_NumberOfDayOfTheWeek(((Sequence`Index)[NameOfDayOfTheWeek](nameOfDayOfTheWeek)(namesOfDayOfTheWeek) - 1)) and is_(((Sequence`Index)[NameOfDayOfTheWeek](nameOfDayOfTheWeek)(namesOfDayOfTheWeek) - 1), nat)))","cases exhaustive obligation:(forall year:int, month:int, nameOfDayOfTheWeek:NameOfDayOfTheWeek \u0026 let numberOfDayOfTheWeek:NumberOfDayOfTheWeek \u003d getNumberOfDayOfTheWeekFromName(nameOfDayOfTheWeek), firstDayOfMonth:Date \u003d getFirstDayOfMonth(year, month), diff:int \u003d (numberOfDayOfTheWeek - getNumberOfDayOfTheWeek(firstDayOfMonth)) in (((true \u003d (diff \u003d 0)) or (true \u003d (diff \u003e 0))) or (true \u003d (diff \u003c 0))))","legal function application obligation:(forall date1:Date, date2:Date, nameOfDayOfTheWeek:NameOfDayOfTheWeek \u0026 pre_(min(date1)date2))","legal function application obligation:(forall date1:Date, date2:Date, nameOfDayOfTheWeek:NameOfDayOfTheWeek \u0026 pre_(max(date1)date2))","non-zero obligation:(forall date1:Date, date2:Date, nameOfDayOfTheWeek:NameOfDayOfTheWeek \u0026 (daysInWeek \u003c\u003e 0))","non-zero obligation:(forall date:Date \u0026 (averageDaysInMonth \u003c\u003e 0))","non-zero obligation:(forall date:Date \u0026 (daysInYear \u003c\u003e 0))","non-zero obligation:(forall candidateYear:int, candidateOfMonth:int \u0026 ((candidateOfMonth \u003c\u003d 0) \u003d\u003e (monthsInYear \u003c\u003e 0)))","non-zero obligation:(forall candidateYear:int, candidateOfMonth:int \u0026 ((not (candidateOfMonth \u003c\u003d 0)) \u003d\u003e (monthsInYear \u003c\u003e 0)))","non-zero obligation:(forall year:int, month:int, day:int \u0026 (monthsInYear \u003c\u003e 0))","non-zero obligation:(forall year:int, month:int, day:int \u0026 (daysInYear \u003c\u003e 0))","legal function application obligation:(forall date:Date \u0026 pre_((date.date2Str)))","type compatibility obligation:(forall dateStr:seq of (char) \u0026 is_(let date:(Date | bool) \u003d getDateFromString(dateStr) in (if (date \u003d false)\nthen nil\nelse date), [Date]))","legal function application obligation:(forall date1:Date, date2:Date \u0026 pre_(min(date1)date2))","legal function application obligation:(forall date1:Date, date2:Date \u0026 pre_(max(date1)date2))","legal function application obligation:(forall date1:Date, date2:Date \u0026 pre_(min(date1)date2))","legal function application obligation:(forall date1:Date, date2:Date \u0026 pre_(max(date1)date2))","legal function application obligation:(forall date1:Date, date2:Date \u0026 pre_(min(date1)date2))","legal function application obligation:(forall date1:Date, date2:Date \u0026 pre_(max(date1)date2))","recursive function obligation:(forall date:Date \u0026 ((true \u003d (isSundayOrDayoff(date) or isSaturday(date))) \u003d\u003e (getPastWeekdaymeasure(date) \u003e getPastWeekdaymeasure((date.minus)(1)))))","type compatibility obligation:(forall d:Date \u0026 is_((d.getModifiedJulianDate)(), nat))","legal function application obligation:(forall date:Date \u0026 pre_((date.Year)))","non-zero obligation:(forall year:int, month:int, day:int \u0026 (yearInCentury \u003c\u003e 0))","legal function application obligation:(forall yyyymmdd:seq of (char) \u0026 pre_((getDateFrom_yyyy_mm_dd(year, month, day).date2Str)))","legal function application obligation:(forall year:int, dayOfWeek:NameOfDayOfTheWeek \u0026 pre_((self.getNthDayOfTheWeek)year, 1, 1, dayOfWeek))","type compatibility obligation:(forall year:int, dayOfWeek:NameOfDayOfTheWeek \u0026 is_((self.getNthDayOfTheWeek)(year, 1, 1, dayOfWeek), Date))","while loop termination obligation:...","legal function application obligation:(forall year:int, dayOfWeek:NameOfDayOfTheWeek \u0026 pre_((self.lastDayOfTheWeekInMonth)year, 12, dayOfWeek))","legal map application obligation:(forall aYear:int \u0026 (aYear in set (dom (self.Year2Holidays))))","legal function application obligation:(forall fname:seq of (char) \u0026 pre_(((io.freadval))[(int * int * int)]fname))","type compatibility obligation:is_(RESULT, Date)","type compatibility obligation:(forall fname:seq of (char) \u0026 is_(RESULT, Date))","type compatibility obligation:(forall i:int \u0026 ((i \u003c 0) \u003d\u003e (-i \u003e\u003d 0)))","type compatibility obligation:(forall i:int \u0026 ((not (i \u003c 0)) \u003d\u003e (i \u003e\u003d 0)))","type compatibility obligation:(forall n:nat \u0026 let r:int \u003d (n mod 10), q:int \u003d (n div 10) in ((not (0 \u003d q)) \u003d\u003e (q \u003e\u003d 0)))","recursive function obligation:(forall n:nat \u0026 let r:int \u003d (n mod 10), q:int \u003d (n div 10) in ((not (0 \u003d q)) \u003d\u003e (ndiv10(n) \u003e ndiv10(q))))","type compatibility obligation:(forall n:nat \u0026 is_(let r:int \u003d (n mod 10), q:int \u003d (n div 10) in (cases q :\n0 -\u003e asChar(r)\nothers (asStringAux(q) ^ asChar(r))\n end), seq1 of (char)))","type compatibility obligation:(forall n:nat \u0026 ((n div 10) \u003e\u003d 0))","legal sequence application obligation:(forall cobolStrConversionCommand:seq of (char), i:int \u0026 let minusSymbol:char \u003d \u0027-\u0027 in ((i \u003c 0) \u003d\u003e (1 in set (inds cobolStrConversionCommand))))","legal function application obligation:(forall cobolStrConversionCommand:seq of (char), i:int \u0026 let minusSymbol:char \u003d \u0027-\u0027 in ((i \u003c 0) \u003d\u003e ((cobolStrConversionCommand(1) \u003d minusSymbol) \u003d\u003e pre_(asStringZAux(String`subStr(cobolStrConversionCommand, 2, (len cobolStrConversionCommand)))-i, true))))","type compatibility obligation:(forall cobolStrConversionCommand:seq of (char), i:int \u0026 let minusSymbol:char \u003d \u0027-\u0027 in ((i \u003c 0) \u003d\u003e ((cobolStrConversionCommand(1) \u003d minusSymbol) \u003d\u003e (-i \u003e\u003d 0))))","type compatibility obligation:(forall cobolStrConversionCommand:seq of (char), i:int \u0026 let minusSymbol:char \u003d \u0027-\u0027 in ((i \u003c 0) \u003d\u003e ((cobolStrConversionCommand(1) \u003d minusSymbol) \u003d\u003e is_(cobolStrConversionCommand, seq1 of (char)))))","legal function application obligation:(forall cobolStrConversionCommand:seq of (char), i:int \u0026 let minusSymbol:char \u003d \u0027-\u0027 in ((i \u003c 0) \u003d\u003e ((not (cobolStrConversionCommand(1) \u003d minusSymbol)) \u003d\u003e pre_(asStringZAux(cobolStrConversionCommand)-i, true))))","type compatibility obligation:(forall cobolStrConversionCommand:seq of (char), i:int \u0026 let minusSymbol:char \u003d \u0027-\u0027 in ((i \u003c 0) \u003d\u003e ((not (cobolStrConversionCommand(1) \u003d minusSymbol)) \u003d\u003e (-i \u003e\u003d 0))))","legal sequence application obligation:(forall cobolStrConversionCommand:seq of (char), i:int \u0026 let minusSymbol:char \u003d \u0027-\u0027 in ((not (i \u003c 0)) \u003d\u003e (1 in set (inds cobolStrConversionCommand))))","legal function application obligation:(forall cobolStrConversionCommand:seq of (char), i:int \u0026 let minusSymbol:char \u003d \u0027-\u0027 in ((not (i \u003c 0)) \u003d\u003e ((cobolStrConversionCommand(1) \u003d minusSymbol) \u003d\u003e pre_(asStringZAux(String`subStr(cobolStrConversionCommand, 2, (len cobolStrConversionCommand)))i, true))))","type compatibility obligation:(forall cobolStrConversionCommand:seq of (char), i:int \u0026 let minusSymbol:char \u003d \u0027-\u0027 in ((not (i \u003c 0)) \u003d\u003e ((cobolStrConversionCommand(1) \u003d minusSymbol) \u003d\u003e (i \u003e\u003d 0))))","type compatibility obligation:(forall cobolStrConversionCommand:seq of (char), i:int \u0026 let minusSymbol:char \u003d \u0027-\u0027 in ((not (i \u003c 0)) \u003d\u003e ((cobolStrConversionCommand(1) \u003d minusSymbol) \u003d\u003e is_(cobolStrConversionCommand, seq1 of (char)))))","legal function application obligation:(forall cobolStrConversionCommand:seq of (char), i:int \u0026 let minusSymbol:char \u003d \u0027-\u0027 in ((not (i \u003c 0)) \u003d\u003e ((not (cobolStrConversionCommand(1) \u003d minusSymbol)) \u003d\u003e pre_(asStringZAux(cobolStrConversionCommand)i, true))))","type compatibility obligation:(forall cobolStrConversionCommand:seq of (char), i:int \u0026 let minusSymbol:char \u003d \u0027-\u0027 in ((not (i \u003c 0)) \u003d\u003e ((not (cobolStrConversionCommand(1) \u003d minusSymbol)) \u003d\u003e (i \u003e\u003d 0))))","legal sequence application obligation:(forall cobolStrConversionCommand:seq of (char), n:nat, wasZero:bool \u0026 (cobolStrConversionCommandStrLen in set (inds cobolStrConversionCommand)))","type compatibility obligation:(forall cobolStrConversionCommand:seq of (char), n:nat, wasZero:bool \u0026 is_(cobolStrConversionCommand, seq1 of (char)))","type compatibility obligation:(forall cobolStrConversionCommand:seq of (char), n:nat, wasZero:bool \u0026 ((cobolStrConversionCommandStrLen - 1) \u003e\u003d 0))","legal function application obligation:(forall cobolStrConversionCommand:seq of (char), n:nat, wasZero:bool \u0026 let cobolStrConversionCommandStrLen:nat \u003d (len cobolStrConversionCommand), cobolStrConversionCommandChar:char \u003d cobolStrConversionCommand(cobolStrConversionCommandStrLen), cobolStrConversionCommandStr:seq of (char) \u003d String`subStr(cobolStrConversionCommand, 1, (cobolStrConversionCommandStrLen - 1)), r:int \u003d (n mod 10), q:int \u003d (n div 10), isZero:bool \u003d ((r \u003d 0) and (wasZero and (q \u003c\u003e 0))) in (([] \u003d cobolStrConversionCommandStr) \u003d\u003e pre_(asCharZ(cobolStrConversionCommandChar)r, isZero)))","type compatibility obligation:(forall cobolStrConversionCommand:seq of (char), n:nat, wasZero:bool \u0026 let cobolStrConversionCommandStrLen:nat \u003d (len cobolStrConversionCommand), cobolStrConversionCommandChar:char \u003d cobolStrConversionCommand(cobolStrConversionCommandStrLen), cobolStrConversionCommandStr:seq of (char) \u003d String`subStr(cobolStrConversionCommand, 1, (cobolStrConversionCommandStrLen - 1)), r:int \u003d (n mod 10), q:int \u003d (n div 10), isZero:bool \u003d ((r \u003d 0) and (wasZero and (q \u003c\u003e 0))) in (([] \u003d cobolStrConversionCommandStr) \u003d\u003e (r \u003e\u003d 0)))","legal function application obligation:(forall cobolStrConversionCommand:seq of (char), n:nat, wasZero:bool \u0026 let cobolStrConversionCommandStrLen:nat \u003d (len cobolStrConversionCommand), cobolStrConversionCommandChar:char \u003d cobolStrConversionCommand(cobolStrConversionCommandStrLen), cobolStrConversionCommandStr:seq of (char) \u003d String`subStr(cobolStrConversionCommand, 1, (cobolStrConversionCommandStrLen - 1)), r:int \u003d (n mod 10), q:int \u003d (n div 10), isZero:bool \u003d ((r \u003d 0) and (wasZero and (q \u003c\u003e 0))) in ((not ([] \u003d cobolStrConversionCommandStr)) \u003d\u003e pre_(asStringZAux(cobolStrConversionCommandStr)q, isZero)))","type compatibility obligation:(forall cobolStrConversionCommand:seq of (char), n:nat, wasZero:bool \u0026 let cobolStrConversionCommandStrLen:nat \u003d (len cobolStrConversionCommand), cobolStrConversionCommandChar:char \u003d cobolStrConversionCommand(cobolStrConversionCommandStrLen), cobolStrConversionCommandStr:seq of (char) \u003d String`subStr(cobolStrConversionCommand, 1, (cobolStrConversionCommandStrLen - 1)), r:int \u003d (n mod 10), q:int \u003d (n div 10), isZero:bool \u003d ((r \u003d 0) and (wasZero and (q \u003c\u003e 0))) in ((not ([] \u003d cobolStrConversionCommandStr)) \u003d\u003e (q \u003e\u003d 0)))","legal function application obligation:(forall cobolStrConversionCommand:seq of (char), n:nat, wasZero:bool \u0026 let cobolStrConversionCommandStrLen:nat \u003d (len cobolStrConversionCommand), cobolStrConversionCommandChar:char \u003d cobolStrConversionCommand(cobolStrConversionCommandStrLen), cobolStrConversionCommandStr:seq of (char) \u003d String`subStr(cobolStrConversionCommand, 1, (cobolStrConversionCommandStrLen - 1)), r:int \u003d (n mod 10), q:int \u003d (n div 10), isZero:bool \u003d ((r \u003d 0) and (wasZero and (q \u003c\u003e 0))) in ((not ([] \u003d cobolStrConversionCommandStr)) \u003d\u003e pre_(asCharZ(cobolStrConversionCommandChar)r, isZero)))","type compatibility obligation:(forall cobolStrConversionCommand:seq of (char), n:nat, wasZero:bool \u0026 let cobolStrConversionCommandStrLen:nat \u003d (len cobolStrConversionCommand), cobolStrConversionCommandChar:char \u003d cobolStrConversionCommand(cobolStrConversionCommandStrLen), cobolStrConversionCommandStr:seq of (char) \u003d String`subStr(cobolStrConversionCommand, 1, (cobolStrConversionCommandStrLen - 1)), r:int \u003d (n mod 10), q:int \u003d (n div 10), isZero:bool \u003d ((r \u003d 0) and (wasZero and (q \u003c\u003e 0))) in ((not ([] \u003d cobolStrConversionCommandStr)) \u003d\u003e (r \u003e\u003d 0)))","type compatibility obligation:(forall cobolStrConversionCommand:seq of (char), n:nat, wasZero:bool \u0026 is_(let cobolStrConversionCommandStrLen:nat \u003d (len cobolStrConversionCommand), cobolStrConversionCommandChar:char \u003d cobolStrConversionCommand(cobolStrConversionCommandStrLen), cobolStrConversionCommandStr:seq of (char) \u003d String`subStr(cobolStrConversionCommand, 1, (cobolStrConversionCommandStrLen - 1)), r:int \u003d (n mod 10), q:int \u003d (n div 10), isZero:bool \u003d ((r \u003d 0) and (wasZero and (q \u003c\u003e 0))) in (cases cobolStrConversionCommandStr :\n[] -\u003e asCharZ(cobolStrConversionCommandChar)(r, isZero)\nothers (asStringZAux(cobolStrConversionCommandStr)(q, isZero) ^ asCharZ(cobolStrConversionCommandChar)(r, isZero))\n end), seq1 of (char)))","legal function application obligation:(forall x:nat, y:nat \u0026 ((not (y \u003d 0)) \u003d\u003e pre_(GCD(y)(x rem y))))","type compatibility obligation:(forall x:nat, y:nat \u0026 ((not (y \u003d 0)) \u003d\u003e ((x rem y) \u003e\u003d 0)))","legal function application obligation:(forall x:nat, y:nat \u0026 ((not (exists mk_(-, 0):(nat * nat) \u0026 (mk_(any1, 0) \u003d mk_(x, y)))) \u003d\u003e ((not (exists mk_(0, -):(nat * nat) \u0026 (mk_(0, any1) \u003d mk_(x, y)))) \u003d\u003e (exists mk_(z, w):(nat * nat) \u0026 ((mk_(z, w) \u003d mk_(x, y)) \u003d\u003e let mk_(z, w) \u003d mk_(x, y) in pre_(GCD(z)w))))))","non-zero obligation:(forall x:nat, y:nat \u0026 ((not (exists mk_(-, 0):(nat * nat) \u0026 (mk_(any1, 0) \u003d mk_(x, y)))) \u003d\u003e ((not (exists mk_(0, -):(nat * nat) \u0026 (mk_(0, any1) \u003d mk_(x, y)))) \u003d\u003e (exists mk_(z, w):(nat * nat) \u0026 ((mk_(z, w) \u003d mk_(x, y)) \u003d\u003e let mk_(z, w) \u003d mk_(x, y) in (GCD(z)(w) \u003c\u003e 0))))))","cases exhaustive obligation:(forall x:nat, y:nat \u0026 (((exists mk_(-, 0):(nat * nat) \u0026 (mk_(x, y) \u003d mk_(any1, 0))) or (exists mk_(0, -):(nat * nat) \u0026 (mk_(x, y) \u003d mk_(0, any1)))) or (exists mk_(z, w):(nat * nat) \u0026 (mk_(x, y) \u003d mk_(z, w)))))","type compatibility obligation:(forall x:nat, y:nat \u0026 is_((cases mk_(x, y) :\nmk_(-, 0) -\u003e 0,\nmk_(0, -) -\u003e 0,\nmk_(z, w) -\u003e ((z / GCD(z)(w)) * w)\n end), nat))","legal function application obligation:(forall aTime:Time, aPeriod:Term \u0026 ((not ((aPeriod.getStartTime)() \u003d nil)) \u003d\u003e pre_(((aPeriod.getStartTime)().LE)aTime)))","legal function application obligation:(forall aTime:Time, aPeriod:Term \u0026 ((((aPeriod.getStartTime)() \u003d nil) or ((aPeriod.getStartTime)().LE)(aTime)) \u003d\u003e ((not ((aPeriod.getEndTime)() \u003d nil)) \u003d\u003e pre_(((aPeriod.getEndTime)().GE)aTime))))","legal function application obligation:(forall aPeriod:Term \u0026 pre_(((self.getStartTime)().EQ)(aPeriod.getStartTime)()))","type compatibility obligation:(forall aPeriod:Term \u0026 is_((aPeriod.getStartTime)(), Time))","legal function application obligation:(forall aPeriod:Term \u0026 (((self.getStartTime)().EQ)((aPeriod.getStartTime)()) \u003d\u003e pre_(((self.getEndTime)().EQ)(aPeriod.getEndTime)())))","type compatibility obligation:(forall aPeriod:Term \u0026 (((self.getStartTime)().EQ)((aPeriod.getStartTime)()) \u003d\u003e is_((aPeriod.getEndTime)(), Time)))","legal function application obligation:(forall s:seq of (char) \u0026 pre_(String`AsIntegerAux(s)0))","legal function application obligation:(forall s:seq of (char), sum:int \u0026 ((not (s \u003d [])) \u003d\u003e pre_(AsIntegerAux((tl s))((10 * sum) + Character`asDigit((hd s))))))","non-empty sequence obligation:(forall s:seq of (char), sum:int \u0026 ((not (s \u003d [])) \u003d\u003e (s \u003c\u003e [])))","type compatibility obligation:(forall s:seq of (char), sum:int \u0026 ((not (s \u003d [])) \u003d\u003e is_(Character`asDigit((hd s)), real)))","non-empty sequence obligation:(forall s:seq of (char), sum:int \u0026 ((not (s \u003d [])) \u003d\u003e (s \u003c\u003e [])))","legal function application obligation:(forall f:(char -\u003e bool), s:seq of (char) \u0026 (forall i in set (inds s) \u0026 pre_(fs(i))))","legal sequence application obligation:(forall f:(char -\u003e bool), s:seq of (char) \u0026 (forall i in set (inds s) \u0026 (i in set (inds s))))","legal function application obligation:(forall s:seq of (char) \u0026 pre_(isSomeString(Character`isDigit)s))","legal function application obligation:(forall s:seq of (char) \u0026 pre_(isSomeString(Character`isLetter)s))","legal function application obligation:(forall s:seq of (char) \u0026 pre_(isSomeString(Character`isLetterOrDigit)s))","legal function application obligation:(forall s:[seq of (char)] \u0026 pre_(isSomeString((lambda [c:char] \u0026 ((c \u003d \u0027 \u0027) or (c \u003d \u0027\t\u0027))))s))","type compatibility obligation:(forall s:[seq of (char)] \u0026 is_(s, seq of (char)))","legal function application obligation:(forall s1:seq of (char), s2:seq of (char) \u0026 pre_(String`LT2(s1)s2))","cases exhaustive obligation:(forall s1:seq of (char), s2:seq of (char) \u0026 ((((mk_(s1, s2) \u003d mk_([], [])) or (exists mk_([], -):(seq of (char) * seq of (char)) \u0026 (mk_(s1, s2) \u003d mk_([], any1)))) or (exists mk_(- ^ -, []):(seq of (char) * seq of (char)) \u0026 (mk_(s1, s2) \u003d mk_((any1 ^ any1), [])))) or (exists mk_([head1] ^ tails1, [head2] ^ tails2):(seq of (char) * seq of (char)) \u0026 (mk_(s1, s2) \u003d mk_(([head1] ^ tails1), ([head2] ^ tails2))))))","legal function application obligation:(forall s1:seq of (char), s2:seq of (char) \u0026 pre_(String`LE2(s1)s2))","legal function application obligation:(forall s1:seq of (char), s2:seq of (char) \u0026 pre_(String`LT2(s1)s2))","legal function application obligation:(forall s1:seq of (char), s2:seq of (char) \u0026 pre_(String`GT2(s1)s2))","legal function application obligation:(forall s1:seq of (char), s2:seq of (char) \u0026 pre_(String`GE2(s1)s2))","legal function application obligation:(forall s1:seq of (char), s2:seq of (char) \u0026 pre_(String`LT2(s1)s2))","legal function application obligation:(forall c:char, aStr:seq of (char) \u0026 pre_((Sequence`Index)[char](c)aStr))","legal function application obligation:(forall aStr:seq of (char), c:char \u0026 pre_((Sequence`IndexAll2)[char](c)aStr))","legal function application obligation:(forall c:char, aStr:seq of (char) \u0026 pre_((Sequence`IndexAll2)[char](c)aStr))","legal sequence application obligation:(forall aStr:seq of (char), aTargetStr:seq of (char) \u0026 ((aTargetStr \u003c\u003e \"\") \u003d\u003e (1 in set (inds aTargetStr))))","legal function application obligation:(forall aStr:seq of (char), aTargetStr:seq of (char) \u0026 ((aTargetStr \u003c\u003e \"\") \u003d\u003e let indexSet:set of (int) \u003d indexAll(aStr, aTargetStr(1)) in (forall i in set indexSet \u0026 pre_(SubStr(i)((len aTargetStr))aStr))))","type compatibility obligation:(forall aStr:seq of (char), aTargetStr:seq of (char) \u0026 ((aTargetStr \u003c\u003e \"\") \u003d\u003e let indexSet:set of (int) \u003d indexAll(aStr, aTargetStr(1)) in (forall i in set indexSet \u0026 is_(aStr, seq1 of (char)))))","legal function application obligation:(forall aStr:seq of (char), aTargetStr:seq of (char) \u0026 ((aTargetStr \u003c\u003e \"\") \u003d\u003e let indexSet:set of (int) \u003d indexAll(aStr, aTargetStr(1)) in (forall i in set indexSet \u0026 pre_(SubStr(i)(len aTargetStr)))))","type compatibility obligation:(forall aStr:seq of (char), aTargetStr:seq of (char) \u0026 ((aTargetStr \u003c\u003e \"\") \u003d\u003e let indexSet:set of (int) \u003d indexAll(aStr, aTargetStr(1)) in (forall i in set indexSet \u0026 (i \u003e\u003d 0))))","legal function application obligation:(forall s:seq of (char), aDelimitterSet:set of (char) \u0026 pre_((TakeWhile)[char]((lambda [c:char] \u0026 (c not in set aDelimitterSet)))s))","legal function application obligation:(forall s:seq of (char), aDelimitterSet:set of (char) \u0026 pre_((DropWhile)[char]((lambda [c:char] \u0026 (c not in set aDelimitterSet)))s))","legal function application obligation:(forall s:seq of (char) \u0026 pre_(getLinesAux(s)[]))","non-empty sequence obligation:(forall s:seq of (char), line:seq of (seq of (char)) \u0026 ((not (s \u003d [])) \u003d\u003e ((wTailStringCandidate \u003c\u003e []) \u003d\u003e (wTailStringCandidate \u003c\u003e []))))","non-empty sequence obligation:(forall s:seq of (char), line:seq of (seq of (char)) \u0026 ((not (s \u003d [])) \u003d\u003e (((wTailStringCandidate \u003c\u003e []) and ((hd wTailStringCandidate) \u003d \u0027\n\u0027)) \u003d\u003e (wTailStringCandidate \u003c\u003e []))))","legal function application obligation:(forall s:seq of (char), line:seq of (seq of (char)) \u0026 ((not (s \u003d [])) \u003d\u003e let wDelimitterSet:set of (char) \u003d {\u0027\n\u0027}, wHeadLine:seq of (char) \u003d GetToken(s, wDelimitterSet), wTailStringCandidate:seq of (char) \u003d DropToken(s, wDelimitterSet), wTailString:seq of (char) \u003d (if ((wTailStringCandidate \u003c\u003e []) and ((hd wTailStringCandidate) \u003d \u0027\n\u0027))\nthen (tl wTailStringCandidate)\nelse wTailStringCandidate) in pre_(getLinesAux(wTailString)(line ^ [wHeadLine]))))","legal sequence application obligation:(forall aStr:seq of (char), c:char \u0026 (i in set (inds aStr)))","legal sequence application obligation:(forall aStr:seq of (char), fromPos:nat, length:nat, fillChar:char \u0026 (((fromPos \u003e 0) and (length \u003e\u003d 0)) \u003d\u003e (i in set (inds aStr))))","legal function application obligation:pre_((i.asString)1234567890)","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e pre_((i.asString)-1234567890))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e pre_((i.asStringZ)(\"zzz9\")9900)))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e pre_((i.asStringZ)\"zzz9\")))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e pre_((i.asStringZ)(\"9\")0))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e pre_((i.asStringZ)\"9\"))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e pre_((i.asStringZ)(\"z\")0)))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e pre_((i.asStringZ)\"z\")))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e pre_((i.asStringZ)(\"z\")9))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e pre_((i.asStringZ)\"z\"))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e pre_((i.asStringZ)(\"zzz9\")9)))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e pre_((i.asStringZ)\"zzz9\")))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e pre_((i.asStringZ)(\"0009\")9))))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e pre_((i.asStringZ)\"0009\"))))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e (((i.asStringZ)(\"0009\")(9) \u003d \"0009\") \u003d\u003e pre_((i.asStringZ)(\"-0009\")9)))))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e (((i.asStringZ)(\"0009\")(9) \u003d \"0009\") \u003d\u003e pre_((i.asStringZ)\"-0009\")))))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e (((i.asStringZ)(\"0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-0009\")(9) \u003d \"0009\") \u003d\u003e pre_((i.asStringZ)(\"-zzz9\")-9999))))))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e (((i.asStringZ)(\"0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-0009\")(9) \u003d \"0009\") \u003d\u003e pre_((i.asStringZ)\"-zzz9\"))))))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e (((i.asStringZ)(\"0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9999) \u003d \"-9999\") \u003d\u003e pre_((i.asStringZ)(\"-zzz9\")-9)))))))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e (((i.asStringZ)(\"0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9999) \u003d \"-9999\") \u003d\u003e pre_((i.asStringZ)\"-zzz9\")))))))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e (((i.asStringZ)(\"0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9999) \u003d \"-9999\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9) \u003d \"- 9\") \u003d\u003e pre_((i.asStringZ)(\"zzz9\")-9999))))))))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e (((i.asStringZ)(\"0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9999) \u003d \"-9999\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9) \u003d \"- 9\") \u003d\u003e pre_((i.asStringZ)\"zzz9\"))))))))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e (((i.asStringZ)(\"0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9999) \u003d \"-9999\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9) \u003d \"- 9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9999) \u003d \"9999\") \u003d\u003e pre_((i.asStringZ)(\"zzz9\")-9)))))))))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e (((i.asStringZ)(\"0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9999) \u003d \"-9999\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9) \u003d \"- 9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9999) \u003d \"9999\") \u003d\u003e pre_((i.asStringZ)\"zzz9\")))))))))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e (((i.asStringZ)(\"0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9999) \u003d \"-9999\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9) \u003d \"- 9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9999) \u003d \"9999\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9) \u003d \" 9\") \u003d\u003e pre_((i.asString)0))))))))))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e (((i.asStringZ)(\"0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9999) \u003d \"-9999\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9) \u003d \"- 9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9999) \u003d \"9999\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9) \u003d \" 9\") \u003d\u003e (((i.asString)(0) \u003d \"0\") \u003d\u003e pre_((i.asChar)0)))))))))))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e (((i.asStringZ)(\"0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9999) \u003d \"-9999\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9) \u003d \"- 9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9999) \u003d \"9999\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9) \u003d \" 9\") \u003d\u003e (((i.asString)(0) \u003d \"0\") \u003d\u003e (((i.asChar)(0) \u003d \"0\") \u003d\u003e pre_((i.asChar)1))))))))))))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e (((i.asStringZ)(\"0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9999) \u003d \"-9999\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9) \u003d \"- 9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9999) \u003d \"9999\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9) \u003d \" 9\") \u003d\u003e (((i.asString)(0) \u003d \"0\") \u003d\u003e (((i.asChar)(0) \u003d \"0\") \u003d\u003e (((i.asChar)(1) \u003d \"1\") \u003d\u003e pre_((i.asChar)2)))))))))))))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e (((i.asStringZ)(\"0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9999) \u003d \"-9999\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9) \u003d \"- 9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9999) \u003d \"9999\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9) \u003d \" 9\") \u003d\u003e (((i.asString)(0) \u003d \"0\") \u003d\u003e (((i.asChar)(0) \u003d \"0\") \u003d\u003e (((i.asChar)(1) \u003d \"1\") \u003d\u003e (((i.asChar)(2) \u003d \"2\") \u003d\u003e pre_((i.asChar)3))))))))))))))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e (((i.asStringZ)(\"0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9999) \u003d \"-9999\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9) \u003d \"- 9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9999) \u003d \"9999\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9) \u003d \" 9\") \u003d\u003e (((i.asString)(0) \u003d \"0\") \u003d\u003e (((i.asChar)(0) \u003d \"0\") \u003d\u003e (((i.asChar)(1) \u003d \"1\") \u003d\u003e (((i.asChar)(2) \u003d \"2\") \u003d\u003e (((i.asChar)(3) \u003d \"3\") \u003d\u003e pre_((i.asChar)4)))))))))))))))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e (((i.asStringZ)(\"0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9999) \u003d \"-9999\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9) \u003d \"- 9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9999) \u003d \"9999\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9) \u003d \" 9\") \u003d\u003e (((i.asString)(0) \u003d \"0\") \u003d\u003e (((i.asChar)(0) \u003d \"0\") \u003d\u003e (((i.asChar)(1) \u003d \"1\") \u003d\u003e (((i.asChar)(2) \u003d \"2\") \u003d\u003e (((i.asChar)(3) \u003d \"3\") \u003d\u003e (((i.asChar)(4) \u003d \"4\") \u003d\u003e pre_((i.asChar)5))))))))))))))))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e (((i.asStringZ)(\"0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9999) \u003d \"-9999\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9) \u003d \"- 9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9999) \u003d \"9999\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9) \u003d \" 9\") \u003d\u003e (((i.asString)(0) \u003d \"0\") \u003d\u003e (((i.asChar)(0) \u003d \"0\") \u003d\u003e (((i.asChar)(1) \u003d \"1\") \u003d\u003e (((i.asChar)(2) \u003d \"2\") \u003d\u003e (((i.asChar)(3) \u003d \"3\") \u003d\u003e (((i.asChar)(4) \u003d \"4\") \u003d\u003e (((i.asChar)(5) \u003d \"5\") \u003d\u003e pre_((i.asChar)6)))))))))))))))))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e (((i.asStringZ)(\"0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9999) \u003d \"-9999\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9) \u003d \"- 9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9999) \u003d \"9999\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9) \u003d \" 9\") \u003d\u003e (((i.asString)(0) \u003d \"0\") \u003d\u003e (((i.asChar)(0) \u003d \"0\") \u003d\u003e (((i.asChar)(1) \u003d \"1\") \u003d\u003e (((i.asChar)(2) \u003d \"2\") \u003d\u003e (((i.asChar)(3) \u003d \"3\") \u003d\u003e (((i.asChar)(4) \u003d \"4\") \u003d\u003e (((i.asChar)(5) \u003d \"5\") \u003d\u003e (((i.asChar)(6) \u003d \"6\") \u003d\u003e pre_((i.asChar)7))))))))))))))))))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e (((i.asStringZ)(\"0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9999) \u003d \"-9999\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9) \u003d \"- 9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9999) \u003d \"9999\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9) \u003d \" 9\") \u003d\u003e (((i.asString)(0) \u003d \"0\") \u003d\u003e (((i.asChar)(0) \u003d \"0\") \u003d\u003e (((i.asChar)(1) \u003d \"1\") \u003d\u003e (((i.asChar)(2) \u003d \"2\") \u003d\u003e (((i.asChar)(3) \u003d \"3\") \u003d\u003e (((i.asChar)(4) \u003d \"4\") \u003d\u003e (((i.asChar)(5) \u003d \"5\") \u003d\u003e (((i.asChar)(6) \u003d \"6\") \u003d\u003e (((i.asChar)(7) \u003d \"7\") \u003d\u003e pre_((i.asChar)8)))))))))))))))))))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e (((i.asStringZ)(\"0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9999) \u003d \"-9999\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9) \u003d \"- 9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9999) \u003d \"9999\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9) \u003d \" 9\") \u003d\u003e (((i.asString)(0) \u003d \"0\") \u003d\u003e (((i.asChar)(0) \u003d \"0\") \u003d\u003e (((i.asChar)(1) \u003d \"1\") \u003d\u003e (((i.asChar)(2) \u003d \"2\") \u003d\u003e (((i.asChar)(3) \u003d \"3\") \u003d\u003e (((i.asChar)(4) \u003d \"4\") \u003d\u003e (((i.asChar)(5) \u003d \"5\") \u003d\u003e (((i.asChar)(6) \u003d \"6\") \u003d\u003e (((i.asChar)(7) \u003d \"7\") \u003d\u003e (((i.asChar)(8) \u003d \"8\") \u003d\u003e pre_((i.asChar)9))))))))))))))))))))))))","legal function application obligation:(((i.asString)(1234567890) \u003d \"1234567890\") \u003d\u003e (((i.asString)(-1234567890) \u003d \"-1234567890\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9900) \u003d \"9900\") \u003d\u003e (((i.asStringZ)(\"9\")(0) \u003d \"0\") \u003d\u003e (((i.asStringZ)(\"z\")(0) \u003d \" \") \u003d\u003e (((i.asStringZ)(\"z\")(9) \u003d \"9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(9) \u003d \" 9\") \u003d\u003e (((i.asStringZ)(\"0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-0009\")(9) \u003d \"0009\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9999) \u003d \"-9999\") \u003d\u003e (((i.asStringZ)(\"-zzz9\")(-9) \u003d \"- 9\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9999) \u003d \"9999\") \u003d\u003e (((i.asStringZ)(\"zzz9\")(-9) \u003d \" 9\") \u003d\u003e (((i.asString)(0) \u003d \"0\") \u003d\u003e (((i.asChar)(0) \u003d \"0\") \u003d\u003e (((i.asChar)(1) \u003d \"1\") \u003d\u003e (((i.asChar)(2) \u003d \"2\") \u003d\u003e (((i.asChar)(3) \u003d \"3\") \u003d\u003e (((i.asChar)(4) \u003d \"4\") \u003d\u003e (((i.asChar)(5) \u003d \"5\") \u003d\u003e (((i.asChar)(6) \u003d \"6\") \u003d\u003e (((i.asChar)(7) \u003d \"7\") \u003d\u003e (((i.asChar)(8) \u003d \"8\") \u003d\u003e (((i.asChar)(9) \u003d \"9\") \u003d\u003e pre_((i.asChar)10)))))))))))))))))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((Sequence`fmap)[nat, nat](gcd)[36, 48, 16])","legal function application obligation:(((Sequence`fmap)[nat, nat](gcd)([36, 48, 16]) \u003d [12, 24, 8]) \u003d\u003e pre_((Sequence`fmap)[nat, nat](lcm)[3, 4, 5]))","type compatibility obligation:is_(RESULT, ())","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((Set`Combinations)[int](2){1, 2, 3})","legal function application obligation:(((Set`Combinations)[int](2)({1, 2, 3}) \u003d {{1, 2}, {1, 3}, {2, 3}}) \u003d\u003e pre_((Set`Combinations)[int](2){1, 2, 3, 4}))","legal function application obligation:(((Set`Combinations)[int](2)({1, 2, 3}) \u003d {{1, 2}, {1, 3}, {2, 3}}) \u003d\u003e (((Set`Combinations)[int](2)({1, 2, 3, 4}) \u003d {{1, 2}, {1, 3}, {1, 4}, {2, 3}, {2, 4}, {3, 4}}) \u003d\u003e pre_((Set`fmap)[set of (int), set of (set of (int))]((Set`Combinations)[int](2)){{1, 2, 3}, {1, 2, 3, 4}})))","legal function application obligation:(((Set`Combinations)[int](2)({1, 2, 3}) \u003d {{1, 2}, {1, 3}, {2, 3}}) \u003d\u003e (((Set`Combinations)[int](2)({1, 2, 3, 4}) \u003d {{1, 2}, {1, 3}, {1, 4}, {2, 3}, {2, 4}, {3, 4}}) \u003d\u003e (((Set`fmap)[set of (int), set of (set of (int))]((Set`Combinations)[int](2))({{1, 2, 3}, {1, 2, 3, 4}}) \u003d {{{1, 2}, {1, 3}, {2, 3}}, {{1, 2}, {1, 3}, {1, 4}, {2, 3}, {2, 4}, {3, 4}}}) \u003d\u003e pre_((Set`Combinations)[int](3){1, 2, 3, 4}))))","legal function application obligation:(((Set`Combinations)[int](2)({1, 2, 3}) \u003d {{1, 2}, {1, 3}, {2, 3}}) \u003d\u003e (((Set`Combinations)[int](2)({1, 2, 3, 4}) \u003d {{1, 2}, {1, 3}, {1, 4}, {2, 3}, {2, 4}, {3, 4}}) \u003d\u003e (((Set`fmap)[set of (int), set of (set of (int))]((Set`Combinations)[int](2))({{1, 2, 3}, {1, 2, 3, 4}}) \u003d {{{1, 2}, {1, 3}, {2, 3}}, {{1, 2}, {1, 3}, {1, 4}, {2, 3}, {2, 4}, {3, 4}}}) \u003d\u003e (((Set`Combinations)[int](3)({1, 2, 3, 4}) \u003d {{1, 2, 3}, {1, 2, 4}, {1, 3, 4}, {2, 3, 4}}) \u003d\u003e pre_((Set`Combinations)[seq of (char)](2){\"Sahara\", \"Sato\", \"Sakoh\", \"Yatsu\", \"Nishikawa\"})))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((Set`fmap)[int, int]((lambda [x:int] \u0026 (x mod 3))){1, 2, 3, 4, 5})","legal function application obligation:(((Set`fmap)[int, int]((lambda [x:int] \u0026 (x mod 3)))({1, 2, 3, 4, 5}) \u003d {0, 1, 2}) \u003d\u003e pre_((Set`fmap)[seq of (char), seq of (char)]((Sequence`take)[char](2)){\"Shin Sahara\", \"Hiroshi Sakoh\"}))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_Sum({1, ... ,10})","legal function application obligation:(((Set`Sum)[int]({1, ... ,10}) \u003d 55) \u003d\u003e pre_Sum({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}))","legal function application obligation:(((Set`Sum)[int]({1, ... ,10}) \u003d 55) \u003d\u003e (((Set`Sum)[int]({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}) \u003d 55) \u003d\u003e pre_Sum({0.1, 0.2, 0.3})))","legal function application obligation:(((Set`Sum)[int]({1, ... ,10}) \u003d 55) \u003d\u003e (((Set`Sum)[int]({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}) \u003d 55) \u003d\u003e (((abs ((Set`Sum)[real]({0.1, 0.2, 0.3}) - 0.6)) \u003c\u003d 1.0E-5) \u003d\u003e pre_Sum({1, 2, 3, 3}))))","type compatibility obligation:is_(RESULT, ())","type invariant satisfiable obligation:(exists -:Identifier \u0026 (forall s1, s2:seq of (char), id1, id2:Identifier \u0026 ((id1 \u003c\u003e id2) \u003d\u003e (s1 \u003c\u003e s2))))","type invariant satisfiable obligation:(exists p:Percent \u0026 ((0 \u003c\u003d p) and (p \u003c\u003d 100)))","legal function application obligation:(forall am:real \u0026 pre_((new Real().isNDigitsAfterTheDecimalPoint)am, 2))","type invariant satisfiable obligation:(exists am:AmountOfMoney2 \u0026 (new Real().isNDigitsAfterTheDecimalPoint)(am, 2))","legal function application obligation:pre_((Product`Curry)[seq of (char), seq of (char), bool](lt)(\"abc\")\"abcd\")","legal function application obligation:pre_((Product`Curry)[seq of (char), seq of (char), bool](lt)\"abc\")","legal function application obligation:((Product`Curry)[seq of (char), seq of (char), bool](lt)(\"abc\")(\"abcd\") \u003d\u003e pre_((Product`Curry)[seq of (char), seq of (char), bool](lt)(\"abcde\")\"abcd\"))","legal function application obligation:((Product`Curry)[seq of (char), seq of (char), bool](lt)(\"abc\")(\"abcd\") \u003d\u003e pre_((Product`Curry)[seq of (char), seq of (char), bool](lt)\"abcde\"))","legal function application obligation:((Product`Curry)[seq of (char), seq of (char), bool](lt)(\"abc\")(\"abcd\") \u003d\u003e (((Product`Curry)[seq of (char), seq of (char), bool](lt)(\"abcde\")(\"abcd\") \u003d false) \u003d\u003e pre_((Product`Curry)[int, int, bool](lt2)(3)4)))","legal function application obligation:((Product`Curry)[seq of (char), seq of (char), bool](lt)(\"abc\")(\"abcd\") \u003d\u003e (((Product`Curry)[seq of (char), seq of (char), bool](lt)(\"abcde\")(\"abcd\") \u003d false) \u003d\u003e pre_((Product`Curry)[int, int, bool](lt2)3)))","legal function application obligation:((Product`Curry)[seq of (char), seq of (char), bool](lt)(\"abc\")(\"abcd\") \u003d\u003e (((Product`Curry)[seq of (char), seq of (char), bool](lt)(\"abcde\")(\"abcd\") \u003d false) \u003d\u003e ((Product`Curry)[int, int, bool](lt2)(3)(4) \u003d\u003e pre_((Product`Uncurry)[seq of (char), seq of (char), bool](String`LT2)\"abc\", \"abcd\"))))","legal function application obligation:((Product`Curry)[seq of (char), seq of (char), bool](lt)(\"abc\")(\"abcd\") \u003d\u003e (((Product`Curry)[seq of (char), seq of (char), bool](lt)(\"abcde\")(\"abcd\") \u003d false) \u003d\u003e ((Product`Curry)[int, int, bool](lt2)(3)(4) \u003d\u003e ((Product`Uncurry)[seq of (char), seq of (char), bool](String`LT2)(\"abc\", \"abcd\") \u003d\u003e pre_((Product`Uncurry)[seq of (char), seq of (char), bool](String`LT2)\"abcde\", \"abcd\")))))","legal function application obligation:((Product`Curry)[seq of (char), seq of (char), bool](lt)(\"abc\")(\"abcd\") \u003d\u003e (((Product`Curry)[seq of (char), seq of (char), bool](lt)(\"abcde\")(\"abcd\") \u003d false) \u003d\u003e ((Product`Curry)[int, int, bool](lt2)(3)(4) \u003d\u003e ((Product`Uncurry)[seq of (char), seq of (char), bool](String`LT2)(\"abc\", \"abcd\") \u003d\u003e (((Product`Uncurry)[seq of (char), seq of (char), bool](String`LT2)(\"abcde\", \"abcd\") \u003d false) \u003d\u003e pre_((Product`Uncurry)[seq of (char), seq of (char), bool](String`LE2)\"3\", \"4\"))))))","type compatibility obligation:is_(RESULT, ())","enumeration map injectivity obligation:(forall m1, m2 in set {{1 |-\u003e \"Kei Sato\"}, {19 |-\u003e \"Shin Sahara\"}, {20 |-\u003e \"Hiroshi Sakoh\"}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","enumeration map injectivity obligation:(forall m1, m2 in set {{\"Kei Sato\" |-\u003e 1}, {\"Shin Sahara\" |-\u003e 19}, {\"Hiroshi Sakoh\" |-\u003e 20}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","legal function application obligation:pre_(get1(m1)19)","legal function application obligation:pre_(get1m1)","legal function application obligation:((get1(m1)(19) \u003d \"Shin Sahara\") \u003d\u003e pre_(get1(m1)2))","legal function application obligation:((get1(m1)(19) \u003d \"Shin Sahara\") \u003d\u003e pre_(get1m1))","legal function application obligation:((get1(m1)(19) \u003d \"Shin Sahara\") \u003d\u003e ((get1(m1)(2) \u003d nil) \u003d\u003e pre_(get2(m2)\"Shin Sahara\")))","legal function application obligation:((get1(m1)(19) \u003d \"Shin Sahara\") \u003d\u003e ((get1(m1)(2) \u003d nil) \u003d\u003e pre_(get2m2)))","legal function application obligation:((get1(m1)(19) \u003d \"Shin Sahara\") \u003d\u003e ((get1(m1)(2) \u003d nil) \u003d\u003e ((get2(m2)(\"Shin Sahara\") \u003d 19) \u003d\u003e pre_(get2(m2)\"Worst Prime Minister Koizumi\"))))","legal function application obligation:((get1(m1)(19) \u003d \"Shin Sahara\") \u003d\u003e ((get1(m1)(2) \u003d nil) \u003d\u003e ((get2(m2)(\"Shin Sahara\") \u003d 19) \u003d\u003e pre_(get2m2))))","type compatibility obligation:is_(RESULT, ())","enumeration map injectivity obligation:(forall m1, m2 in set {{1 |-\u003e \"Kei Sato\"}, {19 |-\u003e \"Shin Sahara\"}, {20 |-\u003e \"Hiroshi Sakoh\"}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","enumeration map injectivity obligation:(forall m1, m2 in set {{\"Kei Sato\" |-\u003e 1}, {\"Shin Sahara\" |-\u003e 19}, {\"Hiroshi Sakoh\" |-\u003e 20}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","legal function application obligation:pre_(c1(m1)\"Kei Sato\")","legal function application obligation:pre_(c1m1)","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e pre_(c1(m1)\"Shin Sahara\"))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e pre_(c1m1))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e pre_(c1(m1)\"Hiroshi Sakoh\")))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e pre_(c1m1)))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e pre_(c1(m1)\"Worst Prime Minister Koizumi\"))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e pre_(c1m1))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e pre_(k1(m1)1)))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e pre_(k1m1)))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e (k1(m1)(1) \u003d\u003e pre_(k1(m1)19))))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e (k1(m1)(1) \u003d\u003e pre_(k1m1))))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e (k1(m1)(1) \u003d\u003e (k1(m1)(19) \u003d\u003e pre_(k1(m1)20)))))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e (k1(m1)(1) \u003d\u003e (k1(m1)(19) \u003d\u003e pre_(k1m1)))))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e (k1(m1)(1) \u003d\u003e (k1(m1)(19) \u003d\u003e (k1(m1)(20) \u003d\u003e pre_(k1(m1)99))))))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e (k1(m1)(1) \u003d\u003e (k1(m1)(19) \u003d\u003e (k1(m1)(20) \u003d\u003e pre_(k1m1))))))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e (k1(m1)(1) \u003d\u003e (k1(m1)(19) \u003d\u003e (k1(m1)(20) \u003d\u003e ((not k1(m1)(99)) \u003d\u003e pre_(c2(m2)1)))))))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e (k1(m1)(1) \u003d\u003e (k1(m1)(19) \u003d\u003e (k1(m1)(20) \u003d\u003e ((not k1(m1)(99)) \u003d\u003e pre_(c2m2)))))))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e (k1(m1)(1) \u003d\u003e (k1(m1)(19) \u003d\u003e (k1(m1)(20) \u003d\u003e ((not k1(m1)(99)) \u003d\u003e (c2(m2)(1) \u003d\u003e pre_(c2(m2)19))))))))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e (k1(m1)(1) \u003d\u003e (k1(m1)(19) \u003d\u003e (k1(m1)(20) \u003d\u003e ((not k1(m1)(99)) \u003d\u003e (c2(m2)(1) \u003d\u003e pre_(c2m2))))))))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e (k1(m1)(1) \u003d\u003e (k1(m1)(19) \u003d\u003e (k1(m1)(20) \u003d\u003e ((not k1(m1)(99)) \u003d\u003e (c2(m2)(1) \u003d\u003e (c2(m2)(19) \u003d\u003e pre_(c2(m2)20)))))))))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e (k1(m1)(1) \u003d\u003e (k1(m1)(19) \u003d\u003e (k1(m1)(20) \u003d\u003e ((not k1(m1)(99)) \u003d\u003e (c2(m2)(1) \u003d\u003e (c2(m2)(19) \u003d\u003e pre_(c2m2)))))))))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e (k1(m1)(1) \u003d\u003e (k1(m1)(19) \u003d\u003e (k1(m1)(20) \u003d\u003e ((not k1(m1)(99)) \u003d\u003e (c2(m2)(1) \u003d\u003e (c2(m2)(19) \u003d\u003e (c2(m2)(20) \u003d\u003e pre_(c2(m2)30))))))))))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e (k1(m1)(1) \u003d\u003e (k1(m1)(19) \u003d\u003e (k1(m1)(20) \u003d\u003e ((not k1(m1)(99)) \u003d\u003e (c2(m2)(1) \u003d\u003e (c2(m2)(19) \u003d\u003e (c2(m2)(20) \u003d\u003e pre_(c2m2))))))))))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e (k1(m1)(1) \u003d\u003e (k1(m1)(19) \u003d\u003e (k1(m1)(20) \u003d\u003e ((not k1(m1)(99)) \u003d\u003e (c2(m2)(1) \u003d\u003e (c2(m2)(19) \u003d\u003e (c2(m2)(20) \u003d\u003e ((c2(m2)(30) \u003d false) \u003d\u003e pre_(k2(m2)\"Kei Sato\")))))))))))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e (k1(m1)(1) \u003d\u003e (k1(m1)(19) \u003d\u003e (k1(m1)(20) \u003d\u003e ((not k1(m1)(99)) \u003d\u003e (c2(m2)(1) \u003d\u003e (c2(m2)(19) \u003d\u003e (c2(m2)(20) \u003d\u003e ((c2(m2)(30) \u003d false) \u003d\u003e pre_(k2m2)))))))))))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e (k1(m1)(1) \u003d\u003e (k1(m1)(19) \u003d\u003e (k1(m1)(20) \u003d\u003e ((not k1(m1)(99)) \u003d\u003e (c2(m2)(1) \u003d\u003e (c2(m2)(19) \u003d\u003e (c2(m2)(20) \u003d\u003e ((c2(m2)(30) \u003d false) \u003d\u003e (k2(m2)(\"Kei Sato\") \u003d\u003e pre_(k2(m2)\"Shin Sahara\"))))))))))))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e (k1(m1)(1) \u003d\u003e (k1(m1)(19) \u003d\u003e (k1(m1)(20) \u003d\u003e ((not k1(m1)(99)) \u003d\u003e (c2(m2)(1) \u003d\u003e (c2(m2)(19) \u003d\u003e (c2(m2)(20) \u003d\u003e ((c2(m2)(30) \u003d false) \u003d\u003e (k2(m2)(\"Kei Sato\") \u003d\u003e pre_(k2m2))))))))))))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e (k1(m1)(1) \u003d\u003e (k1(m1)(19) \u003d\u003e (k1(m1)(20) \u003d\u003e ((not k1(m1)(99)) \u003d\u003e (c2(m2)(1) \u003d\u003e (c2(m2)(19) \u003d\u003e (c2(m2)(20) \u003d\u003e ((c2(m2)(30) \u003d false) \u003d\u003e (k2(m2)(\"Kei Sato\") \u003d\u003e (k2(m2)(\"Shin Sahara\") \u003d\u003e pre_(k2(m2)\"Hiroshi Sakoh\")))))))))))))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e (k1(m1)(1) \u003d\u003e (k1(m1)(19) \u003d\u003e (k1(m1)(20) \u003d\u003e ((not k1(m1)(99)) \u003d\u003e (c2(m2)(1) \u003d\u003e (c2(m2)(19) \u003d\u003e (c2(m2)(20) \u003d\u003e ((c2(m2)(30) \u003d false) \u003d\u003e (k2(m2)(\"Kei Sato\") \u003d\u003e (k2(m2)(\"Shin Sahara\") \u003d\u003e pre_(k2m2)))))))))))))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e (k1(m1)(1) \u003d\u003e (k1(m1)(19) \u003d\u003e (k1(m1)(20) \u003d\u003e ((not k1(m1)(99)) \u003d\u003e (c2(m2)(1) \u003d\u003e (c2(m2)(19) \u003d\u003e (c2(m2)(20) \u003d\u003e ((c2(m2)(30) \u003d false) \u003d\u003e (k2(m2)(\"Kei Sato\") \u003d\u003e (k2(m2)(\"Shin Sahara\") \u003d\u003e (k2(m2)(\"Hiroshi Sakoh\") \u003d\u003e pre_(k2(m2)\"Worst Prime Minister Koizumi\"))))))))))))))))","legal function application obligation:(c1(m1)(\"Kei Sato\") \u003d\u003e (c1(m1)(\"Shin Sahara\") \u003d\u003e (c1(m1)(\"Hiroshi Sakoh\") \u003d\u003e ((c1(m1)(\"Worst Prime Minister Koizumi\") \u003d false) \u003d\u003e (k1(m1)(1) \u003d\u003e (k1(m1)(19) \u003d\u003e (k1(m1)(20) \u003d\u003e ((not k1(m1)(99)) \u003d\u003e (c2(m2)(1) \u003d\u003e (c2(m2)(19) \u003d\u003e (c2(m2)(20) \u003d\u003e ((c2(m2)(30) \u003d false) \u003d\u003e (k2(m2)(\"Kei Sato\") \u003d\u003e (k2(m2)(\"Shin Sahara\") \u003d\u003e (k2(m2)(\"Hiroshi Sakoh\") \u003d\u003e pre_(k2m2))))))))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:(forall i:int \u0026 let str:(int -\u003e seq1 of (char)) \u003d Integer`asString in ((i \u003e\u003d 10) \u003d\u003e pre_(stri)))","legal function application obligation:(forall i:int \u0026 let str:(int -\u003e seq1 of (char)) \u003d Integer`asString in ((not (i \u003e\u003d 10)) \u003d\u003e pre_(stri)))","legal function application obligation:(forall ADdate:Date \u0026 pre_((ADdate.Year)))","legal function application obligation:(forall ADdate:Date \u0026 (((ADdate.Year)() \u003e\u003d differenceBetweenADandJapaneseCal) \u003d\u003e pre_((ADdate.Year))))","legal function application obligation:(forall ADdate:Date \u0026 (((ADdate.Year)() \u003e\u003d differenceBetweenADandJapaneseCal) \u003d\u003e pre_((ADdate.Month))))","legal function application obligation:(forall ADdate:Date \u0026 (((ADdate.Year)() \u003e\u003d differenceBetweenADandJapaneseCal) \u003d\u003e pre_((ADdate.day))))","legal function application obligation:(forall ADdate:Date \u0026 (((ADdate.Year)() \u003e\u003d differenceBetweenADandJapaneseCal) \u003d\u003e pre_(asStringyearOfJapaneseCal)))","type compatibility obligation:(forall year:int \u0026 ((year \u003e\u003d 2000) \u003d\u003e ((year \u003e\u003d 2007) \u003d\u003e (forall d in set nationalHolidaySet \u0026 (isSunday(d) \u003d\u003e is_(nationalHolidaySet, set of (Date)))))))","type compatibility obligation:(forall year:int \u0026 ((year \u003e\u003d 2000) \u003d\u003e ((year \u003e\u003d 2007) \u003d\u003e (forall d in set nationalHolidaySet \u0026 (isSunday(d) \u003d\u003e is_(d, Date))))))","type compatibility obligation:(forall year:int \u0026 ((year \u003e\u003d 2000) \u003d\u003e ((year \u003e\u003d 2007) \u003d\u003e (forall d in set nationalHolidaySet \u0026 is_(d, Date)))))","type compatibility obligation:(forall year:int \u0026 ((year \u003e\u003d 2000) \u003d\u003e ((not (year \u003e\u003d 2007)) \u003d\u003e (forall d in set nationalHolidaySet \u0026 is_(d, Date)))))","map compatible obligation:(forall year:int \u0026 ((year \u003e\u003d 2000) \u003d\u003e (forall ldom1 in set (dom Year2Holidays), rdom2 in set (dom {year |-\u003e ((nationalHolidaySet union mondayMakeupHolidat) union weekdayBetweenDayOff)}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (Year2Holidays(ldom1) \u003d {year |-\u003e ((nationalHolidaySet union mondayMakeupHolidat) union weekdayBetweenDayOff)}(rdom2))))))","type compatibility obligation:(forall year:int \u0026 ((year \u003e\u003d 2000) \u003d\u003e is_((Year2Holidays munion {year |-\u003e ((nationalHolidaySet union mondayMakeupHolidat) union weekdayBetweenDayOff)}), map (int) to (set of (Date)))))","legal function application obligation:(forall aNationalHolidaySet:set of (Date) \u0026 (forall d in set aNationalHolidaySet \u0026 pre_(((d.minus)(1).Year))))","legal function application obligation:(forall aNationalHolidaySet:set of (Date) \u0026 (forall d in set aNationalHolidaySet \u0026 pre_((d.Year))))","legal function application obligation:(forall aNationalHolidaySet:set of (Date) \u0026 (forall d in set aNationalHolidaySet \u0026 ((((d.minus)(1).Year)() \u003d (d.Year)()) \u003d\u003e pre_(((d.plus)(1).Year)))))","legal function application obligation:(forall aNationalHolidaySet:set of (Date) \u0026 (forall d in set aNationalHolidaySet \u0026 ((((d.minus)(1).Year)() \u003d (d.Year)()) \u003d\u003e pre_((d.Year)))))","non-empty sequence obligation:(forall mk_(aHeads, aTails):(seq of (@T) * seq of (@T)) \u0026 ((not (exists [-] ^ aTailsOfHeads:seq of (@T) \u0026 (([any1] ^ aTailsOfHeads) \u003d aHeads))) \u003d\u003e (([] \u003d aHeads) \u003d\u003e ((not ([] \u003d aTails)) \u003d\u003e ((Sequence`freverse)[@T](aTails) \u003c\u003e [])))))","cases exhaustive obligation:(forall mk_(aHeads, aTails):(seq of (@T) * seq of (@T)) \u0026 ((exists [-] ^ aTailsOfHeads:seq of (@T) \u0026 (aHeads \u003d ([any1] ^ aTailsOfHeads))) or (aHeads \u003d [])))","non-empty sequence obligation:(forall mk_(aHeads, aTails):(seq of (@T) * seq of (@T)) \u0026 ((not (exists [h] ^ -:seq of (@T) \u0026 (([h] ^ any1) \u003d aHeads))) \u003d\u003e (([] \u003d aHeads) \u003d\u003e ((not ([] \u003d aTails)) \u003d\u003e ((Sequence`freverse)[@T](aTails) \u003c\u003e [])))))","cases exhaustive obligation:(forall mk_(aHeads, aTails):(seq of (@T) * seq of (@T)) \u0026 ((exists [h] ^ -:seq of (@T) \u0026 (aHeads \u003d ([h] ^ any1))) or (aHeads \u003d [])))","recursive function obligation:(forall aSeq:seq of (@T), aQueue:(seq of (@T) * seq of (@T)) \u0026 ((not ([] \u003d aSeq)) \u003d\u003e (exists [h] ^ aTailsOfSeq:seq of (@T) \u0026 ((([h] ^ aTailsOfSeq) \u003d aSeq) \u003d\u003e let [h] ^ aTailsOfSeq \u003d aSeq in ((fromListMeasure)[seq of (@T), (seq of (@T) * seq of (@T))](aSeq, aQueue) \u003e (fromListMeasure)[@T](aTailsOfSeq, (enQueue)[@T](h, aQueue)))))))","cases exhaustive obligation:(forall aSeq:seq of (@T), aQueue:(seq of (@T) * seq of (@T)) \u0026 ((aSeq \u003d []) or (exists [h] ^ aTailsOfSeq:seq of (@T) \u0026 (aSeq \u003d ([h] ^ aTailsOfSeq)))))","type compatibility obligation:(forall aaQueue:(seq of (@T) * seq of (@T)) \u0026 ((not (mk_([], []) \u003d aaQueue)) \u003d\u003e (exists aQueue:(seq of (@T) * seq of (@T)) \u0026 ((aQueue \u003d aaQueue) \u003d\u003e let aQueue \u003d aaQueue in is_((deQueue)[@T](aQueue), (seq of (@T) * seq of (@T)))))))","recursive function obligation:(forall aaQueue:(seq of (@T) * seq of (@T)) \u0026 ((not (mk_([], []) \u003d aaQueue)) \u003d\u003e (exists aQueue:(seq of (@T) * seq of (@T)) \u0026 ((aQueue \u003d aaQueue) \u003d\u003e let aQueue \u003d aaQueue in ((toListMeasure)[[(seq of (@T) * seq of (@T))]](aaQueue) \u003e (toListMeasure)[@T]((deQueue)[@T](aQueue)))))))","cases exhaustive obligation:(forall aaQueue:(seq of (@T) * seq of (@T)) \u0026 ((aaQueue \u003d mk_([], [])) or (exists aQueue:(seq of (@T) * seq of (@T)) \u0026 (aaQueue \u003d aQueue))))","legal function application obligation:(forall s:seq of (@T) \u0026 (is_(s, seq of (real)) \u003d\u003e pre_((SumAux)[@T](s)0)))","legal function application obligation:(forall s:seq of (@T), sum:@T \u0026 ((is_(s, seq of (real)) and is_(sum, real)) \u003d\u003e ((not (s \u003d [])) \u003d\u003e pre_((SumAux)[@T]((tl s))(sum + (hd s))))))","non-empty sequence obligation:(forall s:seq of (@T), sum:@T \u0026 ((is_(s, seq of (real)) and is_(sum, real)) \u003d\u003e ((not (s \u003d [])) \u003d\u003e (s \u003c\u003e []))))","non-empty sequence obligation:(forall s:seq of (@T), sum:@T \u0026 ((is_(s, seq of (real)) and is_(sum, real)) \u003d\u003e ((not (s \u003d [])) \u003d\u003e (s \u003c\u003e []))))","legal function application obligation:(forall s:seq of (@T) \u0026 (is_(s, seq of (real)) \u003d\u003e pre_((ProductAux)[@T](s)1)))","legal function application obligation:(forall s:seq of (@T), p:@T \u0026 ((is_(s, seq of (real)) and is_(p, real)) \u003d\u003e (exists [h] ^ tail:seq of (real) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in pre_((ProductAux)[@T](tail)(p * h))))))","cases exhaustive obligation:(forall s:seq of (@T), p:@T \u0026 ((is_(s, seq of (real)) and is_(p, real)) \u003d\u003e ((exists [h] ^ tail:seq of (real) \u0026 (s \u003d ([h] ^ tail))) or (s \u003d []))))","legal function application obligation:(forall s:seq of (@T) \u0026 ((not (s \u003d [])) \u003d\u003e pre_((GetAverageAux)[@T](s)(0)(len s))))","legal function application obligation:(forall s:seq of (@T) \u0026 ((not (s \u003d [])) \u003d\u003e pre_((GetAverageAux)[@T](s)0)))","legal function application obligation:(forall s:seq of (@T), sum:@T, numberOfElem:@T \u0026 ((is_(s, seq of (real)) and (is_(sum, real) and is_(numberOfElem, real))) \u003d\u003e (exists [h] ^ tail:seq of (real) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in pre_((GetAverageAux)[@T](tail)((sum + h))numberOfElem)))))","legal function application obligation:(forall s:seq of (@T), sum:@T, numberOfElem:@T \u0026 ((is_(s, seq of (real)) and (is_(sum, real) and is_(numberOfElem, real))) \u003d\u003e (exists [h] ^ tail:seq of (real) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in pre_((GetAverageAux)[@T](tail)(sum + h))))))","non-zero obligation:(forall s:seq of (@T), sum:@T, numberOfElem:@T \u0026 ((is_(s, seq of (real)) and (is_(sum, real) and is_(numberOfElem, real))) \u003d\u003e ((not (exists [h] ^ tail:seq of (real) \u0026 (([h] ^ tail) \u003d s))) \u003d\u003e (([] \u003d s) \u003d\u003e (numberOfElem \u003c\u003e 0)))))","cases exhaustive obligation:(forall s:seq of (@T), sum:@T, numberOfElem:@T \u0026 ((is_(s, seq of (real)) and (is_(sum, real) and is_(numberOfElem, real))) \u003d\u003e ((exists [h] ^ tail:seq of (real) \u0026 (s \u003d ([h] ^ tail))) or (s \u003d []))))","legal function application obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s:seq of (@T) \u0026 (forall i, j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e pre_(decideOrderFuncs(i), s(j)))))","legal sequence application obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s:seq of (@T) \u0026 (forall i, j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e (i in set (inds s)))))","legal sequence application obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s:seq of (@T) \u0026 (forall i, j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e (j in set (inds s)))))","legal sequence application obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s:seq of (@T) \u0026 (forall i, j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e ((not decideOrderFunc(s(i), s(j))) \u003d\u003e (i in set (inds s))))))","legal sequence application obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s:seq of (@T) \u0026 (forall i, j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e ((not decideOrderFunc(s(i), s(j))) \u003d\u003e (j in set (inds s))))))","legal function application obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s:seq of (@T) \u0026 (forall i, j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e pre_(decideOrderFuncs(j), s(i)))))","legal sequence application obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s:seq of (@T) \u0026 (forall i, j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e (j in set (inds s)))))","legal sequence application obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s:seq of (@T) \u0026 (forall i, j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e (i in set (inds s)))))","legal sequence application obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s:seq of (@T) \u0026 (forall i, j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e ((not decideOrderFunc(s(j), s(i))) \u003d\u003e (i in set (inds s))))))","legal sequence application obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s:seq of (@T) \u0026 (forall i, j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e ((not decideOrderFunc(s(j), s(i))) \u003d\u003e (j in set (inds s))))))","legal function application obligation:(forall s:seq of (@T) \u0026 pre_((isAscendingTotalOrder)[@T]((lambda [x:@T, y:@T] \u0026 (if (is_(x, real) and is_(y, real))\nthen (x \u003c y)\nelse (undefined))))s))","legal function application obligation:(forall s:seq of (@T) \u0026 pre_((isDescendingTotalOrder)[@T]((lambda [x:@T, y:@T] \u0026 (if (is_(x, real) and is_(y, real))\nthen (x \u003c y)\nelse (undefined))))s))","legal function application obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s:seq of (@T) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [h] ^ tail:seq of (@T) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in pre_((sort)[@T](decideOrderFunc)[tail(i) | i in set (inds tail) \u0026 decideOrderFunc(tail(i), h)])))))","legal sequence application obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s:seq of (@T) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [h] ^ tail:seq of (@T) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in (forall i in set (inds tail) \u0026 (decideOrderFunc(tail(i), h) \u003d\u003e (i in set (inds tail))))))))","legal function application obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s:seq of (@T) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [h] ^ tail:seq of (@T) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in (forall i in set (inds tail) \u0026 pre_(decideOrderFunctail(i), h))))))","legal sequence application obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s:seq of (@T) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [h] ^ tail:seq of (@T) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in (forall i in set (inds tail) \u0026 (i in set (inds tail)))))))","legal function application obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s:seq of (@T) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [h] ^ tail:seq of (@T) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in pre_((sort)[@T](decideOrderFunc)[tail(i) | i in set (inds tail) \u0026 (not decideOrderFunc(tail(i), h))])))))","legal sequence application obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s:seq of (@T) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [h] ^ tail:seq of (@T) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in (forall i in set (inds tail) \u0026 ((not decideOrderFunc(tail(i), h)) \u003d\u003e (i in set (inds tail))))))))","legal function application obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s:seq of (@T) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [h] ^ tail:seq of (@T) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in (forall i in set (inds tail) \u0026 pre_(decideOrderFunctail(i), h))))))","legal sequence application obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s:seq of (@T) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [h] ^ tail:seq of (@T) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in (forall i in set (inds tail) \u0026 (i in set (inds tail)))))))","cases exhaustive obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s:seq of (@T) \u0026 ((s \u003d []) or (exists [h] ^ tail:seq of (@T) \u0026 (s \u003d ([h] ^ tail)))))","legal function application obligation:(forall s:seq of (@T) \u0026 pre_((sort)[@T]((lambda [x:@T, y:@T] \u0026 (if (is_(x, real) and is_(y, real))\nthen (x \u003c y)\nelse (undefined))))s))","legal function application obligation:(forall s:seq of (@T) \u0026 pre_((sort)[@T]((lambda [x:@T, y:@T] \u0026 (if (is_(x, real) and is_(y, real))\nthen (x \u003e y)\nelse (undefined))))s))","legal function application obligation:(forall decideOrderFuncSeq:seq of ((@T * @T -\u003e bool)), s1:seq of (@T), s2:seq of (@T) \u0026 ((not (mk_([], []) \u003d mk_(s1, s2))) \u003d\u003e ((not (exists mk_([], -):(seq of (@T) * seq of (@T)) \u0026 (mk_([], any1) \u003d mk_(s1, s2)))) \u003d\u003e ((not (exists mk_(-, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(any1, []) \u003d mk_(s1, s2)))) \u003d\u003e (exists mk_([h1] ^ tail1, [h2] ^ tail2):(seq of (@T) * seq of (@T)) \u0026 ((mk_(([h1] ^ tail1), ([h2] ^ tail2)) \u003d mk_(s1, s2)) \u003d\u003e let mk_([h1] ^ tail1, [h2] ^ tail2) \u003d mk_(s1, s2) in pre_((hd decideOrderFuncSeq)h1, h2)))))))","non-empty sequence obligation:(forall decideOrderFuncSeq:seq of ((@T * @T -\u003e bool)), s1:seq of (@T), s2:seq of (@T) \u0026 ((not (mk_([], []) \u003d mk_(s1, s2))) \u003d\u003e ((not (exists mk_([], -):(seq of (@T) * seq of (@T)) \u0026 (mk_([], any1) \u003d mk_(s1, s2)))) \u003d\u003e ((not (exists mk_(-, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(any1, []) \u003d mk_(s1, s2)))) \u003d\u003e (exists mk_([h1] ^ tail1, [h2] ^ tail2):(seq of (@T) * seq of (@T)) \u0026 ((mk_(([h1] ^ tail1), ([h2] ^ tail2)) \u003d mk_(s1, s2)) \u003d\u003e let mk_([h1] ^ tail1, [h2] ^ tail2) \u003d mk_(s1, s2) in (decideOrderFuncSeq \u003c\u003e [])))))))","legal function application obligation:(forall decideOrderFuncSeq:seq of ((@T * @T -\u003e bool)), s1:seq of (@T), s2:seq of (@T) \u0026 ((not (mk_([], []) \u003d mk_(s1, s2))) \u003d\u003e ((not (exists mk_([], -):(seq of (@T) * seq of (@T)) \u0026 (mk_([], any1) \u003d mk_(s1, s2)))) \u003d\u003e ((not (exists mk_(-, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(any1, []) \u003d mk_(s1, s2)))) \u003d\u003e (exists mk_([h1] ^ tail1, [h2] ^ tail2):(seq of (@T) * seq of (@T)) \u0026 ((mk_(([h1] ^ tail1), ([h2] ^ tail2)) \u003d mk_(s1, s2)) \u003d\u003e let mk_([h1] ^ tail1, [h2] ^ tail2) \u003d mk_(s1, s2) in ((not (hd decideOrderFuncSeq)(h1, h2)) \u003d\u003e ((not (hd decideOrderFuncSeq)(h2, h1)) \u003d\u003e pre_((Sequence`isOrdered)[@T]((tl decideOrderFuncSeq))(tail1)tail2)))))))))","legal function application obligation:(forall decideOrderFuncSeq:seq of ((@T * @T -\u003e bool)), s1:seq of (@T), s2:seq of (@T) \u0026 ((not (mk_([], []) \u003d mk_(s1, s2))) \u003d\u003e ((not (exists mk_([], -):(seq of (@T) * seq of (@T)) \u0026 (mk_([], any1) \u003d mk_(s1, s2)))) \u003d\u003e ((not (exists mk_(-, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(any1, []) \u003d mk_(s1, s2)))) \u003d\u003e (exists mk_([h1] ^ tail1, [h2] ^ tail2):(seq of (@T) * seq of (@T)) \u0026 ((mk_(([h1] ^ tail1), ([h2] ^ tail2)) \u003d mk_(s1, s2)) \u003d\u003e let mk_([h1] ^ tail1, [h2] ^ tail2) \u003d mk_(s1, s2) in ((not (hd decideOrderFuncSeq)(h1, h2)) \u003d\u003e ((not (hd decideOrderFuncSeq)(h2, h1)) \u003d\u003e pre_((Sequence`isOrdered)[@T]((tl decideOrderFuncSeq))tail1)))))))))","non-empty sequence obligation:(forall decideOrderFuncSeq:seq of ((@T * @T -\u003e bool)), s1:seq of (@T), s2:seq of (@T) \u0026 ((not (mk_([], []) \u003d mk_(s1, s2))) \u003d\u003e ((not (exists mk_([], -):(seq of (@T) * seq of (@T)) \u0026 (mk_([], any1) \u003d mk_(s1, s2)))) \u003d\u003e ((not (exists mk_(-, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(any1, []) \u003d mk_(s1, s2)))) \u003d\u003e (exists mk_([h1] ^ tail1, [h2] ^ tail2):(seq of (@T) * seq of (@T)) \u0026 ((mk_(([h1] ^ tail1), ([h2] ^ tail2)) \u003d mk_(s1, s2)) \u003d\u003e let mk_([h1] ^ tail1, [h2] ^ tail2) \u003d mk_(s1, s2) in ((not (hd decideOrderFuncSeq)(h1, h2)) \u003d\u003e ((not (hd decideOrderFuncSeq)(h2, h1)) \u003d\u003e (decideOrderFuncSeq \u003c\u003e [])))))))))","cases exhaustive obligation:(forall decideOrderFuncSeq:seq of ((@T * @T -\u003e bool)), s1:seq of (@T), s2:seq of (@T) \u0026 ((((mk_(s1, s2) \u003d mk_([], [])) or (exists mk_([], -):(seq of (@T) * seq of (@T)) \u0026 (mk_(s1, s2) \u003d mk_([], any1)))) or (exists mk_(-, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(s1, s2) \u003d mk_(any1, [])))) or (exists mk_([h1] ^ tail1, [h2] ^ tail2):(seq of (@T) * seq of (@T)) \u0026 (mk_(s1, s2) \u003d mk_(([h1] ^ tail1), ([h2] ^ tail2))))))","legal function application obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s1:seq of (@T), s2:seq of (@T) \u0026 ((not (exists mk_([], y):(seq of (@T) * seq of (@T)) \u0026 (mk_([], y) \u003d mk_(s1, s2)))) \u003d\u003e ((not (exists mk_(x, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(x, []) \u003d mk_(s1, s2)))) \u003d\u003e (exists mk_([h1] ^ tail1, [h2] ^ tail2):(seq of (@T) * seq of (@T)) \u0026 ((mk_(([h1] ^ tail1), ([h2] ^ tail2)) \u003d mk_(s1, s2)) \u003d\u003e let mk_([h1] ^ tail1, [h2] ^ tail2) \u003d mk_(s1, s2) in pre_(decideOrderFunch1, h2))))))","legal function application obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s1:seq of (@T), s2:seq of (@T) \u0026 ((not (exists mk_([], y):(seq of (@T) * seq of (@T)) \u0026 (mk_([], y) \u003d mk_(s1, s2)))) \u003d\u003e ((not (exists mk_(x, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(x, []) \u003d mk_(s1, s2)))) \u003d\u003e (exists mk_([h1] ^ tail1, [h2] ^ tail2):(seq of (@T) * seq of (@T)) \u0026 ((mk_(([h1] ^ tail1), ([h2] ^ tail2)) \u003d mk_(s1, s2)) \u003d\u003e let mk_([h1] ^ tail1, [h2] ^ tail2) \u003d mk_(s1, s2) in (decideOrderFunc(h1, h2) \u003d\u003e pre_((Sequence`Merge)[@T](decideOrderFunc)(tail1)s2)))))))","legal function application obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s1:seq of (@T), s2:seq of (@T) \u0026 ((not (exists mk_([], y):(seq of (@T) * seq of (@T)) \u0026 (mk_([], y) \u003d mk_(s1, s2)))) \u003d\u003e ((not (exists mk_(x, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(x, []) \u003d mk_(s1, s2)))) \u003d\u003e (exists mk_([h1] ^ tail1, [h2] ^ tail2):(seq of (@T) * seq of (@T)) \u0026 ((mk_(([h1] ^ tail1), ([h2] ^ tail2)) \u003d mk_(s1, s2)) \u003d\u003e let mk_([h1] ^ tail1, [h2] ^ tail2) \u003d mk_(s1, s2) in (decideOrderFunc(h1, h2) \u003d\u003e pre_((Sequence`Merge)[@T](decideOrderFunc)tail1)))))))","legal function application obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s1:seq of (@T), s2:seq of (@T) \u0026 ((not (exists mk_([], y):(seq of (@T) * seq of (@T)) \u0026 (mk_([], y) \u003d mk_(s1, s2)))) \u003d\u003e ((not (exists mk_(x, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(x, []) \u003d mk_(s1, s2)))) \u003d\u003e (exists mk_([h1] ^ tail1, [h2] ^ tail2):(seq of (@T) * seq of (@T)) \u0026 ((mk_(([h1] ^ tail1), ([h2] ^ tail2)) \u003d mk_(s1, s2)) \u003d\u003e let mk_([h1] ^ tail1, [h2] ^ tail2) \u003d mk_(s1, s2) in ((not decideOrderFunc(h1, h2)) \u003d\u003e pre_((Sequence`Merge)[@T](decideOrderFunc)(s1)tail2)))))))","legal function application obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s1:seq of (@T), s2:seq of (@T) \u0026 ((not (exists mk_([], y):(seq of (@T) * seq of (@T)) \u0026 (mk_([], y) \u003d mk_(s1, s2)))) \u003d\u003e ((not (exists mk_(x, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(x, []) \u003d mk_(s1, s2)))) \u003d\u003e (exists mk_([h1] ^ tail1, [h2] ^ tail2):(seq of (@T) * seq of (@T)) \u0026 ((mk_(([h1] ^ tail1), ([h2] ^ tail2)) \u003d mk_(s1, s2)) \u003d\u003e let mk_([h1] ^ tail1, [h2] ^ tail2) \u003d mk_(s1, s2) in ((not decideOrderFunc(h1, h2)) \u003d\u003e pre_((Sequence`Merge)[@T](decideOrderFunc)s1)))))))","cases exhaustive obligation:(forall decideOrderFunc:(@T * @T -\u003e bool), s1:seq of (@T), s2:seq of (@T) \u0026 (((exists mk_([], y):(seq of (@T) * seq of (@T)) \u0026 (mk_(s1, s2) \u003d mk_([], y))) or (exists mk_(x, []):(seq of (@T) * seq of (@T)) \u0026 (mk_(s1, s2) \u003d mk_(x, [])))) or (exists mk_([h1] ^ tail1, [h2] ^ tail2):(seq of (@T) * seq of (@T)) \u0026 (mk_(s1, s2) \u003d mk_(([h1] ^ tail1), ([h2] ^ tail2))))))","legal function application obligation:(forall position:nat1, e:@T, s:seq of (@T) \u0026 ((not (exists mk_(1, str):(nat1 * seq of (@T)) \u0026 (mk_(1, str) \u003d mk_(position, s)))) \u003d\u003e ((not (exists mk_(-, []):(nat1 * seq of (@T)) \u0026 (mk_(any1, []) \u003d mk_(position, s)))) \u003d\u003e (exists mk_(pos, [h] ^ tail):(nat1 * seq of (@T)) \u0026 ((mk_(pos, ([h] ^ tail)) \u003d mk_(position, s)) \u003d\u003e let mk_(pos, [h] ^ tail) \u003d mk_(position, s) in pre_((InsertAt)[@T]((pos - 1))(e)tail))))))","legal function application obligation:(forall position:nat1, e:@T, s:seq of (@T) \u0026 ((not (exists mk_(1, str):(nat1 * seq of (@T)) \u0026 (mk_(1, str) \u003d mk_(position, s)))) \u003d\u003e ((not (exists mk_(-, []):(nat1 * seq of (@T)) \u0026 (mk_(any1, []) \u003d mk_(position, s)))) \u003d\u003e (exists mk_(pos, [h] ^ tail):(nat1 * seq of (@T)) \u0026 ((mk_(pos, ([h] ^ tail)) \u003d mk_(position, s)) \u003d\u003e let mk_(pos, [h] ^ tail) \u003d mk_(position, s) in pre_((InsertAt)[@T]((pos - 1))e))))))","type compatibility obligation:(forall position:nat1, e:@T, s:seq of (@T) \u0026 ((not (exists mk_(1, str):(nat1 * seq of (@T)) \u0026 (mk_(1, str) \u003d mk_(position, s)))) \u003d\u003e ((not (exists mk_(-, []):(nat1 * seq of (@T)) \u0026 (mk_(any1, []) \u003d mk_(position, s)))) \u003d\u003e (exists mk_(pos, [h] ^ tail):(nat1 * seq of (@T)) \u0026 ((mk_(pos, ([h] ^ tail)) \u003d mk_(position, s)) \u003d\u003e let mk_(pos, [h] ^ tail) \u003d mk_(position, s) in ((pos - 1) \u003e 0))))))","cases exhaustive obligation:(forall position:nat1, e:@T, s:seq of (@T) \u0026 (((exists mk_(1, str):(nat1 * seq of (@T)) \u0026 (mk_(position, s) \u003d mk_(1, str))) or (exists mk_(-, []):(nat1 * seq of (@T)) \u0026 (mk_(position, s) \u003d mk_(any1, [])))) or (exists mk_(pos, [h] ^ tail):(nat1 * seq of (@T)) \u0026 (mk_(position, s) \u003d mk_(pos, ([h] ^ tail))))))","legal function application obligation:(forall position:nat1, s:seq of (@T) \u0026 ((not (exists mk_(1, [-] ^ tail):(nat1 * seq of (@T)) \u0026 (mk_(1, ([any1] ^ tail)) \u003d mk_(position, s)))) \u003d\u003e (exists mk_(pos, [h] ^ tail):(nat1 * seq of (@T)) \u0026 ((mk_(pos, ([h] ^ tail)) \u003d mk_(position, s)) \u003d\u003e let mk_(pos, [h] ^ tail) \u003d mk_(position, s) in pre_((RemoveAt)[@T]((pos - 1))tail)))))","type compatibility obligation:(forall position:nat1, s:seq of (@T) \u0026 ((not (exists mk_(1, [-] ^ tail):(nat1 * seq of (@T)) \u0026 (mk_(1, ([any1] ^ tail)) \u003d mk_(position, s)))) \u003d\u003e (exists mk_(pos, [h] ^ tail):(nat1 * seq of (@T)) \u0026 ((mk_(pos, ([h] ^ tail)) \u003d mk_(position, s)) \u003d\u003e let mk_(pos, [h] ^ tail) \u003d mk_(position, s) in ((pos - 1) \u003e 0)))))","cases exhaustive obligation:(forall position:nat1, s:seq of (@T) \u0026 (((exists mk_(1, [-] ^ tail):(nat1 * seq of (@T)) \u0026 (mk_(position, s) \u003d mk_(1, ([any1] ^ tail)))) or (exists mk_(pos, [h] ^ tail):(nat1 * seq of (@T)) \u0026 (mk_(position, s) \u003d mk_(pos, ([h] ^ tail))))) or (exists mk_(-, []):(nat1 * seq of (@T)) \u0026 (mk_(position, s) \u003d mk_(any1, [])))))","recursive function obligation:(forall s:seq of (@T) \u0026 (exists [h] ^ tail:seq of (@T) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in ((length_measure)[seq of (@T)](s) \u003e (length_measure)[@T]((filter)[@T]((lambda [x:@T] \u0026 (x \u003c\u003e h)))(tail))))))","legal function application obligation:(forall s:seq of (@T) \u0026 (exists [h] ^ tail:seq of (@T) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in pre_((filter)[@T]((lambda [x:@T] \u0026 (x \u003c\u003e h)))tail))))","cases exhaustive obligation:(forall s:seq of (@T) \u0026 ((exists [h] ^ tail:seq of (@T) \u0026 (s \u003d ([h] ^ tail))) or (s \u003d [])))","legal function application obligation:(forall e:@T, s:seq of (@T) \u0026 (exists [h] ^ tail:seq of (@T) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in ((not (e \u003d h)) \u003d\u003e pre_((RemoveMember)[@T](e)tail)))))","cases exhaustive obligation:(forall e:@T, s:seq of (@T) \u0026 ((exists [h] ^ tail:seq of (@T) \u0026 (s \u003d ([h] ^ tail))) or (s \u003d [])))","legal function application obligation:(forall elemSeq:seq of (@T), s:seq of (@T) \u0026 ((not ([] \u003d elemSeq)) \u003d\u003e (exists [h] ^ tail:seq of (@T) \u0026 ((([h] ^ tail) \u003d elemSeq) \u003d\u003e let [h] ^ tail \u003d elemSeq in pre_((RemoveMembers)[@T](tail)(RemoveMember)[@T](h)(s))))))","legal function application obligation:(forall elemSeq:seq of (@T), s:seq of (@T) \u0026 ((not ([] \u003d elemSeq)) \u003d\u003e (exists [h] ^ tail:seq of (@T) \u0026 ((([h] ^ tail) \u003d elemSeq) \u003d\u003e let [h] ^ tail \u003d elemSeq in pre_((RemoveMember)[@T](h)s)))))","cases exhaustive obligation:(forall elemSeq:seq of (@T), s:seq of (@T) \u0026 ((elemSeq \u003d []) or (exists [h] ^ tail:seq of (@T) \u0026 (elemSeq \u003d ([h] ^ tail)))))","legal function application obligation:(forall position:nat1, e:@T, s:seq of (@T) \u0026 ((not (exists mk_(-, []):(nat1 * seq of (@T)) \u0026 (mk_(any1, []) \u003d mk_(position, s)))) \u003d\u003e ((not (exists mk_(1, [-] ^ tail):(nat1 * seq of (@T)) \u0026 (mk_(1, ([any1] ^ tail)) \u003d mk_(position, s)))) \u003d\u003e (exists mk_(pos, [h] ^ tail):(nat1 * seq of (@T)) \u0026 ((mk_(pos, ([h] ^ tail)) \u003d mk_(position, s)) \u003d\u003e let mk_(pos, [h] ^ tail) \u003d mk_(position, s) in pre_((UpdateAt)[@T]((pos - 1))(e)tail))))))","legal function application obligation:(forall position:nat1, e:@T, s:seq of (@T) \u0026 ((not (exists mk_(-, []):(nat1 * seq of (@T)) \u0026 (mk_(any1, []) \u003d mk_(position, s)))) \u003d\u003e ((not (exists mk_(1, [-] ^ tail):(nat1 * seq of (@T)) \u0026 (mk_(1, ([any1] ^ tail)) \u003d mk_(position, s)))) \u003d\u003e (exists mk_(pos, [h] ^ tail):(nat1 * seq of (@T)) \u0026 ((mk_(pos, ([h] ^ tail)) \u003d mk_(position, s)) \u003d\u003e let mk_(pos, [h] ^ tail) \u003d mk_(position, s) in pre_((UpdateAt)[@T]((pos - 1))e))))))","type compatibility obligation:(forall position:nat1, e:@T, s:seq of (@T) \u0026 ((not (exists mk_(-, []):(nat1 * seq of (@T)) \u0026 (mk_(any1, []) \u003d mk_(position, s)))) \u003d\u003e ((not (exists mk_(1, [-] ^ tail):(nat1 * seq of (@T)) \u0026 (mk_(1, ([any1] ^ tail)) \u003d mk_(position, s)))) \u003d\u003e (exists mk_(pos, [h] ^ tail):(nat1 * seq of (@T)) \u0026 ((mk_(pos, ([h] ^ tail)) \u003d mk_(position, s)) \u003d\u003e let mk_(pos, [h] ^ tail) \u003d mk_(position, s) in ((pos - 1) \u003e 0))))))","cases exhaustive obligation:(forall position:nat1, e:@T, s:seq of (@T) \u0026 (((exists mk_(-, []):(nat1 * seq of (@T)) \u0026 (mk_(position, s) \u003d mk_(any1, []))) or (exists mk_(1, [-] ^ tail):(nat1 * seq of (@T)) \u0026 (mk_(position, s) \u003d mk_(1, ([any1] ^ tail))))) or (exists mk_(pos, [h] ^ tail):(nat1 * seq of (@T)) \u0026 (mk_(position, s) \u003d mk_(pos, ([h] ^ tail))))))","legal function application obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 (exists [h] ^ tail:seq of (@T) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in pre_(fh))))","legal function application obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 (exists [h] ^ tail:seq of (@T) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in (f(h) \u003d\u003e pre_((TakeWhile)[@T](f)tail)))))","cases exhaustive obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 ((exists [h] ^ tail:seq of (@T) \u0026 (s \u003d ([h] ^ tail))) or (s \u003d [])))","legal function application obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 (exists [h] ^ tail:seq of (@T) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in pre_(fh))))","legal function application obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 (exists [h] ^ tail:seq of (@T) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in (f(h) \u003d\u003e pre_((DropWhile)[@T](f)tail)))))","cases exhaustive obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 ((exists [h] ^ tail:seq of (@T) \u0026 (s \u003d ([h] ^ tail))) or (s \u003d [])))","legal function application obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 (exists [h] ^ tail:seq of (@T) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in pre_(fh))))","legal function application obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 (exists [h] ^ tail:seq of (@T) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in (f(h) \u003d\u003e pre_((Span)[@T](f)tail)))))","cases exhaustive obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 ((exists [h] ^ tail:seq of (@T) \u0026 (s \u003d ([h] ^ tail))) or (s \u003d [])))","legal sequence application obligation:(forall s:seq of (@T) \u0026 ((len s) in set (inds s)))","legal function application obligation:(forall f:(@T1 -\u003e @T2), s:seq of (@T1) \u0026 (forall i in set (inds s) \u0026 pre_(fs(i))))","legal sequence application obligation:(forall f:(@T1 -\u003e @T2), s:seq of (@T1) \u0026 (forall i in set (inds s) \u0026 (i in set (inds s))))","legal function application obligation:(forall f:(@elem -\u003e @elem), l:seq of (@elem) \u0026 ((not (l \u003d [])) \u003d\u003e pre_(f(hd l))))","non-empty sequence obligation:(forall f:(@elem -\u003e @elem), l:seq of (@elem) \u0026 ((not (l \u003d [])) \u003d\u003e (l \u003c\u003e [])))","legal function application obligation:(forall f:(@elem -\u003e @elem), l:seq of (@elem) \u0026 ((not (l \u003d [])) \u003d\u003e pre_((Fmap)[@elem](f)(tl l))))","non-empty sequence obligation:(forall f:(@elem -\u003e @elem), l:seq of (@elem) \u0026 ((not (l \u003d [])) \u003d\u003e (l \u003c\u003e [])))","legal sequence application obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 (forall i in set (inds s) \u0026 (f(s(i)) \u003d\u003e (i in set (inds s)))))","legal function application obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 (forall i in set (inds s) \u0026 pre_(fs(i))))","legal sequence application obligation:(forall f:(@T -\u003e bool), s:seq of (@T) \u0026 (forall i in set (inds s) \u0026 (i in set (inds s))))","legal function application obligation:(forall f:(@T1 -\u003e (@T2 -\u003e @T1)), arg:@T1, s:seq of (@T2) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [h] ^ tail:seq of (@T2) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in pre_((Foldl)[@T1, @T2](f)(f(arg)(h))tail)))))","legal function application obligation:(forall f:(@T1 -\u003e (@T2 -\u003e @T1)), arg:@T1, s:seq of (@T2) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [h] ^ tail:seq of (@T2) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in pre_((Foldl)[@T1, @T2](f)f(arg)(h))))))","legal function application obligation:(forall f:(@T1 -\u003e (@T2 -\u003e @T1)), arg:@T1, s:seq of (@T2) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [h] ^ tail:seq of (@T2) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in pre_(f(arg)h)))))","legal function application obligation:(forall f:(@T1 -\u003e (@T2 -\u003e @T1)), arg:@T1, s:seq of (@T2) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [h] ^ tail:seq of (@T2) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in pre_(farg)))))","cases exhaustive obligation:(forall f:(@T1 -\u003e (@T2 -\u003e @T1)), arg:@T1, s:seq of (@T2) \u0026 ((s \u003d []) or (exists [h] ^ tail:seq of (@T2) \u0026 (s \u003d ([h] ^ tail)))))","legal function application obligation:(forall f:(@T1 -\u003e (@T2 -\u003e @T2)), arg:@T2, s:seq of (@T1) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [h] ^ tail:seq of (@T1) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in pre_(f(h)(Foldr)[@T1, @T2](f)(arg)(tail))))))","legal function application obligation:(forall f:(@T1 -\u003e (@T2 -\u003e @T2)), arg:@T2, s:seq of (@T1) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [h] ^ tail:seq of (@T1) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in pre_(fh)))))","legal function application obligation:(forall f:(@T1 -\u003e (@T2 -\u003e @T2)), arg:@T2, s:seq of (@T1) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [h] ^ tail:seq of (@T1) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in pre_((Foldr)[@T1, @T2](f)(arg)tail)))))","legal function application obligation:(forall f:(@T1 -\u003e (@T2 -\u003e @T2)), arg:@T2, s:seq of (@T1) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [h] ^ tail:seq of (@T1) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in pre_((Foldr)[@T1, @T2](f)arg)))))","cases exhaustive obligation:(forall f:(@T1 -\u003e (@T2 -\u003e @T2)), arg:@T2, s:seq of (@T1) \u0026 ((s \u003d []) or (exists [h] ^ tail:seq of (@T1) \u0026 (s \u003d ([h] ^ tail)))))","legal function application obligation:(forall e:@T, s:seq of (@T) \u0026 (exists [h] ^ tail:seq of (@T) \u0026 ((([h] ^ tail) \u003d s) \u003d\u003e let [h] ^ tail \u003d s in ((not (e \u003d h)) \u003d\u003e pre_((isMember)[@T](e)tail)))))","cases exhaustive obligation:(forall e:@T, s:seq of (@T) \u0026 ((exists [h] ^ tail:seq of (@T) \u0026 (s \u003d ([h] ^ tail))) or (s \u003d [])))","legal function application obligation:(forall elemSeq:seq of (@T), s:seq of (@T) \u0026 (exists [h] ^ tail:seq of (@T) \u0026 ((([h] ^ tail) \u003d elemSeq) \u003d\u003e let [h] ^ tail \u003d elemSeq in pre_((isMember)[@T](h)s))))","legal function application obligation:(forall elemSeq:seq of (@T), s:seq of (@T) \u0026 (exists [h] ^ tail:seq of (@T) \u0026 ((([h] ^ tail) \u003d elemSeq) \u003d\u003e let [h] ^ tail \u003d elemSeq in ((not (isMember)[@T](h)(s)) \u003d\u003e pre_((isAnyMember)[@T](tail)s)))))","cases exhaustive obligation:(forall elemSeq:seq of (@T), s:seq of (@T) \u0026 ((exists [h] ^ tail:seq of (@T) \u0026 (elemSeq \u003d ([h] ^ tail))) or (elemSeq \u003d [])))","legal function application obligation:(forall e:@T, s:seq of (@T) \u0026 let i:nat \u003d 0 in pre_((IndexAux)[@T](e)(s)i))","legal function application obligation:(forall e:@T, s:seq of (@T) \u0026 let i:nat \u003d 0 in pre_((IndexAux)[@T](e)s))","legal function application obligation:(forall e:@T, s:seq of (@T), indx:int \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in ((not (x \u003d e)) \u003d\u003e pre_((IndexAux)[@T](e)(xs)(indx + 1)))))))","legal function application obligation:(forall e:@T, s:seq of (@T), indx:int \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [x] ^ xs:seq of (@T) \u0026 ((([x] ^ xs) \u003d s) \u003d\u003e let [x] ^ xs \u003d s in ((not (x \u003d e)) \u003d\u003e pre_((IndexAux)[@T](e)xs))))))","cases exhaustive obligation:(forall e:@T, s:seq of (@T), indx:int \u0026 ((s \u003d []) or (exists [x] ^ xs:seq of (@T) \u0026 (s \u003d ([x] ^ xs)))))","legal sequence application obligation:(forall e:@T, s:seq of (@T) \u0026 (forall i in set (inds s) \u0026 (i in set (inds s))))","legal sequence application obligation:(forall s:seq of ([@T]) \u0026 (forall i in set (inds s) \u0026 ((s(i) \u003c\u003e nil) \u003d\u003e (i in set (inds s)))))","legal sequence application obligation:(forall s:seq of ([@T]) \u0026 (forall i in set (inds s) \u0026 (i in set (inds s))))","legal sequence application obligation:(forall s:seq of (@T) \u0026 (forall i in set (inds s) \u0026 ((((len s) + 1) - i) in set (inds s))))","legal sequence application obligation:(forall s:seq of (@T) \u0026 ((not ([] \u003d s)) \u003d\u003e ((not (exists [-]:seq of (@T) \u0026 ([any1] \u003d s))) \u003d\u003e (forall i in set (inds s) \u0026 (forall j in set (Permutations)[@T]((RestSeq)[@T](s, i)) \u0026 (i in set (inds s)))))))","recursive function obligation:(forall s:seq of (@T) \u0026 ((not ([] \u003d s)) \u003d\u003e ((not (exists [-]:seq of (@T) \u0026 ([any1] \u003d s))) \u003d\u003e (forall i in set (inds s) \u0026 ((length_measure)[seq of (@T)](s) \u003e (length_measure)[@T]((RestSeq)[@T](s, i)))))))","legal sequence application obligation:(forall s:seq of (@T), i:nat \u0026 (forall j in set ((inds s) \\ {i}) \u0026 (j in set (inds s))))","recursive function obligation:(forall s:seq of ((@T1 * @T2)) \u0026 ((not ([] \u003d s)) \u003d\u003e (exists [mk_(x, y)] ^ tail:seq of ((@T1 * @T2)) \u0026 ((([mk_(x, y)] ^ tail) \u003d s) \u003d\u003e let [mk_(x, y)] ^ tail \u003d s in ((lengthUnzip)[seq of ((@T1 * @T2))](s) \u003e (lengthUnzip)[@T1, @T2](tail))))))","cases exhaustive obligation:(forall s:seq of ((@T1 * @T2)) \u0026 ((s \u003d []) or (exists [mk_(x, y)] ^ tail:seq of ((@T1 * @T2)) \u0026 (s \u003d ([mk_(x, y)] ^ tail)))))","legal function application obligation:(forall s1:seq of (@T1), s2:seq of (@T2) \u0026 pre_((Zip2)[@T1, @T2](s1)s2))","legal function application obligation:(forall s1:seq of (@T1), s2:seq of (@T2) \u0026 (exists mk_([h1] ^ tail1, [h2] ^ tail2):(seq of (@T1) * seq of (@T2)) \u0026 ((mk_(([h1] ^ tail1), ([h2] ^ tail2)) \u003d mk_(s1, s2)) \u003d\u003e let mk_([h1] ^ tail1, [h2] ^ tail2) \u003d mk_(s1, s2) in pre_((Zip2)[@T1, @T2](tail1)tail2))))","cases exhaustive obligation:(forall s1:seq of (@T1), s2:seq of (@T2) \u0026 ((exists mk_([h1] ^ tail1, [h2] ^ tail2):(seq of (@T1) * seq of (@T2)) \u0026 (mk_(s1, s2) \u003d mk_(([h1] ^ tail1), ([h2] ^ tail2)))) or (exists mk_(-, -):(seq of (@T1) * seq of (@T2)) \u0026 (mk_(s1, s2) \u003d mk_(any1, any1)))))","legal function application obligation:pre_((term1.isInThePeriod)t1, term1)","legal function application obligation:((not (term1.isInThePeriod)(t1, term1)) \u003d\u003e pre_((term1.isInThePeriod)t2, term1))","legal function application obligation:((not (term1.isInThePeriod)(t1, term1)) \u003d\u003e ((term1.isInThePeriod)(t2, term1) \u003d\u003e pre_((term1.isInThePeriod)t3, term1)))","legal function application obligation:((not (term1.isInThePeriod)(t1, term1)) \u003d\u003e ((term1.isInThePeriod)(t2, term1) \u003d\u003e ((term1.isInThePeriod)(t3, term1) \u003d\u003e pre_((term1.isInThePeriod)t4, term1))))","legal function application obligation:((not (term1.isInThePeriod)(t1, term1)) \u003d\u003e ((term1.isInThePeriod)(t2, term1) \u003d\u003e ((term1.isInThePeriod)(t3, term1) \u003d\u003e ((term1.isInThePeriod)(t4, term1) \u003d\u003e pre_((term1.isInThePeriod)t5, term1)))))","legal function application obligation:((not (term1.isInThePeriod)(t1, term1)) \u003d\u003e ((term1.isInThePeriod)(t2, term1) \u003d\u003e ((term1.isInThePeriod)(t3, term1) \u003d\u003e ((term1.isInThePeriod)(t4, term1) \u003d\u003e ((not (term1.isInThePeriod)(t5, term1)) \u003d\u003e pre_((term1.isInThePeriod)t6, term1))))))","legal function application obligation:((not (term1.isInThePeriod)(t1, term1)) \u003d\u003e ((term1.isInThePeriod)(t2, term1) \u003d\u003e ((term1.isInThePeriod)(t3, term1) \u003d\u003e ((term1.isInThePeriod)(t4, term1) \u003d\u003e ((not (term1.isInThePeriod)(t5, term1)) \u003d\u003e ((not (term1.isInThePeriod)(t6, term1)) \u003d\u003e pre_((term1.isInThePeriod)t7, term1)))))))","legal function application obligation:((not (term1.isInThePeriod)(t1, term1)) \u003d\u003e ((term1.isInThePeriod)(t2, term1) \u003d\u003e ((term1.isInThePeriod)(t3, term1) \u003d\u003e ((term1.isInThePeriod)(t4, term1) \u003d\u003e ((not (term1.isInThePeriod)(t5, term1)) \u003d\u003e ((not (term1.isInThePeriod)(t6, term1)) \u003d\u003e ((not (term1.isInThePeriod)(t7, term1)) \u003d\u003e pre_((term1.isInThePeriod)t8, term1))))))))","legal function application obligation:((not (term1.isInThePeriod)(t1, term1)) \u003d\u003e ((term1.isInThePeriod)(t2, term1) \u003d\u003e ((term1.isInThePeriod)(t3, term1) \u003d\u003e ((term1.isInThePeriod)(t4, term1) \u003d\u003e ((not (term1.isInThePeriod)(t5, term1)) \u003d\u003e ((not (term1.isInThePeriod)(t6, term1)) \u003d\u003e ((not (term1.isInThePeriod)(t7, term1)) \u003d\u003e ((not (term1.isInThePeriod)(t8, term1)) \u003d\u003e pre_((term1.isInThePeriod)t9, term1)))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aKey:@T1, aValue:@T2 \u0026 pre_(aHashCodeaKey))","legal map application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aKey:@T1, aValue:@T2 \u0026 let hashcode:@T1 \u003d aHashCode(aKey) in ((hashcode in set (dom aHashtable)) \u003d\u003e (hashcode in set (dom aHashtable))))","map compatible obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aKey:@T1, aValue:@T2 \u0026 let hashcode:@T1 \u003d aHashCode(aKey) in ((not (hashcode in set (dom aHashtable))) \u003d\u003e (forall ldom1 in set (dom aHashtable), rdom2 in set (dom {hashcode |-\u003e {aKey |-\u003e aValue}}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (aHashtable(ldom1) \u003d {hashcode |-\u003e {aKey |-\u003e aValue}}(rdom2))))))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aMap:map (@T1) to (@T2) \u0026 pre_((PutAllAux)[@T1, @T2](aHashtable)(aHashCode)(aMap)(dom aMap)))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aMap:map (@T1) to (@T2) \u0026 pre_((PutAllAux)[@T1, @T2](aHashtable)(aHashCode)aMap))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aMap:map (@T1) to (@T2) \u0026 pre_((PutAllAux)[@T1, @T2](aHashtable)aHashCode))","let be st existence obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aMap:map (@T1) to (@T2), aKeySet:set of (@T1) \u0026 ((not (aKeySet \u003d {})) \u003d\u003e (exists aKey in set aKeySet \u0026 true)))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aMap:map (@T1) to (@T2), aKeySet:set of (@T1) \u0026 ((not (aKeySet \u003d {})) \u003d\u003e (forall aKey in set aKeySet \u0026 pre_((Put)[@T1, @T2](aHashtable)(aHashCode)(aKey)aMap(aKey)))))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aMap:map (@T1) to (@T2), aKeySet:set of (@T1) \u0026 ((not (aKeySet \u003d {})) \u003d\u003e (forall aKey in set aKeySet \u0026 pre_((Put)[@T1, @T2](aHashtable)(aHashCode)aKey))))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aMap:map (@T1) to (@T2), aKeySet:set of (@T1) \u0026 ((not (aKeySet \u003d {})) \u003d\u003e (forall aKey in set aKeySet \u0026 pre_((Put)[@T1, @T2](aHashtable)aHashCode))))","legal map application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aMap:map (@T1) to (@T2), aKeySet:set of (@T1) \u0026 ((not (aKeySet \u003d {})) \u003d\u003e (forall aKey in set aKeySet \u0026 (aKey in set (dom aMap)))))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aMap:map (@T1) to (@T2), aKeySet:set of (@T1) \u0026 ((not (aKeySet \u003d {})) \u003d\u003e (forall aKey in set aKeySet \u0026 let newHashtable:map (@T1) to (map (@T1) to (@T2)) \u003d (Put)[@T1, @T2](aHashtable)(aHashCode)(aKey)(aMap(aKey)) in pre_((PutAllAux)[@T1, @T2](newHashtable)(aHashCode)(aMap)(aKeySet \\ {aKey})))))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aMap:map (@T1) to (@T2), aKeySet:set of (@T1) \u0026 ((not (aKeySet \u003d {})) \u003d\u003e (forall aKey in set aKeySet \u0026 let newHashtable:map (@T1) to (map (@T1) to (@T2)) \u003d (Put)[@T1, @T2](aHashtable)(aHashCode)(aKey)(aMap(aKey)) in pre_((PutAllAux)[@T1, @T2](newHashtable)(aHashCode)aMap))))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aMap:map (@T1) to (@T2), aKeySet:set of (@T1) \u0026 ((not (aKeySet \u003d {})) \u003d\u003e (forall aKey in set aKeySet \u0026 let newHashtable:map (@T1) to (map (@T1) to (@T2)) \u003d (Put)[@T1, @T2](aHashtable)(aHashCode)(aKey)(aMap(aKey)) in pre_((PutAllAux)[@T1, @T2](newHashtable)aHashCode))))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aKey:@T1 \u0026 pre_(aHashCodeaKey))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aKey:@T1 \u0026 let hashcode:@T1 \u003d aHashCode(aKey) in ((hashcode in set (dom aHashtable)) \u003d\u003e pre_((FMap`Get)[@T1, @T2](aHashtable(hashcode))aKey)))","legal map application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aKey:@T1 \u0026 let hashcode:@T1 \u003d aHashCode(aKey) in ((hashcode in set (dom aHashtable)) \u003d\u003e (hashcode in set (dom aHashtable))))","legal function application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aKey:@T1 \u0026 pre_(aHashCodeaKey))","comprehension map injectivity obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aKey:@T1 \u0026 let hashcode:@T1 \u003d aHashCode(aKey) in (forall m1, m2 in set {{h |-\u003e ({aKey} \u003c-: aHashtable(hashcode))} | h in set {hashcode}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4))))))","legal map application obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aKey:@T1 \u0026 let hashcode:@T1 \u003d aHashCode(aKey) in (forall h in set {hashcode} \u0026 (hashcode in set (dom aHashtable))))","map compatible obligation:(forall aHashtable:map (@T1) to (map (@T1) to (@T2)), aHashCode:(@T1 -\u003e @T1), aKey:@T1 \u0026 let hashcode:@T1 \u003d aHashCode(aKey) in (forall ldom1 in set (dom {h |-\u003e ({aKey} \u003c-: aHashtable(hashcode)) | h in set {hashcode}}), rdom2 in set (dom ({hashcode} \u003c-: aHashtable)) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e ({h |-\u003e ({aKey} \u003c-: aHashtable(hashcode)) | h in set {hashcode}}(ldom1) \u003d ({hashcode} \u003c-: aHashtable)(rdom2)))))","enumeration map injectivity obligation:(forall m1, m2 in set {{k1 |-\u003e new StringObj(\"Shin Sahara\")}, {k2 |-\u003e new StringObj(\"Kei Sato\")}, {k3 |-\u003e new StringObj(\"Hiroshi Sakoh\")}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","legal function application obligation:(((h1.getBuckets)() \u003d {|-\u003e}) \u003d\u003e pre_(((h2.get)(k1).equals)new StringObj(\"Shin Sahara\")))","legal function application obligation:(((h1.getBuckets)() \u003d {|-\u003e}) \u003d\u003e (((h2.get)(k1).equals)(new StringObj(\"Shin Sahara\")) \u003d\u003e pre_(((h2.get)(k2).equals)new StringObj(\"Kei Sato\"))))","legal function application obligation:(((h1.getBuckets)() \u003d {|-\u003e}) \u003d\u003e (((h2.get)(k1).equals)(new StringObj(\"Shin Sahara\")) \u003d\u003e (((h2.get)(k2).equals)(new StringObj(\"Kei Sato\")) \u003d\u003e pre_(((h2.get)(k3).equals)new StringObj(\"Hiroshi Sakoh\")))))","legal function application obligation:(((h1.getBuckets)() \u003d {|-\u003e}) \u003d\u003e (((h2.get)(k1).equals)(new StringObj(\"Shin Sahara\")) \u003d\u003e (((h2.get)(k2).equals)(new StringObj(\"Kei Sato\")) \u003d\u003e (((h2.get)(k3).equals)(new StringObj(\"Hiroshi Sakoh\")) \u003d\u003e pre_(((h2.get)(new IntObj(1)).equals)new StringObj(\"Shin Sahara\"))))))","legal function application obligation:(((h1.getBuckets)() \u003d {|-\u003e}) \u003d\u003e (((h2.get)(k1).equals)(new StringObj(\"Shin Sahara\")) \u003d\u003e (((h2.get)(k2).equals)(new StringObj(\"Kei Sato\")) \u003d\u003e (((h2.get)(k3).equals)(new StringObj(\"Hiroshi Sakoh\")) \u003d\u003e (((h2.get)(new IntObj(1)).equals)(new StringObj(\"Shin Sahara\")) \u003d\u003e pre_(((h2.get)(new IntObj(2)).equals)new StringObj(\"Kei Sato\")))))))","legal function application obligation:(((h1.getBuckets)() \u003d {|-\u003e}) \u003d\u003e (((h2.get)(k1).equals)(new StringObj(\"Shin Sahara\")) \u003d\u003e (((h2.get)(k2).equals)(new StringObj(\"Kei Sato\")) \u003d\u003e (((h2.get)(k3).equals)(new StringObj(\"Hiroshi Sakoh\")) \u003d\u003e (((h2.get)(new IntObj(1)).equals)(new StringObj(\"Shin Sahara\")) \u003d\u003e (((h2.get)(new IntObj(2)).equals)(new StringObj(\"Kei Sato\")) \u003d\u003e pre_(((h2.get)(new IntObj(3)).equals)new StringObj(\"Hiroshi Sakoh\"))))))))","type compatibility obligation:is_(RESULT, ())","enumeration map injectivity obligation:(forall m1, m2 in set {{new IntObj(1) |-\u003e new StringObj(\"Shin Sahara\")}, {new IntObj(2) |-\u003e new StringObj(\"Kei Sato\")}, {new IntObj(3) |-\u003e new StringObj(\"Hiroshi Sakoh\")}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","enumeration map injectivity obligation:(forall m1, m2 in set {{new StringObj(\"a\") |-\u003e new IntObj(1)}, {new StringObj(\"b\") |-\u003e new IntObj(2)}, {new StringObj(\"c\") |-\u003e new IntObj(3)}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","legal function application obligation:pre_((h1.contains)new StringObj(\"Shin Sahara\"))","legal function application obligation:((h1.contains)(new StringObj(\"Shin Sahara\")) \u003d\u003e pre_((h1.contains)new StringObj(\"Kei Sato\")))","legal function application obligation:((h1.contains)(new StringObj(\"Shin Sahara\")) \u003d\u003e ((h1.contains)(new StringObj(\"Kei Sato\")) \u003d\u003e pre_((h1.contains)new StringObj(\"Shin Sakoh\"))))","legal function application obligation:((h1.contains)(new StringObj(\"Shin Sahara\")) \u003d\u003e ((h1.contains)(new StringObj(\"Kei Sato\")) \u003d\u003e (((h1.contains)(new StringObj(\"Shin Sakoh\")) \u003d false) \u003d\u003e pre_((h1.containsKey)new IntObj(1)))))","legal function application obligation:((h1.contains)(new StringObj(\"Shin Sahara\")) \u003d\u003e ((h1.contains)(new StringObj(\"Kei Sato\")) \u003d\u003e (((h1.contains)(new StringObj(\"Shin Sakoh\")) \u003d false) \u003d\u003e ((h1.containsKey)(new IntObj(1)) \u003d\u003e pre_((h1.containsKey)new IntObj(4))))))","legal function application obligation:((h1.contains)(new StringObj(\"Shin Sahara\")) \u003d\u003e ((h1.contains)(new StringObj(\"Kei Sato\")) \u003d\u003e (((h1.contains)(new StringObj(\"Shin Sakoh\")) \u003d false) \u003d\u003e ((h1.containsKey)(new IntObj(1)) \u003d\u003e (((h1.containsKey)(new IntObj(4)) \u003d false) \u003d\u003e pre_((h2.contains)new IntObj(3)))))))","legal function application obligation:((h1.contains)(new StringObj(\"Shin Sahara\")) \u003d\u003e ((h1.contains)(new StringObj(\"Kei Sato\")) \u003d\u003e (((h1.contains)(new StringObj(\"Shin Sakoh\")) \u003d false) \u003d\u003e ((h1.containsKey)(new IntObj(1)) \u003d\u003e (((h1.containsKey)(new IntObj(4)) \u003d false) \u003d\u003e ((h2.contains)(new IntObj(3)) \u003d\u003e pre_((h2.contains)new IntObj(7))))))))","legal function application obligation:((h1.contains)(new StringObj(\"Shin Sahara\")) \u003d\u003e ((h1.contains)(new StringObj(\"Kei Sato\")) \u003d\u003e (((h1.contains)(new StringObj(\"Shin Sakoh\")) \u003d false) \u003d\u003e ((h1.containsKey)(new IntObj(1)) \u003d\u003e (((h1.containsKey)(new IntObj(4)) \u003d false) \u003d\u003e ((h2.contains)(new IntObj(3)) \u003d\u003e (((h2.contains)(new IntObj(7)) \u003d false) \u003d\u003e pre_((h2.containsKey)new StringObj(\"a\")))))))))","legal function application obligation:((h1.contains)(new StringObj(\"Shin Sahara\")) \u003d\u003e ((h1.contains)(new StringObj(\"Kei Sato\")) \u003d\u003e (((h1.contains)(new StringObj(\"Shin Sakoh\")) \u003d false) \u003d\u003e ((h1.containsKey)(new IntObj(1)) \u003d\u003e (((h1.containsKey)(new IntObj(4)) \u003d false) \u003d\u003e ((h2.contains)(new IntObj(3)) \u003d\u003e (((h2.contains)(new IntObj(7)) \u003d false) \u003d\u003e ((h2.containsKey)(new StringObj(\"a\")) \u003d\u003e pre_((h2.containsKey)new StringObj(\"d\"))))))))))","type compatibility obligation:is_(RESULT, ())","enumeration map injectivity obligation:(forall m1, m2 in set {{new IntObj(1) |-\u003e new StringObj(\"Shin Sahara\")}, {new IntObj(2) |-\u003e new StringObj(\"Kei Sato\")}, {new IntObj(3) |-\u003e new StringObj(\"Hiroshi Sakoh\")}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","enumeration map injectivity obligation:(forall m1, m2 in set {{new StringObj(\"a\") |-\u003e new IntObj(1)}, {new StringObj(\"b\") |-\u003e new IntObj(2)}, {new StringObj(\"c\") |-\u003e new IntObj(3)}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","legal function application obligation:(((h1.getBuckets)() \u003d {|-\u003e}) \u003d\u003e pre_((deleteObj.equals)new IntObj(2)))","legal function application obligation:(((h1.getBuckets)() \u003d {|-\u003e}) \u003d\u003e ((deleteObj.equals)(new IntObj(2)) \u003d\u003e (((h2.get)(new StringObj(\"b\")) \u003d nil) \u003d\u003e pre_((h2.contains)new IntObj(2)))))","legal function application obligation:(((h1.getBuckets)() \u003d {|-\u003e}) \u003d\u003e ((deleteObj.equals)(new IntObj(2)) \u003d\u003e (((h2.get)(new StringObj(\"b\")) \u003d nil) \u003d\u003e (((h2.contains)(new IntObj(2)) \u003d false) \u003d\u003e pre_((h2.containsKey)new StringObj(\"b\"))))))","type compatibility obligation:is_(RESULT, ())","enumeration map injectivity obligation:(forall m1, m2 in set {{new IntObj(1) |-\u003e new StringObj(\"Shin Sahara\")}, {new IntObj(2) |-\u003e new StringObj(\"Kei Sato\")}, {new IntObj(14) |-\u003e new StringObj(\"Hiroshi Sakoh\")}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","legal function application obligation:pre_(((h1.get)(new IntObj(1)).equals)new StringObj(\"Shin Sahara\"))","legal function application obligation:(((h1.get)(new IntObj(1)).equals)(new StringObj(\"Shin Sahara\")) \u003d\u003e pre_(((h1.get)(new IntObj(2)).equals)new StringObj(\"Kei Sato\")))","legal function application obligation:(((h1.get)(new IntObj(1)).equals)(new StringObj(\"Shin Sahara\")) \u003d\u003e (((h1.get)(new IntObj(2)).equals)(new StringObj(\"Kei Sato\")) \u003d\u003e pre_(((h1.get)(new IntObj(14)).equals)new StringObj(\"Hiroshi Sakoh\"))))","legal function application obligation:(((h1.get)(new IntObj(1)).equals)(new StringObj(\"Shin Sahara\")) \u003d\u003e (((h1.get)(new IntObj(2)).equals)(new StringObj(\"Kei Sato\")) \u003d\u003e (((h1.get)(new IntObj(14)).equals)(new StringObj(\"Hiroshi Sakoh\")) \u003d\u003e (((h1.get)(new IntObj(4)) \u003d nil) \u003d\u003e pre_(((h2.get)(new StringObj(\"a\")).equals)new IntObj(1))))))","legal function application obligation:(((h1.get)(new IntObj(1)).equals)(new StringObj(\"Shin Sahara\")) \u003d\u003e (((h1.get)(new IntObj(2)).equals)(new StringObj(\"Kei Sato\")) \u003d\u003e (((h1.get)(new IntObj(14)).equals)(new StringObj(\"Hiroshi Sakoh\")) \u003d\u003e (((h1.get)(new IntObj(4)) \u003d nil) \u003d\u003e (((h2.get)(new StringObj(\"a\")).equals)(new IntObj(1)) \u003d\u003e pre_(((h2.get)(new StringObj(\"b\")).equals)new IntObj(2)))))))","legal function application obligation:(((h1.get)(new IntObj(1)).equals)(new StringObj(\"Shin Sahara\")) \u003d\u003e (((h1.get)(new IntObj(2)).equals)(new StringObj(\"Kei Sato\")) \u003d\u003e (((h1.get)(new IntObj(14)).equals)(new StringObj(\"Hiroshi Sakoh\")) \u003d\u003e (((h1.get)(new IntObj(4)) \u003d nil) \u003d\u003e (((h2.get)(new StringObj(\"a\")).equals)(new IntObj(1)) \u003d\u003e (((h2.get)(new StringObj(\"b\")).equals)(new IntObj(2)) \u003d\u003e pre_(((h2.get)(new StringObj(\"c\")).equals)new IntObj(3))))))))","type compatibility obligation:is_(RESULT, ())","enumeration map injectivity obligation:(forall m1, m2 in set {{h1k1 |-\u003e h1v1}, {h1k2 |-\u003e h1v2}, {h1k3 |-\u003e h1v3}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","type compatibility obligation:is_(RESULT, ())","enumeration map injectivity obligation:(forall m1, m2 in set {{h1k1 |-\u003e h1v1}, {h1k2 |-\u003e h1v2}, {h1k3 |-\u003e h1v3}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","type compatibility obligation:is_(RESULT, ())","enumeration map injectivity obligation:(forall m1, m2 in set {{h1k1 |-\u003e h1v1}, {h1k2 |-\u003e h1v2}, {h1k3 |-\u003e h1v3}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","enumeration map injectivity obligation:(forall m1, m2 in set {{h1k1 |-\u003e h1v1}, {h1k2 |-\u003e h1v2}, {h1k3 |-\u003e h1v3}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","legal function application obligation:pre_((h1.isEmpty))","legal function application obligation:((h1.isEmpty)() \u003d\u003e pre_((h1.size)))","legal function application obligation:((h1.isEmpty)() \u003d\u003e (((h1.size)() \u003d 0) \u003d\u003e pre_((h2.isEmpty))))","legal function application obligation:((h1.isEmpty)() \u003d\u003e (((h1.size)() \u003d 0) \u003d\u003e (((h2.isEmpty)() \u003d false) \u003d\u003e pre_((h2.size)))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((Hashtable`PutAll)[int, seq of (char)]({|-\u003e})(aHashCode){1 |-\u003e \"Sahara\", 2 |-\u003e \"Sato\", 14 |-\u003e \"Sakoh\"})","legal function application obligation:pre_((Hashtable`PutAll)[int, seq of (char)]({|-\u003e})aHashCode)","enumeration map injectivity obligation:(forall m1, m2 in set {{1 |-\u003e \"Sahara\"}, {2 |-\u003e \"Sato\"}, {14 |-\u003e \"Sakoh\"}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","legal function application obligation:pre_(c1\"Sahara\")","legal function application obligation:(c1(\"Sahara\") \u003d\u003e pre_(c1\"Sato\"))","legal function application obligation:(c1(\"Sahara\") \u003d\u003e (c1(\"Sato\") \u003d\u003e pre_(c1\"Sakoh\")))","legal function application obligation:(c1(\"Sahara\") \u003d\u003e (c1(\"Sato\") \u003d\u003e (c1(\"Sakoh\") \u003d\u003e pre_(c1\"\"))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:(forall x:seq of (char) \u0026 ((not (x \u003d \"\")) \u003d\u003e pre_((Sequence`take)[char](1)x)))","legal function application obligation:pre_((Hashtable`PutAll)[int, seq of (char)]({|-\u003e})(aHashCode1){1 |-\u003e \"Shin Sahara\", 2 |-\u003e \"Kei Sato\", 14 |-\u003e \"Hiroshi Sakoh\"})","legal function application obligation:pre_((Hashtable`PutAll)[int, seq of (char)]({|-\u003e})aHashCode1)","enumeration map injectivity obligation:(forall m1, m2 in set {{1 |-\u003e \"Shin Sahara\"}, {2 |-\u003e \"Kei Sato\"}, {14 |-\u003e \"Hiroshi Sakoh\"}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","legal function application obligation:pre_((Hashtable`PutAll)[seq of (char), int]({|-\u003e})(aHashCode2){\"a\" |-\u003e 1, \"b\" |-\u003e 2, \"c\" |-\u003e 3})","legal function application obligation:pre_((Hashtable`PutAll)[seq of (char), int]({|-\u003e})aHashCode2)","enumeration map injectivity obligation:(forall m1, m2 in set {{\"a\" |-\u003e 1}, {\"b\" |-\u003e 2}, {\"c\" |-\u003e 3}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","legal function application obligation:pre_((Hashtable`Remove)[seq of (char), int](h2)(aHashCode2)\"b\")","legal function application obligation:pre_((Hashtable`Remove)[seq of (char), int](h2)aHashCode2)","legal function application obligation:((h3 \u003d {|-\u003e}) \u003d\u003e pre_((Hashtable`Get)[seq of (char), int](afterRemoveh2)(aHashCode2)\"b\"))","legal function application obligation:((h3 \u003d {|-\u003e}) \u003d\u003e pre_((Hashtable`Get)[seq of (char), int](afterRemoveh2)aHashCode2))","legal function application obligation:((h3 \u003d {|-\u003e}) \u003d\u003e (((Hashtable`Get)[seq of (char), int](afterRemoveh2)(aHashCode2)(\"b\") \u003d nil) \u003d\u003e pre_(c12)))","legal function application obligation:((h3 \u003d {|-\u003e}) \u003d\u003e (((Hashtable`Get)[seq of (char), int](afterRemoveh2)(aHashCode2)(\"b\") \u003d nil) \u003d\u003e ((c1(2) \u003d false) \u003d\u003e pre_(c11))))","legal function application obligation:((h3 \u003d {|-\u003e}) \u003d\u003e (((Hashtable`Get)[seq of (char), int](afterRemoveh2)(aHashCode2)(\"b\") \u003d nil) \u003d\u003e ((c1(2) \u003d false) \u003d\u003e (c1(1) \u003d\u003e pre_(c13)))))","legal function application obligation:((h3 \u003d {|-\u003e}) \u003d\u003e (((Hashtable`Get)[seq of (char), int](afterRemoveh2)(aHashCode2)(\"b\") \u003d nil) \u003d\u003e ((c1(2) \u003d false) \u003d\u003e (c1(1) \u003d\u003e (c1(3) \u003d\u003e pre_(ck1\"b\"))))))","legal function application obligation:((h3 \u003d {|-\u003e}) \u003d\u003e (((Hashtable`Get)[seq of (char), int](afterRemoveh2)(aHashCode2)(\"b\") \u003d nil) \u003d\u003e ((c1(2) \u003d false) \u003d\u003e (c1(1) \u003d\u003e (c1(3) \u003d\u003e ((ck1(\"b\") \u003d false) \u003d\u003e pre_(ck1\"a\")))))))","legal function application obligation:((h3 \u003d {|-\u003e}) \u003d\u003e (((Hashtable`Get)[seq of (char), int](afterRemoveh2)(aHashCode2)(\"b\") \u003d nil) \u003d\u003e ((c1(2) \u003d false) \u003d\u003e (c1(1) \u003d\u003e (c1(3) \u003d\u003e ((ck1(\"b\") \u003d false) \u003d\u003e (ck1(\"a\") \u003d\u003e pre_(ck1\"c\"))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(put({|-\u003e})(aHashCode)(1)\"Sahara\")","legal function application obligation:pre_(put({|-\u003e})(aHashCode)1)","legal function application obligation:pre_(put({|-\u003e})aHashCode)","legal function application obligation:pre_(put{|-\u003e})","legal function application obligation:pre_(put(p1)(aHashCode)(2)\"Bush\")","legal function application obligation:pre_(put(p1)(aHashCode)2)","legal function application obligation:pre_(put(p1)aHashCode)","legal function application obligation:pre_(putp1)","legal function application obligation:pre_(put(p2)(aHashCode)(2)\"Sato\")","legal function application obligation:pre_(put(p2)(aHashCode)2)","legal function application obligation:pre_(put(p2)aHashCode)","legal function application obligation:pre_(putp2)","legal function application obligation:pre_(put(p3)(aHashCode)(14)\"Sakoh\")","legal function application obligation:pre_(put(p3)(aHashCode)14)","legal function application obligation:pre_(put(p3)aHashCode)","legal function application obligation:pre_(putp3)","legal function application obligation:pre_(get(aHashCode)1)","legal function application obligation:pre_(getaHashCode)","legal function application obligation:((get(aHashCode)(1) \u003d \"Sahara\") \u003d\u003e pre_(get(aHashCode)2))","legal function application obligation:((get(aHashCode)(1) \u003d \"Sahara\") \u003d\u003e pre_(getaHashCode))","legal function application obligation:((get(aHashCode)(1) \u003d \"Sahara\") \u003d\u003e ((get(aHashCode)(2) \u003d \"Sato\") \u003d\u003e pre_(get(aHashCode)14)))","legal function application obligation:((get(aHashCode)(1) \u003d \"Sahara\") \u003d\u003e ((get(aHashCode)(2) \u003d \"Sato\") \u003d\u003e pre_(getaHashCode)))","legal function application obligation:((get(aHashCode)(1) \u003d \"Sahara\") \u003d\u003e ((get(aHashCode)(2) \u003d \"Sato\") \u003d\u003e ((get(aHashCode)(14) \u003d \"Sakoh\") \u003d\u003e pre_(get(aHashCode)99))))","legal function application obligation:((get(aHashCode)(1) \u003d \"Sahara\") \u003d\u003e ((get(aHashCode)(2) \u003d \"Sato\") \u003d\u003e ((get(aHashCode)(14) \u003d \"Sakoh\") \u003d\u003e pre_(getaHashCode))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(put({|-\u003e})(aHashCode)(1)\"Sahara\")","legal function application obligation:pre_(put({|-\u003e})(aHashCode)1)","legal function application obligation:pre_(put({|-\u003e})aHashCode)","legal function application obligation:pre_(put{|-\u003e})","legal function application obligation:pre_(put(p1)(aHashCode)(2)\"Bush\")","legal function application obligation:pre_(put(p1)(aHashCode)2)","legal function application obligation:pre_(put(p1)aHashCode)","legal function application obligation:pre_(putp1)","legal function application obligation:pre_(put(p2)(aHashCode)(2)\"Sato\")","legal function application obligation:pre_(put(p2)(aHashCode)2)","legal function application obligation:pre_(put(p2)aHashCode)","legal function application obligation:pre_(putp2)","legal function application obligation:pre_(put(p3)(aHashCode)(14)\"Sakoh\")","legal function application obligation:pre_(put(p3)(aHashCode)14)","legal function application obligation:pre_(put(p3)aHashCode)","legal function application obligation:pre_(putp3)","legal function application obligation:pre_(kp1)","legal function application obligation:((k(p1) \u003d {1}) \u003d\u003e pre_(vp1))","legal function application obligation:((k(p1) \u003d {1}) \u003d\u003e ((v(p1) \u003d {\"Sahara\"}) \u003d\u003e pre_(kp2)))","legal function application obligation:((k(p1) \u003d {1}) \u003d\u003e ((v(p1) \u003d {\"Sahara\"}) \u003d\u003e ((k(p2) \u003d {1, 2}) \u003d\u003e pre_(vp2))))","legal function application obligation:((k(p1) \u003d {1}) \u003d\u003e ((v(p1) \u003d {\"Sahara\"}) \u003d\u003e ((k(p2) \u003d {1, 2}) \u003d\u003e ((v(p2) \u003d {\"Sahara\", \"Bush\"}) \u003d\u003e pre_(kp4)))))","legal function application obligation:((k(p1) \u003d {1}) \u003d\u003e ((v(p1) \u003d {\"Sahara\"}) \u003d\u003e ((k(p2) \u003d {1, 2}) \u003d\u003e ((v(p2) \u003d {\"Sahara\", \"Bush\"}) \u003d\u003e ((k(p4) \u003d {1, 2, 14}) \u003d\u003e pre_(vp4))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((Hashtable`PutAll)[int, seq of (char)]({|-\u003e})(aHashCode1){1 |-\u003e \"Shin Sahara\", 2 |-\u003e \"Kei Sato\", 14 |-\u003e \"Hiroshi Sakoh\", 27 |-\u003e \"Nishikawa\"})","legal function application obligation:pre_((Hashtable`PutAll)[int, seq of (char)]({|-\u003e})aHashCode1)","enumeration map injectivity obligation:(forall m1, m2 in set {{1 |-\u003e \"Shin Sahara\"}, {2 |-\u003e \"Kei Sato\"}, {14 |-\u003e \"Hiroshi Sakoh\"}, {27 |-\u003e \"Nishikawa\"}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","legal function application obligation:pre_((Hashtable`Remove)[int, seq of (char)](h1)(aHashCode1)14)","legal function application obligation:pre_((Hashtable`Remove)[int, seq of (char)](h1)aHashCode1)","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((Hashtable`PutAll)[int, seq of (char)]({|-\u003e})(aHashCode1){1 |-\u003e \"Shin Sahara\", 2 |-\u003e \"Kei Sato\", 14 |-\u003e \"Hiroshi Sakoh\"})","legal function application obligation:pre_((Hashtable`PutAll)[int, seq of (char)]({|-\u003e})aHashCode1)","enumeration map injectivity obligation:(forall m1, m2 in set {{1 |-\u003e \"Shin Sahara\"}, {2 |-\u003e \"Kei Sato\"}, {14 |-\u003e \"Hiroshi Sakoh\"}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","legal function application obligation:pre_(remove(h1)(aHashCode1)1)","legal function application obligation:pre_(remove(h1)aHashCode1)","legal function application obligation:pre_(removeh1)","legal function application obligation:pre_(remove(h2)(aHashCode1)2)","legal function application obligation:pre_(remove(h2)aHashCode1)","legal function application obligation:pre_(removeh2)","legal function application obligation:pre_(remove(h3)(aHashCode1)14)","legal function application obligation:pre_(remove(h3)aHashCode1)","legal function application obligation:pre_(removeh3)","legal function application obligation:pre_(isemptyh4)","legal function application obligation:(isempty(h4) \u003d\u003e pre_(sizeh4))","legal function application obligation:(isempty(h4) \u003d\u003e ((size(h4) \u003d 0) \u003d\u003e pre_(isemptyh3)))","legal function application obligation:(isempty(h4) \u003d\u003e ((size(h4) \u003d 0) \u003d\u003e ((isempty(h3) \u003d false) \u003d\u003e pre_(sizeh3))))","legal function application obligation:(isempty(h4) \u003d\u003e ((size(h4) \u003d 0) \u003d\u003e ((isempty(h3) \u003d false) \u003d\u003e ((size(h3) \u003d 1) \u003d\u003e pre_(sizeh2)))))","legal function application obligation:(isempty(h4) \u003d\u003e ((size(h4) \u003d 0) \u003d\u003e ((isempty(h3) \u003d false) \u003d\u003e ((size(h3) \u003d 1) \u003d\u003e ((size(h2) \u003d 2) \u003d\u003e pre_(sizeh1))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:(((t1.getDate)().EQ)(d1) \u003d\u003e pre_((t1.Time2IntProduct)(t1.getTime)()))","legal function application obligation:(((t1.getDate)().EQ)(d1) \u003d\u003e (((t1.Time2IntProduct)((t1.getTime)()) \u003d mk_(14, 29, 30, 20)) \u003d\u003e ((mk_((t1.hour)(), (t1.minute)(), (t1.second)()) \u003d mk_(14, 29, 30)) \u003d\u003e pre_((t2.Year)))))","legal function application obligation:(((t1.getDate)().EQ)(d1) \u003d\u003e (((t1.Time2IntProduct)((t1.getTime)()) \u003d mk_(14, 29, 30, 20)) \u003d\u003e ((mk_((t1.hour)(), (t1.minute)(), (t1.second)()) \u003d mk_(14, 29, 30)) \u003d\u003e pre_((t2.Month)))))","legal function application obligation:(((t1.getDate)().EQ)(d1) \u003d\u003e (((t1.Time2IntProduct)((t1.getTime)()) \u003d mk_(14, 29, 30, 20)) \u003d\u003e ((mk_((t1.hour)(), (t1.minute)(), (t1.second)()) \u003d mk_(14, 29, 30)) \u003d\u003e pre_((t2.day)))))","legal function application obligation:(((t1.getDate)().EQ)(d1) \u003d\u003e (((t1.Time2IntProduct)((t1.getTime)()) \u003d mk_(14, 29, 30, 20)) \u003d\u003e ((mk_((t1.hour)(), (t1.minute)(), (t1.second)()) \u003d mk_(14, 29, 30)) \u003d\u003e ((mk_((t2.Year)(), (t2.Month)(), (t2.day)()) \u003d mk_(2003, 8, 1)) \u003d\u003e pre_((t2.IntProduct2TimeMillieSeconds)0, 0, 0, 0)))))","legal function application obligation:(((t1.getDate)().EQ)(d1) \u003d\u003e (((t1.Time2IntProduct)((t1.getTime)()) \u003d mk_(14, 29, 30, 20)) \u003d\u003e ((mk_((t1.hour)(), (t1.minute)(), (t1.second)()) \u003d mk_(14, 29, 30)) \u003d\u003e ((mk_((t2.Year)(), (t2.Month)(), (t2.day)()) \u003d mk_(2003, 8, 1)) \u003d\u003e (((t2.getTime)() \u003d (t2.IntProduct2TimeMillieSeconds)(0, 0, 0, 0)) \u003d\u003e (((t3.getDate)().EQ)(d3) \u003d\u003e pre_((t2.IntProduct2TimeMillieSeconds)0, 0, 0, 0)))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((t1.LT)t2)","legal function application obligation:((t1.LT)(t2) \u003d\u003e pre_((t1.LT)t4))","legal function application obligation:((t1.LT)(t2) \u003d\u003e ((t1.LT)(t4) \u003d\u003e pre_((t1.LE)t2)))","legal function application obligation:((t1.LT)(t2) \u003d\u003e ((t1.LT)(t4) \u003d\u003e ((t1.LE)(t2) \u003d\u003e pre_((t1.LE)t4))))","legal function application obligation:((t1.LT)(t2) \u003d\u003e ((t1.LT)(t4) \u003d\u003e ((t1.LE)(t2) \u003d\u003e ((t1.LE)(t4) \u003d\u003e pre_((t2.GT)t1)))))","legal function application obligation:((t1.LT)(t2) \u003d\u003e ((t1.LT)(t4) \u003d\u003e ((t1.LE)(t2) \u003d\u003e ((t1.LE)(t4) \u003d\u003e ((t2.GT)(t1) \u003d\u003e pre_((t4.GT)t1))))))","legal function application obligation:((t1.LT)(t2) \u003d\u003e ((t1.LT)(t4) \u003d\u003e ((t1.LE)(t2) \u003d\u003e ((t1.LE)(t4) \u003d\u003e ((t2.GT)(t1) \u003d\u003e ((t4.GT)(t1) \u003d\u003e pre_((t2.GE)t1)))))))","legal function application obligation:((t1.LT)(t2) \u003d\u003e ((t1.LT)(t4) \u003d\u003e ((t1.LE)(t2) \u003d\u003e ((t1.LE)(t4) \u003d\u003e ((t2.GT)(t1) \u003d\u003e ((t4.GT)(t1) \u003d\u003e ((t2.GE)(t1) \u003d\u003e pre_((t4.GE)t1))))))))","legal function application obligation:((t1.LT)(t2) \u003d\u003e ((t1.LT)(t4) \u003d\u003e ((t1.LE)(t2) \u003d\u003e ((t1.LE)(t4) \u003d\u003e ((t2.GT)(t1) \u003d\u003e ((t4.GT)(t1) \u003d\u003e ((t2.GE)(t1) \u003d\u003e ((t4.GE)(t1) \u003d\u003e pre_((t4.EQ)t5)))))))))","legal function application obligation:((t1.LT)(t2) \u003d\u003e ((t1.LT)(t4) \u003d\u003e ((t1.LE)(t2) \u003d\u003e ((t1.LE)(t4) \u003d\u003e ((t2.GT)(t1) \u003d\u003e ((t4.GT)(t1) \u003d\u003e ((t2.GE)(t1) \u003d\u003e ((t4.GE)(t1) \u003d\u003e ((t4.EQ)(t5) \u003d\u003e pre_((t4.NE)t1))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:(((t1.minute)() \u003d 29) \u003d\u003e (((t1.second)() \u003d 50) \u003d\u003e (((t2.minute)() \u003d 30) \u003d\u003e (((t2.second)() \u003d 0) \u003d\u003e (((t3.minute)() \u003d 30) \u003d\u003e (((t3.second)() \u003d 20) \u003d\u003e (((t4.minute)() \u003d 31) \u003d\u003e (((t4.second)() \u003d 0) \u003d\u003e (((t5.hour)() \u003d 14) \u003d\u003e (((t5.minute)() \u003d 32) \u003d\u003e (((t5.second)() \u003d 0) \u003d\u003e (((t6.hour)() \u003d 15) \u003d\u003e (((t6.minute)() \u003d 29) \u003d\u003e (((t6.second)() \u003d 30) \u003d\u003e (((t7.hour)() \u003d 14) \u003d\u003e (((t7.minute)() \u003d 59) \u003d\u003e (((t8.hour)() \u003d 15) \u003d\u003e (((t8.minute)() \u003d 0) \u003d\u003e (((t9.hour)() \u003d 15) \u003d\u003e (((t9.minute)() \u003d 9) \u003d\u003e (((t10.hour)() \u003d 16) \u003d\u003e (((t10.minute)() \u003d 0) \u003d\u003e (((t10.second)() \u003d 30) \u003d\u003e pre_((t11.Year)))))))))))))))))))))))))","legal function application obligation:(((t1.minute)() \u003d 29) \u003d\u003e (((t1.second)() \u003d 50) \u003d\u003e (((t2.minute)() \u003d 30) \u003d\u003e (((t2.second)() \u003d 0) \u003d\u003e (((t3.minute)() \u003d 30) \u003d\u003e (((t3.second)() \u003d 20) \u003d\u003e (((t4.minute)() \u003d 31) \u003d\u003e (((t4.second)() \u003d 0) \u003d\u003e (((t5.hour)() \u003d 14) \u003d\u003e (((t5.minute)() \u003d 32) \u003d\u003e (((t5.second)() \u003d 0) \u003d\u003e (((t6.hour)() \u003d 15) \u003d\u003e (((t6.minute)() \u003d 29) \u003d\u003e (((t6.second)() \u003d 30) \u003d\u003e (((t7.hour)() \u003d 14) \u003d\u003e (((t7.minute)() \u003d 59) \u003d\u003e (((t8.hour)() \u003d 15) \u003d\u003e (((t8.minute)() \u003d 0) \u003d\u003e (((t9.hour)() \u003d 15) \u003d\u003e (((t9.minute)() \u003d 9) \u003d\u003e (((t10.hour)() \u003d 16) \u003d\u003e (((t10.minute)() \u003d 0) \u003d\u003e (((t10.second)() \u003d 30) \u003d\u003e (((t11.Year)() \u003d 2003) \u003d\u003e pre_((t11.Month))))))))))))))))))))))))))","legal function application obligation:(((t1.minute)() \u003d 29) \u003d\u003e (((t1.second)() \u003d 50) \u003d\u003e (((t2.minute)() \u003d 30) \u003d\u003e (((t2.second)() \u003d 0) \u003d\u003e (((t3.minute)() \u003d 30) \u003d\u003e (((t3.second)() \u003d 20) \u003d\u003e (((t4.minute)() \u003d 31) \u003d\u003e (((t4.second)() \u003d 0) \u003d\u003e (((t5.hour)() \u003d 14) \u003d\u003e (((t5.minute)() \u003d 32) \u003d\u003e (((t5.second)() \u003d 0) \u003d\u003e (((t6.hour)() \u003d 15) \u003d\u003e (((t6.minute)() \u003d 29) \u003d\u003e (((t6.second)() \u003d 30) \u003d\u003e (((t7.hour)() \u003d 14) \u003d\u003e (((t7.minute)() \u003d 59) \u003d\u003e (((t8.hour)() \u003d 15) \u003d\u003e (((t8.minute)() \u003d 0) \u003d\u003e (((t9.hour)() \u003d 15) \u003d\u003e (((t9.minute)() \u003d 9) \u003d\u003e (((t10.hour)() \u003d 16) \u003d\u003e (((t10.minute)() \u003d 0) \u003d\u003e (((t10.second)() \u003d 30) \u003d\u003e (((t11.Year)() \u003d 2003) \u003d\u003e (((t11.Month)() \u003d 7) \u003d\u003e pre_((t11.day)))))))))))))))))))))))))))","legal function application obligation:(((t1.minute)() \u003d 29) \u003d\u003e (((t1.second)() \u003d 50) \u003d\u003e (((t2.minute)() \u003d 30) \u003d\u003e (((t2.second)() \u003d 0) \u003d\u003e (((t3.minute)() \u003d 30) \u003d\u003e (((t3.second)() \u003d 20) \u003d\u003e (((t4.minute)() \u003d 31) \u003d\u003e (((t4.second)() \u003d 0) \u003d\u003e (((t5.hour)() \u003d 14) \u003d\u003e (((t5.minute)() \u003d 32) \u003d\u003e (((t5.second)() \u003d 0) \u003d\u003e (((t6.hour)() \u003d 15) \u003d\u003e (((t6.minute)() \u003d 29) \u003d\u003e (((t6.second)() \u003d 30) \u003d\u003e (((t7.hour)() \u003d 14) \u003d\u003e (((t7.minute)() \u003d 59) \u003d\u003e (((t8.hour)() \u003d 15) \u003d\u003e (((t8.minute)() \u003d 0) \u003d\u003e (((t9.hour)() \u003d 15) \u003d\u003e (((t9.minute)() \u003d 9) \u003d\u003e (((t10.hour)() \u003d 16) \u003d\u003e (((t10.minute)() \u003d 0) \u003d\u003e (((t10.second)() \u003d 30) \u003d\u003e (((t11.Year)() \u003d 2003) \u003d\u003e (((t11.Month)() \u003d 7) \u003d\u003e (((t11.day)() \u003d 31) \u003d\u003e (((t11.hour)() \u003d 14) \u003d\u003e (((t11.minute)() \u003d 29) \u003d\u003e (((t11.second)() \u003d 30) \u003d\u003e pre_((t12.Year)))))))))))))))))))))))))))))))","legal function application obligation:(((t1.minute)() \u003d 29) \u003d\u003e (((t1.second)() \u003d 50) \u003d\u003e (((t2.minute)() \u003d 30) \u003d\u003e (((t2.second)() \u003d 0) \u003d\u003e (((t3.minute)() \u003d 30) \u003d\u003e (((t3.second)() \u003d 20) \u003d\u003e (((t4.minute)() \u003d 31) \u003d\u003e (((t4.second)() \u003d 0) \u003d\u003e (((t5.hour)() \u003d 14) \u003d\u003e (((t5.minute)() \u003d 32) \u003d\u003e (((t5.second)() \u003d 0) \u003d\u003e (((t6.hour)() \u003d 15) \u003d\u003e (((t6.minute)() \u003d 29) \u003d\u003e (((t6.second)() \u003d 30) \u003d\u003e (((t7.hour)() \u003d 14) \u003d\u003e (((t7.minute)() \u003d 59) \u003d\u003e (((t8.hour)() \u003d 15) \u003d\u003e (((t8.minute)() \u003d 0) \u003d\u003e (((t9.hour)() \u003d 15) \u003d\u003e (((t9.minute)() \u003d 9) \u003d\u003e (((t10.hour)() \u003d 16) \u003d\u003e (((t10.minute)() \u003d 0) \u003d\u003e (((t10.second)() \u003d 30) \u003d\u003e (((t11.Year)() \u003d 2003) \u003d\u003e (((t11.Month)() \u003d 7) \u003d\u003e (((t11.day)() \u003d 31) \u003d\u003e (((t11.hour)() \u003d 14) \u003d\u003e (((t11.minute)() \u003d 29) \u003d\u003e (((t11.second)() \u003d 30) \u003d\u003e (((t12.Year)() \u003d 2003) \u003d\u003e pre_((t12.Month))))))))))))))))))))))))))))))))","legal function application obligation:(((t1.minute)() \u003d 29) \u003d\u003e (((t1.second)() \u003d 50) \u003d\u003e (((t2.minute)() \u003d 30) \u003d\u003e (((t2.second)() \u003d 0) \u003d\u003e (((t3.minute)() \u003d 30) \u003d\u003e (((t3.second)() \u003d 20) \u003d\u003e (((t4.minute)() \u003d 31) \u003d\u003e (((t4.second)() \u003d 0) \u003d\u003e (((t5.hour)() \u003d 14) \u003d\u003e (((t5.minute)() \u003d 32) \u003d\u003e (((t5.second)() \u003d 0) \u003d\u003e (((t6.hour)() \u003d 15) \u003d\u003e (((t6.minute)() \u003d 29) \u003d\u003e (((t6.second)() \u003d 30) \u003d\u003e (((t7.hour)() \u003d 14) \u003d\u003e (((t7.minute)() \u003d 59) \u003d\u003e (((t8.hour)() \u003d 15) \u003d\u003e (((t8.minute)() \u003d 0) \u003d\u003e (((t9.hour)() \u003d 15) \u003d\u003e (((t9.minute)() \u003d 9) \u003d\u003e (((t10.hour)() \u003d 16) \u003d\u003e (((t10.minute)() \u003d 0) \u003d\u003e (((t10.second)() \u003d 30) \u003d\u003e (((t11.Year)() \u003d 2003) \u003d\u003e (((t11.Month)() \u003d 7) \u003d\u003e (((t11.day)() \u003d 31) \u003d\u003e (((t11.hour)() \u003d 14) \u003d\u003e (((t11.minute)() \u003d 29) \u003d\u003e (((t11.second)() \u003d 30) \u003d\u003e (((t12.Year)() \u003d 2003) \u003d\u003e (((t12.Month)() \u003d 7) \u003d\u003e pre_((t12.day)))))))))))))))))))))))))))))))))","legal function application obligation:(((t1.minute)() \u003d 29) \u003d\u003e (((t1.second)() \u003d 50) \u003d\u003e (((t2.minute)() \u003d 30) \u003d\u003e (((t2.second)() \u003d 0) \u003d\u003e (((t3.minute)() \u003d 30) \u003d\u003e (((t3.second)() \u003d 20) \u003d\u003e (((t4.minute)() \u003d 31) \u003d\u003e (((t4.second)() \u003d 0) \u003d\u003e (((t5.hour)() \u003d 14) \u003d\u003e (((t5.minute)() \u003d 32) \u003d\u003e (((t5.second)() \u003d 0) \u003d\u003e (((t6.hour)() \u003d 15) \u003d\u003e (((t6.minute)() \u003d 29) \u003d\u003e (((t6.second)() \u003d 30) \u003d\u003e (((t7.hour)() \u003d 14) \u003d\u003e (((t7.minute)() \u003d 59) \u003d\u003e (((t8.hour)() \u003d 15) \u003d\u003e (((t8.minute)() \u003d 0) \u003d\u003e (((t9.hour)() \u003d 15) \u003d\u003e (((t9.minute)() \u003d 9) \u003d\u003e (((t10.hour)() \u003d 16) \u003d\u003e (((t10.minute)() \u003d 0) \u003d\u003e (((t10.second)() \u003d 30) \u003d\u003e (((t11.Year)() \u003d 2003) \u003d\u003e (((t11.Month)() \u003d 7) \u003d\u003e (((t11.day)() \u003d 31) \u003d\u003e (((t11.hour)() \u003d 14) \u003d\u003e (((t11.minute)() \u003d 29) \u003d\u003e (((t11.second)() \u003d 30) \u003d\u003e (((t12.Year)() \u003d 2003) \u003d\u003e (((t12.Month)() \u003d 7) \u003d\u003e (((t12.day)() \u003d 31) \u003d\u003e (((t12.hour)() \u003d 0) \u003d\u003e (((t12.minute)() \u003d 0) \u003d\u003e (((t12.second)() \u003d 0) \u003d\u003e (((t12.milliSecond)() \u003d 123) \u003d\u003e pre_((t13.Year))))))))))))))))))))))))))))))))))))))","legal function application obligation:(((t1.minute)() \u003d 29) \u003d\u003e (((t1.second)() \u003d 50) \u003d\u003e (((t2.minute)() \u003d 30) \u003d\u003e (((t2.second)() \u003d 0) \u003d\u003e (((t3.minute)() \u003d 30) \u003d\u003e (((t3.second)() \u003d 20) \u003d\u003e (((t4.minute)() \u003d 31) \u003d\u003e (((t4.second)() \u003d 0) \u003d\u003e (((t5.hour)() \u003d 14) \u003d\u003e (((t5.minute)() \u003d 32) \u003d\u003e (((t5.second)() \u003d 0) \u003d\u003e (((t6.hour)() \u003d 15) \u003d\u003e (((t6.minute)() \u003d 29) \u003d\u003e (((t6.second)() \u003d 30) \u003d\u003e (((t7.hour)() \u003d 14) \u003d\u003e (((t7.minute)() \u003d 59) \u003d\u003e (((t8.hour)() \u003d 15) \u003d\u003e (((t8.minute)() \u003d 0) \u003d\u003e (((t9.hour)() \u003d 15) \u003d\u003e (((t9.minute)() \u003d 9) \u003d\u003e (((t10.hour)() \u003d 16) \u003d\u003e (((t10.minute)() \u003d 0) \u003d\u003e (((t10.second)() \u003d 30) \u003d\u003e (((t11.Year)() \u003d 2003) \u003d\u003e (((t11.Month)() \u003d 7) \u003d\u003e (((t11.day)() \u003d 31) \u003d\u003e (((t11.hour)() \u003d 14) \u003d\u003e (((t11.minute)() \u003d 29) \u003d\u003e (((t11.second)() \u003d 30) \u003d\u003e (((t12.Year)() \u003d 2003) \u003d\u003e (((t12.Month)() \u003d 7) \u003d\u003e (((t12.day)() \u003d 31) \u003d\u003e (((t12.hour)() \u003d 0) \u003d\u003e (((t12.minute)() \u003d 0) \u003d\u003e (((t12.second)() \u003d 0) \u003d\u003e (((t12.milliSecond)() \u003d 123) \u003d\u003e (((t13.Year)() \u003d 2003) \u003d\u003e pre_((t13.Month)))))))))))))))))))))))))))))))))))))))","legal function application obligation:(((t1.minute)() \u003d 29) \u003d\u003e (((t1.second)() \u003d 50) \u003d\u003e (((t2.minute)() \u003d 30) \u003d\u003e (((t2.second)() \u003d 0) \u003d\u003e (((t3.minute)() \u003d 30) \u003d\u003e (((t3.second)() \u003d 20) \u003d\u003e (((t4.minute)() \u003d 31) \u003d\u003e (((t4.second)() \u003d 0) \u003d\u003e (((t5.hour)() \u003d 14) \u003d\u003e (((t5.minute)() \u003d 32) \u003d\u003e (((t5.second)() \u003d 0) \u003d\u003e (((t6.hour)() \u003d 15) \u003d\u003e (((t6.minute)() \u003d 29) \u003d\u003e (((t6.second)() \u003d 30) \u003d\u003e (((t7.hour)() \u003d 14) \u003d\u003e (((t7.minute)() \u003d 59) \u003d\u003e (((t8.hour)() \u003d 15) \u003d\u003e (((t8.minute)() \u003d 0) \u003d\u003e (((t9.hour)() \u003d 15) \u003d\u003e (((t9.minute)() \u003d 9) \u003d\u003e (((t10.hour)() \u003d 16) \u003d\u003e (((t10.minute)() \u003d 0) \u003d\u003e (((t10.second)() \u003d 30) \u003d\u003e (((t11.Year)() \u003d 2003) \u003d\u003e (((t11.Month)() \u003d 7) \u003d\u003e (((t11.day)() \u003d 31) \u003d\u003e (((t11.hour)() \u003d 14) \u003d\u003e (((t11.minute)() \u003d 29) \u003d\u003e (((t11.second)() \u003d 30) \u003d\u003e (((t12.Year)() \u003d 2003) \u003d\u003e (((t12.Month)() \u003d 7) \u003d\u003e (((t12.day)() \u003d 31) \u003d\u003e (((t12.hour)() \u003d 0) \u003d\u003e (((t12.minute)() \u003d 0) \u003d\u003e (((t12.second)() \u003d 0) \u003d\u003e (((t12.milliSecond)() \u003d 123) \u003d\u003e (((t13.Year)() \u003d 2003) \u003d\u003e (((t13.Month)() \u003d 8) \u003d\u003e pre_((t13.day))))))))))))))))))))))))))))))))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((t1.Time2IntProduct)(t1.getTime)())","legal function application obligation:(((t1.Time2IntProduct)((t1.getTime)()) \u003d mk_(23, 59, 0, 0)) \u003d\u003e pre_(((t1.getDate)().date2Str)))","legal function application obligation:(((t1.Time2IntProduct)((t1.getTime)()) \u003d mk_(23, 59, 0, 0)) \u003d\u003e ((((t1.getDate)().date2Str)() \u003d \"20030729\") \u003d\u003e pre_((t2.Time2IntProduct)(t2.getTime)())))","legal function application obligation:(((t1.Time2IntProduct)((t1.getTime)()) \u003d mk_(23, 59, 0, 0)) \u003d\u003e ((((t1.getDate)().date2Str)() \u003d \"20030729\") \u003d\u003e (((t2.Time2IntProduct)((t2.getTime)()) \u003d mk_(23, 59, 0, 0)) \u003d\u003e pre_(((t2.getDate)().date2Str)))))","legal function application obligation:(((t1.Time2IntProduct)((t1.getTime)()) \u003d mk_(23, 59, 0, 0)) \u003d\u003e ((((t1.getDate)().date2Str)() \u003d \"20030729\") \u003d\u003e (((t2.Time2IntProduct)((t2.getTime)()) \u003d mk_(23, 59, 0, 0)) \u003d\u003e ((((t2.getDate)().date2Str)() \u003d \"20030728\") \u003d\u003e pre_((t3.Time2IntProduct)(t3.getTime)())))))","legal function application obligation:(((t1.Time2IntProduct)((t1.getTime)()) \u003d mk_(23, 59, 0, 0)) \u003d\u003e ((((t1.getDate)().date2Str)() \u003d \"20030729\") \u003d\u003e (((t2.Time2IntProduct)((t2.getTime)()) \u003d mk_(23, 59, 0, 0)) \u003d\u003e ((((t2.getDate)().date2Str)() \u003d \"20030728\") \u003d\u003e (((t3.Time2IntProduct)((t3.getTime)()) \u003d mk_(23, 59, 0, 0)) \u003d\u003e pre_(((t3.getDate)().date2Str)))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((t1.Time2IntProduct)(t1.getTime)())","legal function application obligation:(((t1.Time2IntProduct)((t1.getTime)()) \u003d mk_(15, 29, 30, 0)) \u003d\u003e pre_((t2.Time2IntProduct)(t2.getTime)()))","legal function application obligation:(((t1.Time2IntProduct)((t1.getTime)()) \u003d mk_(15, 29, 30, 0)) \u003d\u003e (((t2.Time2IntProduct)((t2.getTime)()) \u003d mk_(14, 19, 30, 0)) \u003d\u003e pre_((t3.Time2IntProduct)(t3.getTime)())))","legal function application obligation:(((t1.Time2IntProduct)((t1.getTime)()) \u003d mk_(15, 29, 30, 0)) \u003d\u003e (((t2.Time2IntProduct)((t2.getTime)()) \u003d mk_(14, 19, 30, 0)) \u003d\u003e (((t3.Time2IntProduct)((t3.getTime)()) \u003d mk_(14, 29, 47, 0)) \u003d\u003e pre_((t4.Time2IntProduct)(t4.getTime)()))))","legal function application obligation:(((t1.Time2IntProduct)((t1.getTime)()) \u003d mk_(15, 29, 30, 0)) \u003d\u003e (((t2.Time2IntProduct)((t2.getTime)()) \u003d mk_(14, 19, 30, 0)) \u003d\u003e (((t3.Time2IntProduct)((t3.getTime)()) \u003d mk_(14, 29, 47, 0)) \u003d\u003e (((t4.Time2IntProduct)((t4.getTime)()) \u003d mk_(14, 29, 30, 789)) \u003d\u003e pre_(((t4.getDate)().date2Str))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((new Time(cal).EQ)new Time(cal, 2001, 3, 1, 10, 11, 23, 456))","legal function application obligation:((new Time(cal).EQ)(new Time(cal, 2001, 3, 1, 10, 11, 23, 456)) \u003d\u003e pre_((new Time((homedir ^ \"/temp/BaseDay.txt\"), (homedir ^ \"/temp/Now2.txt\"), cal).EQ)new Time(cal, 2003, 10, 24, 12, 34, 56, 789)))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:((((jc.getDateFrom_yyyy_mm_dd)(2003, 3, 0).asString)() \u003d \"20030228\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2003, 2, 29).asString)() \u003d \"20030301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 0).asString)() \u003d \"20040229\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 30).asString)() \u003d \"20040301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 60).asString)() \u003d \"20040229\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 61).asString)() \u003d \"20040301\") \u003d\u003e pre_(((jc.getDateFrom_yyyy_mm_dd)(2001, 5, 1).get_yyyy_mm_dd))))))))","legal function application obligation:((((jc.getDateFrom_yyyy_mm_dd)(2003, 3, 0).asString)() \u003d \"20030228\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2003, 2, 29).asString)() \u003d \"20030301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 0).asString)() \u003d \"20040229\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 30).asString)() \u003d \"20040301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 60).asString)() \u003d \"20040229\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 61).asString)() \u003d \"20040301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2001, 5, 1).get_yyyy_mm_dd)() \u003d mk_(2001, 5, 1)) \u003d\u003e pre_((jc.getYyyymmdd)(jc.today)()))))))))","legal function application obligation:((((jc.getDateFrom_yyyy_mm_dd)(2003, 3, 0).asString)() \u003d \"20030228\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2003, 2, 29).asString)() \u003d \"20030301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 0).asString)() \u003d \"20040229\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 30).asString)() \u003d \"20040301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 60).asString)() \u003d \"20040229\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 61).asString)() \u003d \"20040301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2001, 5, 1).get_yyyy_mm_dd)() \u003d mk_(2001, 5, 1)) \u003d\u003e (((jc.getYyyymmdd)((jc.today)()) \u003d mk_(2001, 9, 12)) \u003d\u003e pre_(((jc.modifiedJulianDate2Date)((jc.julianDate2ModifiedJulianDate)(2299160)).get_yyyy_mm_dd))))))))))","legal function application obligation:((((jc.getDateFrom_yyyy_mm_dd)(2003, 3, 0).asString)() \u003d \"20030228\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2003, 2, 29).asString)() \u003d \"20030301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 0).asString)() \u003d \"20040229\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 30).asString)() \u003d \"20040301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 60).asString)() \u003d \"20040229\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 61).asString)() \u003d \"20040301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2001, 5, 1).get_yyyy_mm_dd)() \u003d mk_(2001, 5, 1)) \u003d\u003e (((jc.getYyyymmdd)((jc.today)()) \u003d mk_(2001, 9, 12)) \u003d\u003e pre_((jc.julianDate2ModifiedJulianDate)2299160)))))))))","legal function application obligation:((((jc.getDateFrom_yyyy_mm_dd)(2003, 3, 0).asString)() \u003d \"20030228\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2003, 2, 29).asString)() \u003d \"20030301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 0).asString)() \u003d \"20040229\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 30).asString)() \u003d \"20040301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 60).asString)() \u003d \"20040229\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 61).asString)() \u003d \"20040301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2001, 5, 1).get_yyyy_mm_dd)() \u003d mk_(2001, 5, 1)) \u003d\u003e (((jc.getYyyymmdd)((jc.today)()) \u003d mk_(2001, 9, 12)) \u003d\u003e ((((jc.modifiedJulianDate2Date)((jc.julianDate2ModifiedJulianDate)(2299160)).get_yyyy_mm_dd)() \u003d mk_(1582, 10, 4)) \u003d\u003e pre_((((jc.modifiedJulianDate2Date)((jc.julianDate2ModifiedJulianDate)(2299160)).plus)(1).get_yyyy_mm_dd)))))))))))","legal function application obligation:((((jc.getDateFrom_yyyy_mm_dd)(2003, 3, 0).asString)() \u003d \"20030228\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2003, 2, 29).asString)() \u003d \"20030301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 0).asString)() \u003d \"20040229\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 30).asString)() \u003d \"20040301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 60).asString)() \u003d \"20040229\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 61).asString)() \u003d \"20040301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2001, 5, 1).get_yyyy_mm_dd)() \u003d mk_(2001, 5, 1)) \u003d\u003e (((jc.getYyyymmdd)((jc.today)()) \u003d mk_(2001, 9, 12)) \u003d\u003e ((((jc.modifiedJulianDate2Date)((jc.julianDate2ModifiedJulianDate)(2299160)).get_yyyy_mm_dd)() \u003d mk_(1582, 10, 4)) \u003d\u003e pre_((jc.julianDate2ModifiedJulianDate)2299160))))))))))","legal function application obligation:((((jc.getDateFrom_yyyy_mm_dd)(2003, 3, 0).asString)() \u003d \"20030228\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2003, 2, 29).asString)() \u003d \"20030301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 0).asString)() \u003d \"20040229\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 30).asString)() \u003d \"20040301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 60).asString)() \u003d \"20040229\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 61).asString)() \u003d \"20040301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2001, 5, 1).get_yyyy_mm_dd)() \u003d mk_(2001, 5, 1)) \u003d\u003e (((jc.getYyyymmdd)((jc.today)()) \u003d mk_(2001, 9, 12)) \u003d\u003e ((((jc.modifiedJulianDate2Date)((jc.julianDate2ModifiedJulianDate)(2299160)).get_yyyy_mm_dd)() \u003d mk_(1582, 10, 4)) \u003d\u003e (((((jc.modifiedJulianDate2Date)((jc.julianDate2ModifiedJulianDate)(2299160)).plus)(1).get_yyyy_mm_dd)() \u003d mk_(1582, 10, 15)) \u003d\u003e pre_((jc.date2Str)(jc.getDateFromString)(\"20010711\"))))))))))))","type compatibility obligation:((((jc.getDateFrom_yyyy_mm_dd)(2003, 3, 0).asString)() \u003d \"20030228\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2003, 2, 29).asString)() \u003d \"20030301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 0).asString)() \u003d \"20040229\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 30).asString)() \u003d \"20040301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 60).asString)() \u003d \"20040229\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 61).asString)() \u003d \"20040301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2001, 5, 1).get_yyyy_mm_dd)() \u003d mk_(2001, 5, 1)) \u003d\u003e (((jc.getYyyymmdd)((jc.today)()) \u003d mk_(2001, 9, 12)) \u003d\u003e ((((jc.modifiedJulianDate2Date)((jc.julianDate2ModifiedJulianDate)(2299160)).get_yyyy_mm_dd)() \u003d mk_(1582, 10, 4)) \u003d\u003e (((((jc.modifiedJulianDate2Date)((jc.julianDate2ModifiedJulianDate)(2299160)).plus)(1).get_yyyy_mm_dd)() \u003d mk_(1582, 10, 15)) \u003d\u003e is_((jc.getDateFromString)(\"20010711\"), Date)))))))))))","legal function application obligation:((((jc.getDateFrom_yyyy_mm_dd)(2003, 3, 0).asString)() \u003d \"20030228\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2003, 2, 29).asString)() \u003d \"20030301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 0).asString)() \u003d \"20040229\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 30).asString)() \u003d \"20040301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 60).asString)() \u003d \"20040229\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 61).asString)() \u003d \"20040301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2001, 5, 1).get_yyyy_mm_dd)() \u003d mk_(2001, 5, 1)) \u003d\u003e (((jc.getYyyymmdd)((jc.today)()) \u003d mk_(2001, 9, 12)) \u003d\u003e ((((jc.modifiedJulianDate2Date)((jc.julianDate2ModifiedJulianDate)(2299160)).get_yyyy_mm_dd)() \u003d mk_(1582, 10, 4)) \u003d\u003e (((((jc.modifiedJulianDate2Date)((jc.julianDate2ModifiedJulianDate)(2299160)).plus)(1).get_yyyy_mm_dd)() \u003d mk_(1582, 10, 15)) \u003d\u003e (((jc.date2Str)((jc.getDateFromString)(\"20010711\")) \u003d \"20010711\") \u003d\u003e pre_((jc.convertDateFromString)\"saharashin\"))))))))))))","legal function application obligation:((((jc.getDateFrom_yyyy_mm_dd)(2003, 3, 0).asString)() \u003d \"20030228\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2003, 2, 29).asString)() \u003d \"20030301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 0).asString)() \u003d \"20040229\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 30).asString)() \u003d \"20040301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 60).asString)() \u003d \"20040229\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 61).asString)() \u003d \"20040301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2001, 5, 1).get_yyyy_mm_dd)() \u003d mk_(2001, 5, 1)) \u003d\u003e (((jc.getYyyymmdd)((jc.today)()) \u003d mk_(2001, 9, 12)) \u003d\u003e ((((jc.modifiedJulianDate2Date)((jc.julianDate2ModifiedJulianDate)(2299160)).get_yyyy_mm_dd)() \u003d mk_(1582, 10, 4)) \u003d\u003e (((((jc.modifiedJulianDate2Date)((jc.julianDate2ModifiedJulianDate)(2299160)).plus)(1).get_yyyy_mm_dd)() \u003d mk_(1582, 10, 15)) \u003d\u003e (((jc.date2Str)((jc.getDateFromString)(\"20010711\")) \u003d \"20010711\") \u003d\u003e (((jc.convertDateFromString)(\"saharashin\") \u003d nil) \u003d\u003e pre_getJapaneseDateStr((jc.getDateFrom_yyyy_mm_dd)(2001, 5, 1))))))))))))))","legal function application obligation:((((jc.getDateFrom_yyyy_mm_dd)(2003, 3, 0).asString)() \u003d \"20030228\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2003, 2, 29).asString)() \u003d \"20030301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 0).asString)() \u003d \"20040229\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 30).asString)() \u003d \"20040301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 60).asString)() \u003d \"20040229\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 61).asString)() \u003d \"20040301\") \u003d\u003e ((((jc.getDateFrom_yyyy_mm_dd)(2001, 5, 1).get_yyyy_mm_dd)() \u003d mk_(2001, 5, 1)) \u003d\u003e (((jc.getYyyymmdd)((jc.today)()) \u003d mk_(2001, 9, 12)) \u003d\u003e ((((jc.modifiedJulianDate2Date)((jc.julianDate2ModifiedJulianDate)(2299160)).get_yyyy_mm_dd)() \u003d mk_(1582, 10, 4)) \u003d\u003e (((((jc.modifiedJulianDate2Date)((jc.julianDate2ModifiedJulianDate)(2299160)).plus)(1).get_yyyy_mm_dd)() \u003d mk_(1582, 10, 15)) \u003d\u003e (((jc.date2Str)((jc.getDateFromString)(\"20010711\")) \u003d \"20010711\") \u003d\u003e (((jc.convertDateFromString)(\"saharashin\") \u003d nil) \u003d\u003e ((JapaneseCalendar`getJapaneseDateStr((jc.getDateFrom_yyyy_mm_dd)(2001, 5, 1)) \u003d \"13 5 1\") \u003d\u003e pre_((jc.getAutumnalEquinox)2001))))))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(((jc.dateAdding)((jc.getDateFrom_yyyy_mm_dd)(2001, 5, 1), 3).date2Str))","legal function application obligation:pre_((jc.dateAdding)(jc.getDateFrom_yyyy_mm_dd)(2001, 5, 1), 3)","legal function application obligation:((((jc.dateAdding)((jc.getDateFrom_yyyy_mm_dd)(2001, 5, 1), 3).date2Str)() \u003d \"20010504\") \u003d\u003e pre_((jc.diffOfDates)(jc.getDateFrom_yyyy_mm_dd)(2001, 5, 8), (jc.getDateFrom_yyyy_mm_dd)(2001, 5, 1)))","legal function application obligation:((((jc.dateAdding)((jc.getDateFrom_yyyy_mm_dd)(2001, 5, 1), 3).date2Str)() \u003d \"20010504\") \u003d\u003e (((jc.diffOfDates)((jc.getDateFrom_yyyy_mm_dd)(2001, 5, 8), (jc.getDateFrom_yyyy_mm_dd)(2001, 5, 1)) \u003d 7) \u003d\u003e pre_(((jc.dateSubtracting)((jc.getDateFrom_yyyy_mm_dd)(2001, 5, 1), 1).get_yyyy_mm_dd))))","legal function application obligation:((((jc.dateAdding)((jc.getDateFrom_yyyy_mm_dd)(2001, 5, 1), 3).date2Str)() \u003d \"20010504\") \u003d\u003e (((jc.diffOfDates)((jc.getDateFrom_yyyy_mm_dd)(2001, 5, 8), (jc.getDateFrom_yyyy_mm_dd)(2001, 5, 1)) \u003d 7) \u003d\u003e pre_((jc.dateSubtracting)(jc.getDateFrom_yyyy_mm_dd)(2001, 5, 1), 1)))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(((jc.getVernalEquinox)(2001).date2Str))","legal function application obligation:pre_((jc.getVernalEquinox)2001)","legal function application obligation:((((jc.getVernalEquinox)(2001).date2Str)() \u003d \"20010320\") \u003d\u003e pre_(((jc.getSummerSolstice)(2001).date2Str)))","legal function application obligation:((((jc.getVernalEquinox)(2001).date2Str)() \u003d \"20010320\") \u003d\u003e pre_((jc.getSummerSolstice)2001))","legal function application obligation:((((jc.getVernalEquinox)(2001).date2Str)() \u003d \"20010320\") \u003d\u003e ((((jc.getSummerSolstice)(2001).date2Str)() \u003d \"20010621\") \u003d\u003e pre_(((jc.getAutumnalEquinox)(2001).date2Str))))","legal function application obligation:((((jc.getVernalEquinox)(2001).date2Str)() \u003d \"20010320\") \u003d\u003e ((((jc.getSummerSolstice)(2001).date2Str)() \u003d \"20010621\") \u003d\u003e pre_((jc.getAutumnalEquinox)2001)))","legal function application obligation:((((jc.getVernalEquinox)(2001).date2Str)() \u003d \"20010320\") \u003d\u003e ((((jc.getSummerSolstice)(2001).date2Str)() \u003d \"20010621\") \u003d\u003e ((((jc.getAutumnalEquinox)(2001).date2Str)() \u003d \"20010923\") \u003d\u003e pre_(((jc.getWinterSolstice)(2001).date2Str)))))","legal function application obligation:((((jc.getVernalEquinox)(2001).date2Str)() \u003d \"20010320\") \u003d\u003e ((((jc.getSummerSolstice)(2001).date2Str)() \u003d \"20010621\") \u003d\u003e ((((jc.getAutumnalEquinox)(2001).date2Str)() \u003d \"20010923\") \u003d\u003e pre_((jc.getWinterSolstice)2001))))","legal function application obligation:((((jc.getVernalEquinox)(2001).date2Str)() \u003d \"20010320\") \u003d\u003e ((((jc.getSummerSolstice)(2001).date2Str)() \u003d \"20010621\") \u003d\u003e ((((jc.getAutumnalEquinox)(2001).date2Str)() \u003d \"20010923\") \u003d\u003e ((((jc.getWinterSolstice)(2001).date2Str)() \u003d \"20011222\") \u003d\u003e pre_(((jc.getVernalEquinox)(2999).date2Str))))))","legal function application obligation:((((jc.getVernalEquinox)(2001).date2Str)() \u003d \"20010320\") \u003d\u003e ((((jc.getSummerSolstice)(2001).date2Str)() \u003d \"20010621\") \u003d\u003e ((((jc.getAutumnalEquinox)(2001).date2Str)() \u003d \"20010923\") \u003d\u003e ((((jc.getWinterSolstice)(2001).date2Str)() \u003d \"20011222\") \u003d\u003e pre_((jc.getVernalEquinox)2999)))))","legal function application obligation:((((jc.getVernalEquinox)(2001).date2Str)() \u003d \"20010320\") \u003d\u003e ((((jc.getSummerSolstice)(2001).date2Str)() \u003d \"20010621\") \u003d\u003e ((((jc.getAutumnalEquinox)(2001).date2Str)() \u003d \"20010923\") \u003d\u003e ((((jc.getWinterSolstice)(2001).date2Str)() \u003d \"20011222\") \u003d\u003e ((((jc.getVernalEquinox)(2999).date2Str)() \u003d \"29990320\") \u003d\u003e pre_(((jc.getSummerSolstice)(2999).date2Str)))))))","legal function application obligation:((((jc.getVernalEquinox)(2001).date2Str)() \u003d \"20010320\") \u003d\u003e ((((jc.getSummerSolstice)(2001).date2Str)() \u003d \"20010621\") \u003d\u003e ((((jc.getAutumnalEquinox)(2001).date2Str)() \u003d \"20010923\") \u003d\u003e ((((jc.getWinterSolstice)(2001).date2Str)() \u003d \"20011222\") \u003d\u003e ((((jc.getVernalEquinox)(2999).date2Str)() \u003d \"29990320\") \u003d\u003e pre_((jc.getSummerSolstice)2999))))))","legal function application obligation:((((jc.getVernalEquinox)(2001).date2Str)() \u003d \"20010320\") \u003d\u003e ((((jc.getSummerSolstice)(2001).date2Str)() \u003d \"20010621\") \u003d\u003e ((((jc.getAutumnalEquinox)(2001).date2Str)() \u003d \"20010923\") \u003d\u003e ((((jc.getWinterSolstice)(2001).date2Str)() \u003d \"20011222\") \u003d\u003e ((((jc.getVernalEquinox)(2999).date2Str)() \u003d \"29990320\") \u003d\u003e ((((jc.getSummerSolstice)(2999).date2Str)() \u003d \"29990620\") \u003d\u003e pre_(((jc.getAutumnalEquinox)(2999).date2Str))))))))","legal function application obligation:((((jc.getVernalEquinox)(2001).date2Str)() \u003d \"20010320\") \u003d\u003e ((((jc.getSummerSolstice)(2001).date2Str)() \u003d \"20010621\") \u003d\u003e ((((jc.getAutumnalEquinox)(2001).date2Str)() \u003d \"20010923\") \u003d\u003e ((((jc.getWinterSolstice)(2001).date2Str)() \u003d \"20011222\") \u003d\u003e ((((jc.getVernalEquinox)(2999).date2Str)() \u003d \"29990320\") \u003d\u003e ((((jc.getSummerSolstice)(2999).date2Str)() \u003d \"29990620\") \u003d\u003e pre_((jc.getAutumnalEquinox)2999)))))))","legal function application obligation:((((jc.getVernalEquinox)(2001).date2Str)() \u003d \"20010320\") \u003d\u003e ((((jc.getSummerSolstice)(2001).date2Str)() \u003d \"20010621\") \u003d\u003e ((((jc.getAutumnalEquinox)(2001).date2Str)() \u003d \"20010923\") \u003d\u003e ((((jc.getWinterSolstice)(2001).date2Str)() \u003d \"20011222\") \u003d\u003e ((((jc.getVernalEquinox)(2999).date2Str)() \u003d \"29990320\") \u003d\u003e ((((jc.getSummerSolstice)(2999).date2Str)() \u003d \"29990620\") \u003d\u003e ((((jc.getAutumnalEquinox)(2999).date2Str)() \u003d \"29990922\") \u003d\u003e pre_(((jc.getWinterSolstice)(2999).date2Str)))))))))","legal function application obligation:((((jc.getVernalEquinox)(2001).date2Str)() \u003d \"20010320\") \u003d\u003e ((((jc.getSummerSolstice)(2001).date2Str)() \u003d \"20010621\") \u003d\u003e ((((jc.getAutumnalEquinox)(2001).date2Str)() \u003d \"20010923\") \u003d\u003e ((((jc.getWinterSolstice)(2001).date2Str)() \u003d \"20011222\") \u003d\u003e ((((jc.getVernalEquinox)(2999).date2Str)() \u003d \"29990320\") \u003d\u003e ((((jc.getSummerSolstice)(2999).date2Str)() \u003d \"29990620\") \u003d\u003e ((((jc.getAutumnalEquinox)(2999).date2Str)() \u003d \"29990922\") \u003d\u003e pre_((jc.getWinterSolstice)2999))))))))","legal function application obligation:((((jc.getVernalEquinox)(2001).date2Str)() \u003d \"20010320\") \u003d\u003e ((((jc.getSummerSolstice)(2001).date2Str)() \u003d \"20010621\") \u003d\u003e ((((jc.getAutumnalEquinox)(2001).date2Str)() \u003d \"20010923\") \u003d\u003e ((((jc.getWinterSolstice)(2001).date2Str)() \u003d \"20011222\") \u003d\u003e ((((jc.getVernalEquinox)(2999).date2Str)() \u003d \"29990320\") \u003d\u003e ((((jc.getSummerSolstice)(2999).date2Str)() \u003d \"29990620\") \u003d\u003e ((((jc.getAutumnalEquinox)(2999).date2Str)() \u003d \"29990922\") \u003d\u003e ((((jc.getWinterSolstice)(2999).date2Str)() \u003d \"29991222\") \u003d\u003e pre_(((jc.getWinterSolstice)(2007).date2Str))))))))))","legal function application obligation:((((jc.getVernalEquinox)(2001).date2Str)() \u003d \"20010320\") \u003d\u003e ((((jc.getSummerSolstice)(2001).date2Str)() \u003d \"20010621\") \u003d\u003e ((((jc.getAutumnalEquinox)(2001).date2Str)() \u003d \"20010923\") \u003d\u003e ((((jc.getWinterSolstice)(2001).date2Str)() \u003d \"20011222\") \u003d\u003e ((((jc.getVernalEquinox)(2999).date2Str)() \u003d \"29990320\") \u003d\u003e ((((jc.getSummerSolstice)(2999).date2Str)() \u003d \"29990620\") \u003d\u003e ((((jc.getAutumnalEquinox)(2999).date2Str)() \u003d \"29990922\") \u003d\u003e ((((jc.getWinterSolstice)(2999).date2Str)() \u003d \"29991222\") \u003d\u003e pre_((jc.getWinterSolstice)2007)))))))))","legal function application obligation:((((jc.getVernalEquinox)(2001).date2Str)() \u003d \"20010320\") \u003d\u003e ((((jc.getSummerSolstice)(2001).date2Str)() \u003d \"20010621\") \u003d\u003e ((((jc.getAutumnalEquinox)(2001).date2Str)() \u003d \"20010923\") \u003d\u003e ((((jc.getWinterSolstice)(2001).date2Str)() \u003d \"20011222\") \u003d\u003e ((((jc.getVernalEquinox)(2999).date2Str)() \u003d \"29990320\") \u003d\u003e ((((jc.getSummerSolstice)(2999).date2Str)() \u003d \"29990620\") \u003d\u003e ((((jc.getAutumnalEquinox)(2999).date2Str)() \u003d \"29990922\") \u003d\u003e ((((jc.getWinterSolstice)(2999).date2Str)() \u003d \"29991222\") \u003d\u003e ((((jc.getWinterSolstice)(2007).date2Str)() \u003d \"20071222\") \u003d\u003e pre_(((jc.getWinterSolstice)(2012).date2Str)))))))))))","legal function application obligation:((((jc.getVernalEquinox)(2001).date2Str)() \u003d \"20010320\") \u003d\u003e ((((jc.getSummerSolstice)(2001).date2Str)() \u003d \"20010621\") \u003d\u003e ((((jc.getAutumnalEquinox)(2001).date2Str)() \u003d \"20010923\") \u003d\u003e ((((jc.getWinterSolstice)(2001).date2Str)() \u003d \"20011222\") \u003d\u003e ((((jc.getVernalEquinox)(2999).date2Str)() \u003d \"29990320\") \u003d\u003e ((((jc.getSummerSolstice)(2999).date2Str)() \u003d \"29990620\") \u003d\u003e ((((jc.getAutumnalEquinox)(2999).date2Str)() \u003d \"29990922\") \u003d\u003e ((((jc.getWinterSolstice)(2999).date2Str)() \u003d \"29991222\") \u003d\u003e ((((jc.getWinterSolstice)(2007).date2Str)() \u003d \"20071222\") \u003d\u003e pre_((jc.getWinterSolstice)2012))))))))))","legal function application obligation:((((jc.getVernalEquinox)(2001).date2Str)() \u003d \"20010320\") \u003d\u003e ((((jc.getSummerSolstice)(2001).date2Str)() \u003d \"20010621\") \u003d\u003e ((((jc.getAutumnalEquinox)(2001).date2Str)() \u003d \"20010923\") \u003d\u003e ((((jc.getWinterSolstice)(2001).date2Str)() \u003d \"20011222\") \u003d\u003e ((((jc.getVernalEquinox)(2999).date2Str)() \u003d \"29990320\") \u003d\u003e ((((jc.getSummerSolstice)(2999).date2Str)() \u003d \"29990620\") \u003d\u003e ((((jc.getAutumnalEquinox)(2999).date2Str)() \u003d \"29990922\") \u003d\u003e ((((jc.getWinterSolstice)(2999).date2Str)() \u003d \"29991222\") \u003d\u003e ((((jc.getWinterSolstice)(2007).date2Str)() \u003d \"20071222\") \u003d\u003e ((((jc.getWinterSolstice)(2012).date2Str)() \u003d \"20121221\") \u003d\u003e pre_(((jc.getWinterSolstice)(2016).date2Str))))))))))))","legal function application obligation:((((jc.getVernalEquinox)(2001).date2Str)() \u003d \"20010320\") \u003d\u003e ((((jc.getSummerSolstice)(2001).date2Str)() \u003d \"20010621\") \u003d\u003e ((((jc.getAutumnalEquinox)(2001).date2Str)() \u003d \"20010923\") \u003d\u003e ((((jc.getWinterSolstice)(2001).date2Str)() \u003d \"20011222\") \u003d\u003e ((((jc.getVernalEquinox)(2999).date2Str)() \u003d \"29990320\") \u003d\u003e ((((jc.getSummerSolstice)(2999).date2Str)() \u003d \"29990620\") \u003d\u003e ((((jc.getAutumnalEquinox)(2999).date2Str)() \u003d \"29990922\") \u003d\u003e ((((jc.getWinterSolstice)(2999).date2Str)() \u003d \"29991222\") \u003d\u003e ((((jc.getWinterSolstice)(2007).date2Str)() \u003d \"20071222\") \u003d\u003e ((((jc.getWinterSolstice)(2012).date2Str)() \u003d \"20121221\") \u003d\u003e pre_((jc.getWinterSolstice)2016)))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:(forall dayOff in set setOfDayOff \u0026 pre_((jc.getYyyymmdd)dayOff))","legal function application obligation:(forall dayOff in set setOfDayOff2003 \u0026 pre_((jc.getYyyymmdd)dayOff))","legal function application obligation:(forall dayOff in set setOfDayOffIn2009 \u0026 pre_((jc.getYyyymmdd)dayOff))","legal function application obligation:((setOfDayOffBy_yyyy_mm_dd \u003d {mk_(2001, 1, 1), mk_(2001, 1, 8), mk_(2001, 2, 11), mk_(2001, 2, 12), mk_(2001, 3, 20), mk_(2001, 4, 29), mk_(2001, 4, 30), mk_(2001, 5, 3), mk_(2001, 5, 4), mk_(2001, 5, 5), mk_(2001, 7, 20), mk_(2001, 9, 15), mk_(2001, 9, 23), mk_(2001, 9, 24), mk_(2001, 10, 8), mk_(2001, 11, 3), mk_(2001, 11, 23), mk_(2001, 12, 23), mk_(2001, 12, 24)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_dd2003 \u003d {mk_(2003, 1, 1), mk_(2003, 1, 13), mk_(2003, 2, 11), mk_(2003, 3, 21), mk_(2003, 4, 29), mk_(2003, 5, 3), mk_(2003, 5, 4), mk_(2003, 5, 5), mk_(2003, 7, 21), mk_(2003, 9, 15), mk_(2003, 9, 23), mk_(2003, 10, 13), mk_(2003, 11, 3), mk_(2003, 11, 23), mk_(2003, 11, 24), mk_(2003, 12, 23)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_ddIn2009 \u003d {mk_(2009, 1, 1), mk_(2009, 1, 12), mk_(2009, 2, 11), mk_(2009, 3, 20), mk_(2009, 4, 29), mk_(2009, 5, 3), mk_(2009, 5, 4), mk_(2009, 5, 5), mk_(2009, 5, 6), mk_(2009, 7, 20), mk_(2009, 9, 21), mk_(2009, 9, 22), mk_(2009, 9, 23), mk_(2009, 10, 12), mk_(2009, 11, 3), mk_(2009, 11, 23), mk_(2009, 12, 23)}) \u003d\u003e pre_((jc.getDayOffsExceptSunday)d0401, d0430))))","type compatibility obligation:((setOfDayOffBy_yyyy_mm_dd \u003d {mk_(2001, 1, 1), mk_(2001, 1, 8), mk_(2001, 2, 11), mk_(2001, 2, 12), mk_(2001, 3, 20), mk_(2001, 4, 29), mk_(2001, 4, 30), mk_(2001, 5, 3), mk_(2001, 5, 4), mk_(2001, 5, 5), mk_(2001, 7, 20), mk_(2001, 9, 15), mk_(2001, 9, 23), mk_(2001, 9, 24), mk_(2001, 10, 8), mk_(2001, 11, 3), mk_(2001, 11, 23), mk_(2001, 12, 23), mk_(2001, 12, 24)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_dd2003 \u003d {mk_(2003, 1, 1), mk_(2003, 1, 13), mk_(2003, 2, 11), mk_(2003, 3, 21), mk_(2003, 4, 29), mk_(2003, 5, 3), mk_(2003, 5, 4), mk_(2003, 5, 5), mk_(2003, 7, 21), mk_(2003, 9, 15), mk_(2003, 9, 23), mk_(2003, 10, 13), mk_(2003, 11, 3), mk_(2003, 11, 23), mk_(2003, 11, 24), mk_(2003, 12, 23)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_ddIn2009 \u003d {mk_(2009, 1, 1), mk_(2009, 1, 12), mk_(2009, 2, 11), mk_(2009, 3, 20), mk_(2009, 4, 29), mk_(2009, 5, 3), mk_(2009, 5, 4), mk_(2009, 5, 5), mk_(2009, 5, 6), mk_(2009, 7, 20), mk_(2009, 9, 21), mk_(2009, 9, 22), mk_(2009, 9, 23), mk_(2009, 10, 12), mk_(2009, 11, 3), mk_(2009, 11, 23), mk_(2009, 12, 23)}) \u003d\u003e is_(d0401, Date))))","type compatibility obligation:((setOfDayOffBy_yyyy_mm_dd \u003d {mk_(2001, 1, 1), mk_(2001, 1, 8), mk_(2001, 2, 11), mk_(2001, 2, 12), mk_(2001, 3, 20), mk_(2001, 4, 29), mk_(2001, 4, 30), mk_(2001, 5, 3), mk_(2001, 5, 4), mk_(2001, 5, 5), mk_(2001, 7, 20), mk_(2001, 9, 15), mk_(2001, 9, 23), mk_(2001, 9, 24), mk_(2001, 10, 8), mk_(2001, 11, 3), mk_(2001, 11, 23), mk_(2001, 12, 23), mk_(2001, 12, 24)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_dd2003 \u003d {mk_(2003, 1, 1), mk_(2003, 1, 13), mk_(2003, 2, 11), mk_(2003, 3, 21), mk_(2003, 4, 29), mk_(2003, 5, 3), mk_(2003, 5, 4), mk_(2003, 5, 5), mk_(2003, 7, 21), mk_(2003, 9, 15), mk_(2003, 9, 23), mk_(2003, 10, 13), mk_(2003, 11, 3), mk_(2003, 11, 23), mk_(2003, 11, 24), mk_(2003, 12, 23)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_ddIn2009 \u003d {mk_(2009, 1, 1), mk_(2009, 1, 12), mk_(2009, 2, 11), mk_(2009, 3, 20), mk_(2009, 4, 29), mk_(2009, 5, 3), mk_(2009, 5, 4), mk_(2009, 5, 5), mk_(2009, 5, 6), mk_(2009, 7, 20), mk_(2009, 9, 21), mk_(2009, 9, 22), mk_(2009, 9, 23), mk_(2009, 10, 12), mk_(2009, 11, 3), mk_(2009, 11, 23), mk_(2009, 12, 23)}) \u003d\u003e is_(d0430, Date))))","legal function application obligation:((setOfDayOffBy_yyyy_mm_dd \u003d {mk_(2001, 1, 1), mk_(2001, 1, 8), mk_(2001, 2, 11), mk_(2001, 2, 12), mk_(2001, 3, 20), mk_(2001, 4, 29), mk_(2001, 4, 30), mk_(2001, 5, 3), mk_(2001, 5, 4), mk_(2001, 5, 5), mk_(2001, 7, 20), mk_(2001, 9, 15), mk_(2001, 9, 23), mk_(2001, 9, 24), mk_(2001, 10, 8), mk_(2001, 11, 3), mk_(2001, 11, 23), mk_(2001, 12, 23), mk_(2001, 12, 24)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_dd2003 \u003d {mk_(2003, 1, 1), mk_(2003, 1, 13), mk_(2003, 2, 11), mk_(2003, 3, 21), mk_(2003, 4, 29), mk_(2003, 5, 3), mk_(2003, 5, 4), mk_(2003, 5, 5), mk_(2003, 7, 21), mk_(2003, 9, 15), mk_(2003, 9, 23), mk_(2003, 10, 13), mk_(2003, 11, 3), mk_(2003, 11, 23), mk_(2003, 11, 24), mk_(2003, 12, 23)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_ddIn2009 \u003d {mk_(2009, 1, 1), mk_(2009, 1, 12), mk_(2009, 2, 11), mk_(2009, 3, 20), mk_(2009, 4, 29), mk_(2009, 5, 3), mk_(2009, 5, 4), mk_(2009, 5, 5), mk_(2009, 5, 6), mk_(2009, 7, 20), mk_(2009, 9, 21), mk_(2009, 9, 22), mk_(2009, 9, 23), mk_(2009, 10, 12), mk_(2009, 11, 3), mk_(2009, 11, 23), mk_(2009, 12, 23)}) \u003d\u003e (((jc.getDayOffsExceptSunday)(d0401, d0430) \u003d 2) \u003d\u003e pre_((jc.getDayOffsAndSunday)d0401, d0430)))))","type compatibility obligation:((setOfDayOffBy_yyyy_mm_dd \u003d {mk_(2001, 1, 1), mk_(2001, 1, 8), mk_(2001, 2, 11), mk_(2001, 2, 12), mk_(2001, 3, 20), mk_(2001, 4, 29), mk_(2001, 4, 30), mk_(2001, 5, 3), mk_(2001, 5, 4), mk_(2001, 5, 5), mk_(2001, 7, 20), mk_(2001, 9, 15), mk_(2001, 9, 23), mk_(2001, 9, 24), mk_(2001, 10, 8), mk_(2001, 11, 3), mk_(2001, 11, 23), mk_(2001, 12, 23), mk_(2001, 12, 24)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_dd2003 \u003d {mk_(2003, 1, 1), mk_(2003, 1, 13), mk_(2003, 2, 11), mk_(2003, 3, 21), mk_(2003, 4, 29), mk_(2003, 5, 3), mk_(2003, 5, 4), mk_(2003, 5, 5), mk_(2003, 7, 21), mk_(2003, 9, 15), mk_(2003, 9, 23), mk_(2003, 10, 13), mk_(2003, 11, 3), mk_(2003, 11, 23), mk_(2003, 11, 24), mk_(2003, 12, 23)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_ddIn2009 \u003d {mk_(2009, 1, 1), mk_(2009, 1, 12), mk_(2009, 2, 11), mk_(2009, 3, 20), mk_(2009, 4, 29), mk_(2009, 5, 3), mk_(2009, 5, 4), mk_(2009, 5, 5), mk_(2009, 5, 6), mk_(2009, 7, 20), mk_(2009, 9, 21), mk_(2009, 9, 22), mk_(2009, 9, 23), mk_(2009, 10, 12), mk_(2009, 11, 3), mk_(2009, 11, 23), mk_(2009, 12, 23)}) \u003d\u003e (((jc.getDayOffsExceptSunday)(d0401, d0430) \u003d 2) \u003d\u003e is_(d0401, Date)))))","type compatibility obligation:((setOfDayOffBy_yyyy_mm_dd \u003d {mk_(2001, 1, 1), mk_(2001, 1, 8), mk_(2001, 2, 11), mk_(2001, 2, 12), mk_(2001, 3, 20), mk_(2001, 4, 29), mk_(2001, 4, 30), mk_(2001, 5, 3), mk_(2001, 5, 4), mk_(2001, 5, 5), mk_(2001, 7, 20), mk_(2001, 9, 15), mk_(2001, 9, 23), mk_(2001, 9, 24), mk_(2001, 10, 8), mk_(2001, 11, 3), mk_(2001, 11, 23), mk_(2001, 12, 23), mk_(2001, 12, 24)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_dd2003 \u003d {mk_(2003, 1, 1), mk_(2003, 1, 13), mk_(2003, 2, 11), mk_(2003, 3, 21), mk_(2003, 4, 29), mk_(2003, 5, 3), mk_(2003, 5, 4), mk_(2003, 5, 5), mk_(2003, 7, 21), mk_(2003, 9, 15), mk_(2003, 9, 23), mk_(2003, 10, 13), mk_(2003, 11, 3), mk_(2003, 11, 23), mk_(2003, 11, 24), mk_(2003, 12, 23)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_ddIn2009 \u003d {mk_(2009, 1, 1), mk_(2009, 1, 12), mk_(2009, 2, 11), mk_(2009, 3, 20), mk_(2009, 4, 29), mk_(2009, 5, 3), mk_(2009, 5, 4), mk_(2009, 5, 5), mk_(2009, 5, 6), mk_(2009, 7, 20), mk_(2009, 9, 21), mk_(2009, 9, 22), mk_(2009, 9, 23), mk_(2009, 10, 12), mk_(2009, 11, 3), mk_(2009, 11, 23), mk_(2009, 12, 23)}) \u003d\u003e (((jc.getDayOffsExceptSunday)(d0401, d0430) \u003d 2) \u003d\u003e is_(d0430, Date)))))","legal function application obligation:((setOfDayOffBy_yyyy_mm_dd \u003d {mk_(2001, 1, 1), mk_(2001, 1, 8), mk_(2001, 2, 11), mk_(2001, 2, 12), mk_(2001, 3, 20), mk_(2001, 4, 29), mk_(2001, 4, 30), mk_(2001, 5, 3), mk_(2001, 5, 4), mk_(2001, 5, 5), mk_(2001, 7, 20), mk_(2001, 9, 15), mk_(2001, 9, 23), mk_(2001, 9, 24), mk_(2001, 10, 8), mk_(2001, 11, 3), mk_(2001, 11, 23), mk_(2001, 12, 23), mk_(2001, 12, 24)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_dd2003 \u003d {mk_(2003, 1, 1), mk_(2003, 1, 13), mk_(2003, 2, 11), mk_(2003, 3, 21), mk_(2003, 4, 29), mk_(2003, 5, 3), mk_(2003, 5, 4), mk_(2003, 5, 5), mk_(2003, 7, 21), mk_(2003, 9, 15), mk_(2003, 9, 23), mk_(2003, 10, 13), mk_(2003, 11, 3), mk_(2003, 11, 23), mk_(2003, 11, 24), mk_(2003, 12, 23)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_ddIn2009 \u003d {mk_(2009, 1, 1), mk_(2009, 1, 12), mk_(2009, 2, 11), mk_(2009, 3, 20), mk_(2009, 4, 29), mk_(2009, 5, 3), mk_(2009, 5, 4), mk_(2009, 5, 5), mk_(2009, 5, 6), mk_(2009, 7, 20), mk_(2009, 9, 21), mk_(2009, 9, 22), mk_(2009, 9, 23), mk_(2009, 10, 12), mk_(2009, 11, 3), mk_(2009, 11, 23), mk_(2009, 12, 23)}) \u003d\u003e (((jc.getDayOffsExceptSunday)(d0401, d0430) \u003d 2) \u003d\u003e (((card (jc.getDayOffsAndSunday)(d0401, d0430)) \u003d 1) \u003d\u003e pre_((jc.getDayOffsAndSunday)d0401, d0408))))))","type compatibility obligation:((setOfDayOffBy_yyyy_mm_dd \u003d {mk_(2001, 1, 1), mk_(2001, 1, 8), mk_(2001, 2, 11), mk_(2001, 2, 12), mk_(2001, 3, 20), mk_(2001, 4, 29), mk_(2001, 4, 30), mk_(2001, 5, 3), mk_(2001, 5, 4), mk_(2001, 5, 5), mk_(2001, 7, 20), mk_(2001, 9, 15), mk_(2001, 9, 23), mk_(2001, 9, 24), mk_(2001, 10, 8), mk_(2001, 11, 3), mk_(2001, 11, 23), mk_(2001, 12, 23), mk_(2001, 12, 24)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_dd2003 \u003d {mk_(2003, 1, 1), mk_(2003, 1, 13), mk_(2003, 2, 11), mk_(2003, 3, 21), mk_(2003, 4, 29), mk_(2003, 5, 3), mk_(2003, 5, 4), mk_(2003, 5, 5), mk_(2003, 7, 21), mk_(2003, 9, 15), mk_(2003, 9, 23), mk_(2003, 10, 13), mk_(2003, 11, 3), mk_(2003, 11, 23), mk_(2003, 11, 24), mk_(2003, 12, 23)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_ddIn2009 \u003d {mk_(2009, 1, 1), mk_(2009, 1, 12), mk_(2009, 2, 11), mk_(2009, 3, 20), mk_(2009, 4, 29), mk_(2009, 5, 3), mk_(2009, 5, 4), mk_(2009, 5, 5), mk_(2009, 5, 6), mk_(2009, 7, 20), mk_(2009, 9, 21), mk_(2009, 9, 22), mk_(2009, 9, 23), mk_(2009, 10, 12), mk_(2009, 11, 3), mk_(2009, 11, 23), mk_(2009, 12, 23)}) \u003d\u003e (((jc.getDayOffsExceptSunday)(d0401, d0430) \u003d 2) \u003d\u003e (((card (jc.getDayOffsAndSunday)(d0401, d0430)) \u003d 1) \u003d\u003e is_(d0401, Date))))))","type compatibility obligation:((setOfDayOffBy_yyyy_mm_dd \u003d {mk_(2001, 1, 1), mk_(2001, 1, 8), mk_(2001, 2, 11), mk_(2001, 2, 12), mk_(2001, 3, 20), mk_(2001, 4, 29), mk_(2001, 4, 30), mk_(2001, 5, 3), mk_(2001, 5, 4), mk_(2001, 5, 5), mk_(2001, 7, 20), mk_(2001, 9, 15), mk_(2001, 9, 23), mk_(2001, 9, 24), mk_(2001, 10, 8), mk_(2001, 11, 3), mk_(2001, 11, 23), mk_(2001, 12, 23), mk_(2001, 12, 24)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_dd2003 \u003d {mk_(2003, 1, 1), mk_(2003, 1, 13), mk_(2003, 2, 11), mk_(2003, 3, 21), mk_(2003, 4, 29), mk_(2003, 5, 3), mk_(2003, 5, 4), mk_(2003, 5, 5), mk_(2003, 7, 21), mk_(2003, 9, 15), mk_(2003, 9, 23), mk_(2003, 10, 13), mk_(2003, 11, 3), mk_(2003, 11, 23), mk_(2003, 11, 24), mk_(2003, 12, 23)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_ddIn2009 \u003d {mk_(2009, 1, 1), mk_(2009, 1, 12), mk_(2009, 2, 11), mk_(2009, 3, 20), mk_(2009, 4, 29), mk_(2009, 5, 3), mk_(2009, 5, 4), mk_(2009, 5, 5), mk_(2009, 5, 6), mk_(2009, 7, 20), mk_(2009, 9, 21), mk_(2009, 9, 22), mk_(2009, 9, 23), mk_(2009, 10, 12), mk_(2009, 11, 3), mk_(2009, 11, 23), mk_(2009, 12, 23)}) \u003d\u003e (((jc.getDayOffsExceptSunday)(d0401, d0430) \u003d 2) \u003d\u003e (((card (jc.getDayOffsAndSunday)(d0401, d0430)) \u003d 1) \u003d\u003e is_(d0408, Date))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e pre_((jc.EQ)d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)))","type compatibility obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e is_(d0711, Date))","legal function application obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e pre_((jc.LT)d0301, d0711))))","type compatibility obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e is_(d0711, Date))))","legal function application obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e pre_((jc.GT)d0711, d0301))))))","type compatibility obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e is_(d0711, Date))))))","legal function application obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e ((jc.GT)(d0711, d0301) \u003d\u003e ((d0711.GE)(d0711) \u003d\u003e ((d0711.GE)(d0301) \u003d\u003e pre_((jc.GE)d0711, d0711)))))))))","type compatibility obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e ((jc.GT)(d0711, d0301) \u003d\u003e ((d0711.GE)(d0711) \u003d\u003e ((d0711.GE)(d0301) \u003d\u003e is_(d0711, Date)))))))))","type compatibility obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e ((jc.GT)(d0711, d0301) \u003d\u003e ((d0711.GE)(d0711) \u003d\u003e ((d0711.GE)(d0301) \u003d\u003e is_(d0711, Date)))))))))","legal function application obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e ((jc.GT)(d0711, d0301) \u003d\u003e ((d0711.GE)(d0711) \u003d\u003e ((d0711.GE)(d0301) \u003d\u003e ((jc.GE)(d0711, d0711) \u003d\u003e pre_((jc.GE)d0711, d0301))))))))))","type compatibility obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e ((jc.GT)(d0711, d0301) \u003d\u003e ((d0711.GE)(d0711) \u003d\u003e ((d0711.GE)(d0301) \u003d\u003e ((jc.GE)(d0711, d0711) \u003d\u003e is_(d0711, Date))))))))))","legal function application obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e ((jc.GT)(d0711, d0301) \u003d\u003e ((d0711.GE)(d0711) \u003d\u003e ((d0711.GE)(d0301) \u003d\u003e ((jc.GE)(d0711, d0711) \u003d\u003e ((jc.GE)(d0711, d0301) \u003d\u003e ((d0711.LE)(d0711) \u003d\u003e ((d0301.LE)(d0711) \u003d\u003e pre_((jc.LE)d0711, d0711)))))))))))))","type compatibility obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e ((jc.GT)(d0711, d0301) \u003d\u003e ((d0711.GE)(d0711) \u003d\u003e ((d0711.GE)(d0301) \u003d\u003e ((jc.GE)(d0711, d0711) \u003d\u003e ((jc.GE)(d0711, d0301) \u003d\u003e ((d0711.LE)(d0711) \u003d\u003e ((d0301.LE)(d0711) \u003d\u003e is_(d0711, Date)))))))))))))","type compatibility obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e ((jc.GT)(d0711, d0301) \u003d\u003e ((d0711.GE)(d0711) \u003d\u003e ((d0711.GE)(d0301) \u003d\u003e ((jc.GE)(d0711, d0711) \u003d\u003e ((jc.GE)(d0711, d0301) \u003d\u003e ((d0711.LE)(d0711) \u003d\u003e ((d0301.LE)(d0711) \u003d\u003e is_(d0711, Date)))))))))))))","legal function application obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e ((jc.GT)(d0711, d0301) \u003d\u003e ((d0711.GE)(d0711) \u003d\u003e ((d0711.GE)(d0301) \u003d\u003e ((jc.GE)(d0711, d0711) \u003d\u003e ((jc.GE)(d0711, d0301) \u003d\u003e ((d0711.LE)(d0711) \u003d\u003e ((d0301.LE)(d0711) \u003d\u003e ((jc.LE)(d0711, d0711) \u003d\u003e pre_((jc.LE)d0301, d0711))))))))))))))","type compatibility obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e ((jc.GT)(d0711, d0301) \u003d\u003e ((d0711.GE)(d0711) \u003d\u003e ((d0711.GE)(d0301) \u003d\u003e ((jc.GE)(d0711, d0711) \u003d\u003e ((jc.GE)(d0711, d0301) \u003d\u003e ((d0711.LE)(d0711) \u003d\u003e ((d0301.LE)(d0711) \u003d\u003e ((jc.LE)(d0711, d0711) \u003d\u003e is_(d0711, Date))))))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd))","legal function application obligation:pre_((jc.firstDayOfTheWeekInMonth)2000, 3, \u003cWed\u003e)","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e pre_(((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e pre_((jc.firstDayOfTheWeekInMonth)2001, 7, \u003cSun\u003e))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e pre_(((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd))))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e pre_((jc.lastDayOfTheWeekInMonth)2000, 2, \u003cTue\u003e)))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e pre_(((jc.lastDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)))))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e pre_((jc.lastDayOfTheWeekInMonth)2001, 7, \u003cSun\u003e))))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e pre_(((jc.getNthDayOfTheWeek)(2001, 7, 5, \u003cSun\u003e).get_yyyy_mm_dd))))))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e pre_((jc.getNthDayOfTheWeek)2001, 7, 5, \u003cSun\u003e)))))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e ((((jc.getNthDayOfTheWeek)(2001, 7, 5, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e pre_((jc.getNthDayOfTheWeek)2001, 7, 6, \u003cSun\u003e))))))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e ((((jc.getNthDayOfTheWeek)(2001, 7, 5, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e (((jc.getNthDayOfTheWeek)(2001, 7, 6, \u003cSun\u003e) \u003d false) \u003d\u003e pre_((jc.getNumberOfTheDayOfWeek)d0711, d0301, \u003cSun\u003e)))))))","type compatibility obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e ((((jc.getNthDayOfTheWeek)(2001, 7, 5, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e (((jc.getNthDayOfTheWeek)(2001, 7, 6, \u003cSun\u003e) \u003d false) \u003d\u003e is_(d0711, Date)))))))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e ((((jc.getNthDayOfTheWeek)(2001, 7, 5, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e (((jc.getNthDayOfTheWeek)(2001, 7, 6, \u003cSun\u003e) \u003d false) \u003d\u003e (((jc.getNumberOfTheDayOfWeek)(d0711, d0301, \u003cSun\u003e) \u003d 19) \u003d\u003e pre_((jc.getNumberOfTheDayOfWeek)d0711, d10010301, \u003cSun\u003e))))))))","type compatibility obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e ((((jc.getNthDayOfTheWeek)(2001, 7, 5, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e (((jc.getNthDayOfTheWeek)(2001, 7, 6, \u003cSun\u003e) \u003d false) \u003d\u003e (((jc.getNumberOfTheDayOfWeek)(d0711, d0301, \u003cSun\u003e) \u003d 19) \u003d\u003e is_(d0711, Date))))))))","type compatibility obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e ((((jc.getNthDayOfTheWeek)(2001, 7, 5, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e (((jc.getNthDayOfTheWeek)(2001, 7, 6, \u003cSun\u003e) \u003d false) \u003d\u003e (((jc.getNumberOfTheDayOfWeek)(d0711, d0301, \u003cSun\u003e) \u003d 19) \u003d\u003e is_(d10010301, Date))))))))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e ((((jc.getNthDayOfTheWeek)(2001, 7, 5, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e (((jc.getNthDayOfTheWeek)(2001, 7, 6, \u003cSun\u003e) \u003d false) \u003d\u003e (((jc.getNumberOfTheDayOfWeek)(d0711, d0301, \u003cSun\u003e) \u003d 19) \u003d\u003e (((jc.getNumberOfTheDayOfWeek)(d0711, d10010301, \u003cSun\u003e) \u003d 52196) \u003d\u003e pre_((jc.getNumberOfDayOfTheWeekFromName)\u003cThu\u003e)))))))))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e ((((jc.getNthDayOfTheWeek)(2001, 7, 5, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e (((jc.getNthDayOfTheWeek)(2001, 7, 6, \u003cSun\u003e) \u003d false) \u003d\u003e (((jc.getNumberOfTheDayOfWeek)(d0711, d0301, \u003cSun\u003e) \u003d 19) \u003d\u003e (((jc.getNumberOfTheDayOfWeek)(d0711, d10010301, \u003cSun\u003e) \u003d 52196) \u003d\u003e (((jc.getNumberOfDayOfTheWeekFromName)(\u003cThu\u003e) \u003d 4) \u003d\u003e pre_((jc.getNumberOfDayOfTheWeekFromName)\u003cFri\u003e))))))))))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e ((((jc.getNthDayOfTheWeek)(2001, 7, 5, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e (((jc.getNthDayOfTheWeek)(2001, 7, 6, \u003cSun\u003e) \u003d false) \u003d\u003e (((jc.getNumberOfTheDayOfWeek)(d0711, d0301, \u003cSun\u003e) \u003d 19) \u003d\u003e (((jc.getNumberOfTheDayOfWeek)(d0711, d10010301, \u003cSun\u003e) \u003d 52196) \u003d\u003e (((jc.getNumberOfDayOfTheWeekFromName)(\u003cThu\u003e) \u003d 4) \u003d\u003e (((jc.getNumberOfDayOfTheWeekFromName)(\u003cFri\u003e) \u003d 5) \u003d\u003e pre_((jc.getNumberOfDayOfTheWeekFromName)\u003cSat\u003e)))))))))))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e ((((jc.getNthDayOfTheWeek)(2001, 7, 5, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e (((jc.getNthDayOfTheWeek)(2001, 7, 6, \u003cSun\u003e) \u003d false) \u003d\u003e (((jc.getNumberOfTheDayOfWeek)(d0711, d0301, \u003cSun\u003e) \u003d 19) \u003d\u003e (((jc.getNumberOfTheDayOfWeek)(d0711, d10010301, \u003cSun\u003e) \u003d 52196) \u003d\u003e (((jc.getNumberOfDayOfTheWeekFromName)(\u003cThu\u003e) \u003d 4) \u003d\u003e (((jc.getNumberOfDayOfTheWeekFromName)(\u003cFri\u003e) \u003d 5) \u003d\u003e (((jc.getNumberOfDayOfTheWeekFromName)(\u003cSat\u003e) \u003d 6) \u003d\u003e pre_((jc.getNumberOfDayOfTheWeekFromName)\u003cSun\u003e))))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:(((jc.getDateFromString)(\"sahara\") \u003d false) \u003d\u003e (((jc.getDateFromString)(\"20011232\") \u003d false) \u003d\u003e pre_(((jc.getDateFromString)(\"20011231\").date2Str))))","type compatibility obligation:is_(RESULT, ())","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((jc.getLastDayOfMonth)2004, 1)","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e pre_((jc.getLastDayOfMonth)2004, 2))","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 2).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e pre_((jc.getLastDayOfMonth)2004, 3)))","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 2).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 3).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e pre_((jc.getLastDayOfMonth)2004, 4))))","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 2).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 3).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 4).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e pre_((jc.getLastDayOfMonth)2004, 5)))))","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 2).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 3).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 4).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 5).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e pre_((jc.getLastDayOfMonth)2004, 6))))))","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 2).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 3).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 4).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 5).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 6).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e pre_((jc.getLastDayOfMonth)2004, 7)))))))","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 2).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 3).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 4).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 5).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 6).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 7).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e pre_((jc.getLastDayOfMonth)2004, 8))))))))","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 2).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 3).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 4).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 5).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 6).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 7).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 8).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 8, 31)) \u003d\u003e pre_((jc.getLastDayOfMonth)2004, 9)))))))))","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 2).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 3).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 4).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 5).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 6).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 7).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 8).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 8, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 9).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e pre_((jc.getLastDayOfMonth)2004, 10))))))))))","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 2).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 3).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 4).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 5).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 6).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 7).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 8).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 8, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 9).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 10).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 10, 31)) \u003d\u003e pre_((jc.getLastDayOfMonth)2004, 11)))))))))))","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 2).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 3).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 4).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 5).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 6).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 7).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 8).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 8, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 9).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 10).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 10, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 11).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 11, 30)) \u003d\u003e pre_((jc.getLastDayOfMonth)2004, 12))))))))))))","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 2).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 3).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 4).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 5).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 6).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 7).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 8).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 8, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 9).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 10).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 10, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 11).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 11, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 12).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 12, 31)) \u003d\u003e pre_((jc.getLastDayOfMonth)2003, 13)))))))))))))","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 2).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 3).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 4).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 5).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 6).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 7).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 8).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 8, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 9).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 10).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 10, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 11).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 11, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 12).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 12, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 13).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e pre_((jc.getLastDayOfMonth)2003, (8 + 6)))))))))))))))","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 2).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 3).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 4).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 5).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 6).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 7).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 8).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 8, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 9).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 10).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 10, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 11).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 11, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 12).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 12, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 13).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, (8 + 6)).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e pre_((jc.getLastDayOfMonth)2003, 15)))))))))))))))","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 2).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 3).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 4).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 5).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 6).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 7).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 8).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 8, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 9).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 10).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 10, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 11).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 11, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 12).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 12, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 13).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, (8 + 6)).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 15).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e pre_((jc.getLastDayOfMonth)2003, 16))))))))))))))))","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 2).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 3).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 4).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 5).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 6).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 7).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 8).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 8, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 9).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 10).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 10, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 11).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 11, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 12).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 12, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 13).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, (8 + 6)).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 15).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 16).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e pre_((jc.getLastDayOfMonth)2003, 17)))))))))))))))))","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 2).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 3).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 4).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 5).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 6).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 7).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 8).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 8, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 9).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 10).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 10, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 11).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 11, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 12).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 12, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 13).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, (8 + 6)).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 15).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 16).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 17).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e pre_((jc.getLastDayOfMonth)2003, 18))))))))))))))))))","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 2).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 3).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 4).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 5).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 6).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 7).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 8).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 8, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 9).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 10).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 10, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 11).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 11, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 12).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 12, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 13).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, (8 + 6)).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 15).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 16).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 17).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 18).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e pre_((jc.getLastDayOfMonth)2003, 19)))))))))))))))))))","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 2).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 3).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 4).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 5).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 6).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 7).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 8).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 8, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 9).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 10).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 10, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 11).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 11, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 12).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 12, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 13).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, (8 + 6)).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 15).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 16).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 17).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 18).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 19).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e pre_((jc.getLastDayOfMonth)2003, 20))))))))))))))))))))","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 2).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 3).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 4).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 5).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 6).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 7).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 8).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 8, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 9).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 10).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 10, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 11).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 11, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 12).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 12, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 13).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, (8 + 6)).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 15).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 16).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 17).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 18).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 19).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 20).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 8, 31)) \u003d\u003e pre_((jc.getLastDayOfMonth)2003, 21)))))))))))))))))))))","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 2).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 3).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 4).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 5).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 6).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 7).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 8).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 8, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 9).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 10).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 10, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 11).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 11, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 12).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 12, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 13).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, (8 + 6)).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 15).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 16).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 17).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 18).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 19).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 20).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 8, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 21).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e pre_((jc.getLastDayOfMonth)2003, 22))))))))))))))))))))))","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 2).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 3).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 4).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 5).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 6).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 7).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 8).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 8, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 9).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 10).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 10, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 11).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 11, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 12).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 12, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 13).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, (8 + 6)).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 15).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 16).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 17).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 18).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 19).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 20).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 8, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 21).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 22).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 10, 31)) \u003d\u003e pre_((jc.getLastDayOfMonth)2003, 23)))))))))))))))))))))))","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 2).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 3).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 4).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 5).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 6).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 7).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 8).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 8, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 9).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 10).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 10, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 11).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 11, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 12).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 12, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 13).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, (8 + 6)).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 15).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 16).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 17).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 18).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 19).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 20).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 8, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 21).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 22).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 10, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 23).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 11, 30)) \u003d\u003e pre_((jc.getLastDayOfMonth)2003, 24))))))))))))))))))))))))","legal function application obligation:(((jc.getLastDayOfMonth)(2004, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 2).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 3).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 4).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 5).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 6).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 7).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 8).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 8, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 9).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 10).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 10, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 11).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 11, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2004, 12).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 12, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 13).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, (8 + 6)).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 15).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 3, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 16).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 17).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 5, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 18).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 6, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 19).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 7, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 20).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 8, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 21).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 22).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 10, 31)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 23).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 11, 30)) \u003d\u003e (((jc.getLastDayOfMonth)(2003, 24).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 12, 31)) \u003d\u003e pre_((jc.getLastDayOfMonth)2005, 2)))))))))))))))))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((jc.getRegularDate)2004, 1, 1)","legal function application obligation:(((jc.getRegularDate)(2004, 1, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e pre_((jc.getRegularDate)2003, 12, 32))","legal function application obligation:(((jc.getRegularDate)(2004, 1, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 12, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e pre_((jc.getRegularDate)2003, 24, 32)))","legal function application obligation:(((jc.getRegularDate)(2004, 1, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 12, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 24, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2005, 1, 1)) \u003d\u003e pre_((jc.getRegularDate)2003, 13, 1))))","legal function application obligation:(((jc.getRegularDate)(2004, 1, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 12, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 24, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2005, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 13, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e pre_((jc.getRegularDate)2004, 1, 32)))))","legal function application obligation:(((jc.getRegularDate)(2004, 1, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 12, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 24, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2005, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 13, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 1, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 1)) \u003d\u003e pre_((jc.getRegularDate)2004, 2, 0))))))","legal function application obligation:(((jc.getRegularDate)(2004, 1, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 12, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 24, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2005, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 13, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 1, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 0).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e pre_((jc.getRegularDate)2004, 2, 28)))))))","legal function application obligation:(((jc.getRegularDate)(2004, 1, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 12, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 24, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2005, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 13, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 1, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 0).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 28).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 28)) \u003d\u003e pre_((jc.getRegularDate)2004, 2, 29))))))))","legal function application obligation:(((jc.getRegularDate)(2004, 1, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 12, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 24, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2005, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 13, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 1, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 0).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 28).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 28)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 29).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e pre_((jc.getRegularDate)2004, 3, 0)))))))))","legal function application obligation:(((jc.getRegularDate)(2004, 1, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 12, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 24, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2005, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 13, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 1, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 0).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 28).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 28)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 29).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getRegularDate)(2004, 3, 0).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e pre_((jc.getRegularDate)2004, 3, -1))))))))))","legal function application obligation:(((jc.getRegularDate)(2004, 1, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 12, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 24, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2005, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 13, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 1, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 0).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 28).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 28)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 29).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getRegularDate)(2004, 3, 0).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getRegularDate)(2004, 3, -1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 28)) \u003d\u003e pre_((jc.getRegularDate)2003, 2, 29)))))))))))","legal function application obligation:(((jc.getRegularDate)(2004, 1, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 12, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 24, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2005, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 13, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 1, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 0).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 28).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 28)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 29).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getRegularDate)(2004, 3, 0).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getRegularDate)(2004, 3, -1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 28)) \u003d\u003e (((jc.getRegularDate)(2003, 2, 29).EQ)((jc.getDateFrom_yyyy_mm_dd)(2003, 3, 1)) \u003d\u003e pre_((jc.getRegularDate)2004, 4, 1))))))))))))","legal function application obligation:(((jc.getRegularDate)(2004, 1, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 12, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 24, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2005, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 13, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 1, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 0).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 28).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 28)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 29).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getRegularDate)(2004, 3, 0).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getRegularDate)(2004, 3, -1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 28)) \u003d\u003e (((jc.getRegularDate)(2003, 2, 29).EQ)((jc.getDateFrom_yyyy_mm_dd)(2003, 3, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 4, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 1)) \u003d\u003e pre_((jc.getRegularDate)2004, 0, 1)))))))))))))","legal function application obligation:(((jc.getRegularDate)(2004, 1, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 12, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 24, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2005, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 13, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 1, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 0).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 28).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 28)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 29).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getRegularDate)(2004, 3, 0).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getRegularDate)(2004, 3, -1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 28)) \u003d\u003e (((jc.getRegularDate)(2003, 2, 29).EQ)((jc.getDateFrom_yyyy_mm_dd)(2003, 3, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 4, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 0, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2003, 12, 1)) \u003d\u003e pre_((jc.getRegularDate)2004, -1, 1))))))))))))))","legal function application obligation:(((jc.getRegularDate)(2004, 1, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 12, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 24, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2005, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 13, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 1, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 0).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 28).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 28)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 29).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getRegularDate)(2004, 3, 0).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getRegularDate)(2004, 3, -1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 28)) \u003d\u003e (((jc.getRegularDate)(2003, 2, 29).EQ)((jc.getDateFrom_yyyy_mm_dd)(2003, 3, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 4, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 0, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2003, 12, 1)) \u003d\u003e (((jc.getRegularDate)(2004, -1, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2003, 11, 1)) \u003d\u003e pre_((jc.getRegularDate)2004, -10, 29)))))))))))))))","legal function application obligation:(((jc.getRegularDate)(2004, 1, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 12, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 24, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2005, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 13, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 1, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 0).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 28).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 28)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 29).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getRegularDate)(2004, 3, 0).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getRegularDate)(2004, 3, -1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 28)) \u003d\u003e (((jc.getRegularDate)(2003, 2, 29).EQ)((jc.getDateFrom_yyyy_mm_dd)(2003, 3, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 4, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 0, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2003, 12, 1)) \u003d\u003e (((jc.getRegularDate)(2004, -1, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2003, 11, 1)) \u003d\u003e (((jc.getRegularDate)(2004, -10, 29).EQ)((jc.getDateFrom_yyyy_mm_dd)(2003, 3, 1)) \u003d\u003e pre_((jc.getRegularDate)2004, -10, 28))))))))))))))))","legal function application obligation:(((jc.getRegularDate)(2004, 1, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 12, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 24, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2005, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 13, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 1, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 0).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 28).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 28)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 29).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getRegularDate)(2004, 3, 0).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getRegularDate)(2004, 3, -1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 28)) \u003d\u003e (((jc.getRegularDate)(2003, 2, 29).EQ)((jc.getDateFrom_yyyy_mm_dd)(2003, 3, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 4, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 0, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2003, 12, 1)) \u003d\u003e (((jc.getRegularDate)(2004, -1, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2003, 11, 1)) \u003d\u003e (((jc.getRegularDate)(2004, -10, 29).EQ)((jc.getDateFrom_yyyy_mm_dd)(2003, 3, 1)) \u003d\u003e (((jc.getRegularDate)(2004, -10, 28).EQ)((jc.getDateFrom_yyyy_mm_dd)(2003, 2, 28)) \u003d\u003e pre_((jc.getRegularDate)2004, -11, 1)))))))))))))))))","legal function application obligation:(((jc.getRegularDate)(2004, 1, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 12, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 24, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2005, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2003, 13, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 1, 32).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 0).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 1, 31)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 28).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 28)) \u003d\u003e (((jc.getRegularDate)(2004, 2, 29).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getRegularDate)(2004, 3, 0).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 29)) \u003d\u003e (((jc.getRegularDate)(2004, 3, -1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 2, 28)) \u003d\u003e (((jc.getRegularDate)(2003, 2, 29).EQ)((jc.getDateFrom_yyyy_mm_dd)(2003, 3, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 4, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2004, 4, 1)) \u003d\u003e (((jc.getRegularDate)(2004, 0, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2003, 12, 1)) \u003d\u003e (((jc.getRegularDate)(2004, -1, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2003, 11, 1)) \u003d\u003e (((jc.getRegularDate)(2004, -10, 29).EQ)((jc.getDateFrom_yyyy_mm_dd)(2003, 3, 1)) \u003d\u003e (((jc.getRegularDate)(2004, -10, 28).EQ)((jc.getDateFrom_yyyy_mm_dd)(2003, 2, 28)) \u003d\u003e (((jc.getRegularDate)(2004, -11, 1).EQ)((jc.getDateFrom_yyyy_mm_dd)(2003, 1, 1)) \u003d\u003e pre_((jc.getRegularDate)2004, -12, 1))))))))))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((jc.getRegularMonth)2004, 1)","legal function application obligation:(((jc.getRegularMonth)(2004, 1) \u003d mk_(2004, 1)) \u003d\u003e pre_((jc.getRegularMonth)2004, 2))","legal function application obligation:(((jc.getRegularMonth)(2004, 1) \u003d mk_(2004, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 2) \u003d mk_(2004, 2)) \u003d\u003e pre_((jc.getRegularMonth)2004, 3)))","legal function application obligation:(((jc.getRegularMonth)(2004, 1) \u003d mk_(2004, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 2) \u003d mk_(2004, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 3) \u003d mk_(2004, 3)) \u003d\u003e pre_((jc.getRegularMonth)2004, 4))))","legal function application obligation:(((jc.getRegularMonth)(2004, 1) \u003d mk_(2004, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 2) \u003d mk_(2004, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 3) \u003d mk_(2004, 3)) \u003d\u003e (((jc.getRegularMonth)(2004, 4) \u003d mk_(2004, 4)) \u003d\u003e pre_((jc.getRegularMonth)2004, 5)))))","legal function application obligation:(((jc.getRegularMonth)(2004, 1) \u003d mk_(2004, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 2) \u003d mk_(2004, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 3) \u003d mk_(2004, 3)) \u003d\u003e (((jc.getRegularMonth)(2004, 4) \u003d mk_(2004, 4)) \u003d\u003e (((jc.getRegularMonth)(2004, 5) \u003d mk_(2004, 5)) \u003d\u003e pre_((jc.getRegularMonth)2004, 6))))))","legal function application obligation:(((jc.getRegularMonth)(2004, 1) \u003d mk_(2004, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 2) \u003d mk_(2004, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 3) \u003d mk_(2004, 3)) \u003d\u003e (((jc.getRegularMonth)(2004, 4) \u003d mk_(2004, 4)) \u003d\u003e (((jc.getRegularMonth)(2004, 5) \u003d mk_(2004, 5)) \u003d\u003e (((jc.getRegularMonth)(2004, 6) \u003d mk_(2004, 6)) \u003d\u003e pre_((jc.getRegularMonth)2004, 7)))))))","legal function application obligation:(((jc.getRegularMonth)(2004, 1) \u003d mk_(2004, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 2) \u003d mk_(2004, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 3) \u003d mk_(2004, 3)) \u003d\u003e (((jc.getRegularMonth)(2004, 4) \u003d mk_(2004, 4)) \u003d\u003e (((jc.getRegularMonth)(2004, 5) \u003d mk_(2004, 5)) \u003d\u003e (((jc.getRegularMonth)(2004, 6) \u003d mk_(2004, 6)) \u003d\u003e (((jc.getRegularMonth)(2004, 7) \u003d mk_(2004, 7)) \u003d\u003e pre_((jc.getRegularMonth)2004, 8))))))))","legal function application obligation:(((jc.getRegularMonth)(2004, 1) \u003d mk_(2004, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 2) \u003d mk_(2004, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 3) \u003d mk_(2004, 3)) \u003d\u003e (((jc.getRegularMonth)(2004, 4) \u003d mk_(2004, 4)) \u003d\u003e (((jc.getRegularMonth)(2004, 5) \u003d mk_(2004, 5)) \u003d\u003e (((jc.getRegularMonth)(2004, 6) \u003d mk_(2004, 6)) \u003d\u003e (((jc.getRegularMonth)(2004, 7) \u003d mk_(2004, 7)) \u003d\u003e (((jc.getRegularMonth)(2004, 8) \u003d mk_(2004, 8)) \u003d\u003e pre_((jc.getRegularMonth)2004, 9)))))))))","legal function application obligation:(((jc.getRegularMonth)(2004, 1) \u003d mk_(2004, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 2) \u003d mk_(2004, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 3) \u003d mk_(2004, 3)) \u003d\u003e (((jc.getRegularMonth)(2004, 4) \u003d mk_(2004, 4)) \u003d\u003e (((jc.getRegularMonth)(2004, 5) \u003d mk_(2004, 5)) \u003d\u003e (((jc.getRegularMonth)(2004, 6) \u003d mk_(2004, 6)) \u003d\u003e (((jc.getRegularMonth)(2004, 7) \u003d mk_(2004, 7)) \u003d\u003e (((jc.getRegularMonth)(2004, 8) \u003d mk_(2004, 8)) \u003d\u003e (((jc.getRegularMonth)(2004, 9) \u003d mk_(2004, 9)) \u003d\u003e pre_((jc.getRegularMonth)2004, 10))))))))))","legal function application obligation:(((jc.getRegularMonth)(2004, 1) \u003d mk_(2004, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 2) \u003d mk_(2004, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 3) \u003d mk_(2004, 3)) \u003d\u003e (((jc.getRegularMonth)(2004, 4) \u003d mk_(2004, 4)) \u003d\u003e (((jc.getRegularMonth)(2004, 5) \u003d mk_(2004, 5)) \u003d\u003e (((jc.getRegularMonth)(2004, 6) \u003d mk_(2004, 6)) \u003d\u003e (((jc.getRegularMonth)(2004, 7) \u003d mk_(2004, 7)) \u003d\u003e (((jc.getRegularMonth)(2004, 8) \u003d mk_(2004, 8)) \u003d\u003e (((jc.getRegularMonth)(2004, 9) \u003d mk_(2004, 9)) \u003d\u003e (((jc.getRegularMonth)(2004, 10) \u003d mk_(2004, 10)) \u003d\u003e pre_((jc.getRegularMonth)2004, 11)))))))))))","legal function application obligation:(((jc.getRegularMonth)(2004, 1) \u003d mk_(2004, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 2) \u003d mk_(2004, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 3) \u003d mk_(2004, 3)) \u003d\u003e (((jc.getRegularMonth)(2004, 4) \u003d mk_(2004, 4)) \u003d\u003e (((jc.getRegularMonth)(2004, 5) \u003d mk_(2004, 5)) \u003d\u003e (((jc.getRegularMonth)(2004, 6) \u003d mk_(2004, 6)) \u003d\u003e (((jc.getRegularMonth)(2004, 7) \u003d mk_(2004, 7)) \u003d\u003e (((jc.getRegularMonth)(2004, 8) \u003d mk_(2004, 8)) \u003d\u003e (((jc.getRegularMonth)(2004, 9) \u003d mk_(2004, 9)) \u003d\u003e (((jc.getRegularMonth)(2004, 10) \u003d mk_(2004, 10)) \u003d\u003e (((jc.getRegularMonth)(2004, 11) \u003d mk_(2004, 11)) \u003d\u003e pre_((jc.getRegularMonth)2004, 12))))))))))))","legal function application obligation:(((jc.getRegularMonth)(2004, 1) \u003d mk_(2004, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 2) \u003d mk_(2004, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 3) \u003d mk_(2004, 3)) \u003d\u003e (((jc.getRegularMonth)(2004, 4) \u003d mk_(2004, 4)) \u003d\u003e (((jc.getRegularMonth)(2004, 5) \u003d mk_(2004, 5)) \u003d\u003e (((jc.getRegularMonth)(2004, 6) \u003d mk_(2004, 6)) \u003d\u003e (((jc.getRegularMonth)(2004, 7) \u003d mk_(2004, 7)) \u003d\u003e (((jc.getRegularMonth)(2004, 8) \u003d mk_(2004, 8)) \u003d\u003e (((jc.getRegularMonth)(2004, 9) \u003d mk_(2004, 9)) \u003d\u003e (((jc.getRegularMonth)(2004, 10) \u003d mk_(2004, 10)) \u003d\u003e (((jc.getRegularMonth)(2004, 11) \u003d mk_(2004, 11)) \u003d\u003e (((jc.getRegularMonth)(2004, 12) \u003d mk_(2004, 12)) \u003d\u003e pre_((jc.getRegularMonth)2004, 13)))))))))))))","legal function application obligation:(((jc.getRegularMonth)(2004, 1) \u003d mk_(2004, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 2) \u003d mk_(2004, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 3) \u003d mk_(2004, 3)) \u003d\u003e (((jc.getRegularMonth)(2004, 4) \u003d mk_(2004, 4)) \u003d\u003e (((jc.getRegularMonth)(2004, 5) \u003d mk_(2004, 5)) \u003d\u003e (((jc.getRegularMonth)(2004, 6) \u003d mk_(2004, 6)) \u003d\u003e (((jc.getRegularMonth)(2004, 7) \u003d mk_(2004, 7)) \u003d\u003e (((jc.getRegularMonth)(2004, 8) \u003d mk_(2004, 8)) \u003d\u003e (((jc.getRegularMonth)(2004, 9) \u003d mk_(2004, 9)) \u003d\u003e (((jc.getRegularMonth)(2004, 10) \u003d mk_(2004, 10)) \u003d\u003e (((jc.getRegularMonth)(2004, 11) \u003d mk_(2004, 11)) \u003d\u003e (((jc.getRegularMonth)(2004, 12) \u003d mk_(2004, 12)) \u003d\u003e (((jc.getRegularMonth)(2004, 13) \u003d mk_(2005, 1)) \u003d\u003e pre_((jc.getRegularMonth)2004, 14))))))))))))))","legal function application obligation:(((jc.getRegularMonth)(2004, 1) \u003d mk_(2004, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 2) \u003d mk_(2004, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 3) \u003d mk_(2004, 3)) \u003d\u003e (((jc.getRegularMonth)(2004, 4) \u003d mk_(2004, 4)) \u003d\u003e (((jc.getRegularMonth)(2004, 5) \u003d mk_(2004, 5)) \u003d\u003e (((jc.getRegularMonth)(2004, 6) \u003d mk_(2004, 6)) \u003d\u003e (((jc.getRegularMonth)(2004, 7) \u003d mk_(2004, 7)) \u003d\u003e (((jc.getRegularMonth)(2004, 8) \u003d mk_(2004, 8)) \u003d\u003e (((jc.getRegularMonth)(2004, 9) \u003d mk_(2004, 9)) \u003d\u003e (((jc.getRegularMonth)(2004, 10) \u003d mk_(2004, 10)) \u003d\u003e (((jc.getRegularMonth)(2004, 11) \u003d mk_(2004, 11)) \u003d\u003e (((jc.getRegularMonth)(2004, 12) \u003d mk_(2004, 12)) \u003d\u003e (((jc.getRegularMonth)(2004, 13) \u003d mk_(2005, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 14) \u003d mk_(2005, 2)) \u003d\u003e pre_((jc.getRegularMonth)2004, 24)))))))))))))))","legal function application obligation:(((jc.getRegularMonth)(2004, 1) \u003d mk_(2004, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 2) \u003d mk_(2004, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 3) \u003d mk_(2004, 3)) \u003d\u003e (((jc.getRegularMonth)(2004, 4) \u003d mk_(2004, 4)) \u003d\u003e (((jc.getRegularMonth)(2004, 5) \u003d mk_(2004, 5)) \u003d\u003e (((jc.getRegularMonth)(2004, 6) \u003d mk_(2004, 6)) \u003d\u003e (((jc.getRegularMonth)(2004, 7) \u003d mk_(2004, 7)) \u003d\u003e (((jc.getRegularMonth)(2004, 8) \u003d mk_(2004, 8)) \u003d\u003e (((jc.getRegularMonth)(2004, 9) \u003d mk_(2004, 9)) \u003d\u003e (((jc.getRegularMonth)(2004, 10) \u003d mk_(2004, 10)) \u003d\u003e (((jc.getRegularMonth)(2004, 11) \u003d mk_(2004, 11)) \u003d\u003e (((jc.getRegularMonth)(2004, 12) \u003d mk_(2004, 12)) \u003d\u003e (((jc.getRegularMonth)(2004, 13) \u003d mk_(2005, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 14) \u003d mk_(2005, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 24) \u003d mk_(2005, 12)) \u003d\u003e pre_((jc.getRegularMonth)2004, 25))))))))))))))))","legal function application obligation:(((jc.getRegularMonth)(2004, 1) \u003d mk_(2004, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 2) \u003d mk_(2004, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 3) \u003d mk_(2004, 3)) \u003d\u003e (((jc.getRegularMonth)(2004, 4) \u003d mk_(2004, 4)) \u003d\u003e (((jc.getRegularMonth)(2004, 5) \u003d mk_(2004, 5)) \u003d\u003e (((jc.getRegularMonth)(2004, 6) \u003d mk_(2004, 6)) \u003d\u003e (((jc.getRegularMonth)(2004, 7) \u003d mk_(2004, 7)) \u003d\u003e (((jc.getRegularMonth)(2004, 8) \u003d mk_(2004, 8)) \u003d\u003e (((jc.getRegularMonth)(2004, 9) \u003d mk_(2004, 9)) \u003d\u003e (((jc.getRegularMonth)(2004, 10) \u003d mk_(2004, 10)) \u003d\u003e (((jc.getRegularMonth)(2004, 11) \u003d mk_(2004, 11)) \u003d\u003e (((jc.getRegularMonth)(2004, 12) \u003d mk_(2004, 12)) \u003d\u003e (((jc.getRegularMonth)(2004, 13) \u003d mk_(2005, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 14) \u003d mk_(2005, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 24) \u003d mk_(2005, 12)) \u003d\u003e (((jc.getRegularMonth)(2004, 25) \u003d mk_(2006, 1)) \u003d\u003e pre_((jc.getRegularMonth)2004, 0)))))))))))))))))","legal function application obligation:(((jc.getRegularMonth)(2004, 1) \u003d mk_(2004, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 2) \u003d mk_(2004, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 3) \u003d mk_(2004, 3)) \u003d\u003e (((jc.getRegularMonth)(2004, 4) \u003d mk_(2004, 4)) \u003d\u003e (((jc.getRegularMonth)(2004, 5) \u003d mk_(2004, 5)) \u003d\u003e (((jc.getRegularMonth)(2004, 6) \u003d mk_(2004, 6)) \u003d\u003e (((jc.getRegularMonth)(2004, 7) \u003d mk_(2004, 7)) \u003d\u003e (((jc.getRegularMonth)(2004, 8) \u003d mk_(2004, 8)) \u003d\u003e (((jc.getRegularMonth)(2004, 9) \u003d mk_(2004, 9)) \u003d\u003e (((jc.getRegularMonth)(2004, 10) \u003d mk_(2004, 10)) \u003d\u003e (((jc.getRegularMonth)(2004, 11) \u003d mk_(2004, 11)) \u003d\u003e (((jc.getRegularMonth)(2004, 12) \u003d mk_(2004, 12)) \u003d\u003e (((jc.getRegularMonth)(2004, 13) \u003d mk_(2005, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 14) \u003d mk_(2005, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 24) \u003d mk_(2005, 12)) \u003d\u003e (((jc.getRegularMonth)(2004, 25) \u003d mk_(2006, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 0) \u003d mk_(2003, 12)) \u003d\u003e pre_((jc.getRegularMonth)2004, -1))))))))))))))))))","legal function application obligation:(((jc.getRegularMonth)(2004, 1) \u003d mk_(2004, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 2) \u003d mk_(2004, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 3) \u003d mk_(2004, 3)) \u003d\u003e (((jc.getRegularMonth)(2004, 4) \u003d mk_(2004, 4)) \u003d\u003e (((jc.getRegularMonth)(2004, 5) \u003d mk_(2004, 5)) \u003d\u003e (((jc.getRegularMonth)(2004, 6) \u003d mk_(2004, 6)) \u003d\u003e (((jc.getRegularMonth)(2004, 7) \u003d mk_(2004, 7)) \u003d\u003e (((jc.getRegularMonth)(2004, 8) \u003d mk_(2004, 8)) \u003d\u003e (((jc.getRegularMonth)(2004, 9) \u003d mk_(2004, 9)) \u003d\u003e (((jc.getRegularMonth)(2004, 10) \u003d mk_(2004, 10)) \u003d\u003e (((jc.getRegularMonth)(2004, 11) \u003d mk_(2004, 11)) \u003d\u003e (((jc.getRegularMonth)(2004, 12) \u003d mk_(2004, 12)) \u003d\u003e (((jc.getRegularMonth)(2004, 13) \u003d mk_(2005, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 14) \u003d mk_(2005, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 24) \u003d mk_(2005, 12)) \u003d\u003e (((jc.getRegularMonth)(2004, 25) \u003d mk_(2006, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 0) \u003d mk_(2003, 12)) \u003d\u003e (((jc.getRegularMonth)(2004, -1) \u003d mk_(2003, 11)) \u003d\u003e pre_((jc.getRegularMonth)2004, -10)))))))))))))))))))","legal function application obligation:(((jc.getRegularMonth)(2004, 1) \u003d mk_(2004, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 2) \u003d mk_(2004, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 3) \u003d mk_(2004, 3)) \u003d\u003e (((jc.getRegularMonth)(2004, 4) \u003d mk_(2004, 4)) \u003d\u003e (((jc.getRegularMonth)(2004, 5) \u003d mk_(2004, 5)) \u003d\u003e (((jc.getRegularMonth)(2004, 6) \u003d mk_(2004, 6)) \u003d\u003e (((jc.getRegularMonth)(2004, 7) \u003d mk_(2004, 7)) \u003d\u003e (((jc.getRegularMonth)(2004, 8) \u003d mk_(2004, 8)) \u003d\u003e (((jc.getRegularMonth)(2004, 9) \u003d mk_(2004, 9)) \u003d\u003e (((jc.getRegularMonth)(2004, 10) \u003d mk_(2004, 10)) \u003d\u003e (((jc.getRegularMonth)(2004, 11) \u003d mk_(2004, 11)) \u003d\u003e (((jc.getRegularMonth)(2004, 12) \u003d mk_(2004, 12)) \u003d\u003e (((jc.getRegularMonth)(2004, 13) \u003d mk_(2005, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 14) \u003d mk_(2005, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 24) \u003d mk_(2005, 12)) \u003d\u003e (((jc.getRegularMonth)(2004, 25) \u003d mk_(2006, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 0) \u003d mk_(2003, 12)) \u003d\u003e (((jc.getRegularMonth)(2004, -1) \u003d mk_(2003, 11)) \u003d\u003e (((jc.getRegularMonth)(2004, -10) \u003d mk_(2003, 2)) \u003d\u003e pre_((jc.getRegularMonth)2004, -11))))))))))))))))))))","legal function application obligation:(((jc.getRegularMonth)(2004, 1) \u003d mk_(2004, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 2) \u003d mk_(2004, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 3) \u003d mk_(2004, 3)) \u003d\u003e (((jc.getRegularMonth)(2004, 4) \u003d mk_(2004, 4)) \u003d\u003e (((jc.getRegularMonth)(2004, 5) \u003d mk_(2004, 5)) \u003d\u003e (((jc.getRegularMonth)(2004, 6) \u003d mk_(2004, 6)) \u003d\u003e (((jc.getRegularMonth)(2004, 7) \u003d mk_(2004, 7)) \u003d\u003e (((jc.getRegularMonth)(2004, 8) \u003d mk_(2004, 8)) \u003d\u003e (((jc.getRegularMonth)(2004, 9) \u003d mk_(2004, 9)) \u003d\u003e (((jc.getRegularMonth)(2004, 10) \u003d mk_(2004, 10)) \u003d\u003e (((jc.getRegularMonth)(2004, 11) \u003d mk_(2004, 11)) \u003d\u003e (((jc.getRegularMonth)(2004, 12) \u003d mk_(2004, 12)) \u003d\u003e (((jc.getRegularMonth)(2004, 13) \u003d mk_(2005, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 14) \u003d mk_(2005, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 24) \u003d mk_(2005, 12)) \u003d\u003e (((jc.getRegularMonth)(2004, 25) \u003d mk_(2006, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 0) \u003d mk_(2003, 12)) \u003d\u003e (((jc.getRegularMonth)(2004, -1) \u003d mk_(2003, 11)) \u003d\u003e (((jc.getRegularMonth)(2004, -10) \u003d mk_(2003, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, -11) \u003d mk_(2003, 1)) \u003d\u003e pre_((jc.getRegularMonth)2004, -12)))))))))))))))))))))","legal function application obligation:(((jc.getRegularMonth)(2004, 1) \u003d mk_(2004, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 2) \u003d mk_(2004, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 3) \u003d mk_(2004, 3)) \u003d\u003e (((jc.getRegularMonth)(2004, 4) \u003d mk_(2004, 4)) \u003d\u003e (((jc.getRegularMonth)(2004, 5) \u003d mk_(2004, 5)) \u003d\u003e (((jc.getRegularMonth)(2004, 6) \u003d mk_(2004, 6)) \u003d\u003e (((jc.getRegularMonth)(2004, 7) \u003d mk_(2004, 7)) \u003d\u003e (((jc.getRegularMonth)(2004, 8) \u003d mk_(2004, 8)) \u003d\u003e (((jc.getRegularMonth)(2004, 9) \u003d mk_(2004, 9)) \u003d\u003e (((jc.getRegularMonth)(2004, 10) \u003d mk_(2004, 10)) \u003d\u003e (((jc.getRegularMonth)(2004, 11) \u003d mk_(2004, 11)) \u003d\u003e (((jc.getRegularMonth)(2004, 12) \u003d mk_(2004, 12)) \u003d\u003e (((jc.getRegularMonth)(2004, 13) \u003d mk_(2005, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 14) \u003d mk_(2005, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, 24) \u003d mk_(2005, 12)) \u003d\u003e (((jc.getRegularMonth)(2004, 25) \u003d mk_(2006, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, 0) \u003d mk_(2003, 12)) \u003d\u003e (((jc.getRegularMonth)(2004, -1) \u003d mk_(2003, 11)) \u003d\u003e (((jc.getRegularMonth)(2004, -10) \u003d mk_(2003, 2)) \u003d\u003e (((jc.getRegularMonth)(2004, -11) \u003d mk_(2003, 1)) \u003d\u003e (((jc.getRegularMonth)(2004, -12) \u003d mk_(2002, 12)) \u003d\u003e pre_((jc.getRegularMonth)2004, -13))))))))))))))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:(forall aContractMonth:seq of (char) \u0026 (isCorrectContractMonth(aContractMonth) \u003d\u003e pre_((firstDayOfContractMonth.Year))))","legal function application obligation:(forall aContractMonth:seq of (char) \u0026 (isCorrectContractMonth(aContractMonth) \u003d\u003e pre_((firstDayOfContractMonth.Month))))","legal function application obligation:(forall aContractMonth:seq of (char) \u0026 (isCorrectContractMonth(aContractMonth) \u003d\u003e let firstDayOfContractMonth:(Date | bool) \u003d (calendar.getDateFromString)((aContractMonth ^ \"01\")), designatedYear:int \u003d (firstDayOfContractMonth.Year)(), designatedMonth:int \u003d (firstDayOfContractMonth.Month)() in pre_(((calendar.getNthDayOfTheWeek)(designatedYear, designatedMonth, 2, \u003cFri\u003e).getPastWeekday))))","legal function application obligation:(forall aContractMonth:seq of (char) \u0026 (isCorrectContractMonth(aContractMonth) \u003d\u003e let firstDayOfContractMonth:(Date | bool) \u003d (calendar.getDateFromString)((aContractMonth ^ \"01\")), designatedYear:int \u003d (firstDayOfContractMonth.Year)(), designatedMonth:int \u003d (firstDayOfContractMonth.Month)() in pre_((calendar.getNthDayOfTheWeek)designatedYear, designatedMonth, 2, \u003cFri\u003e)))","function establishes postcondition obligation:(forall aDate:Date \u0026 post_getContractDate(aDate, let mk_(year, month):(int * int) \u003d (calendar.getMonthOf6monthsLater)((aDate.Year)(), (aDate.Month)()), date:int \u003d (aDate.day)(), candidateDate:Date \u003d getCandidateDate(year, month, date) in (candidateDate.getPastWeekday)()))","legal function application obligation:(forall aDate:Date \u0026 let RESULT \u003d let mk_(year, month):(int * int) \u003d (calendar.getMonthOf6monthsLater)((aDate.Year)(), (aDate.Month)()), date:int \u003d (aDate.day)(), candidateDate:Date \u003d getCandidateDate(year, month, date) in (candidateDate.getPastWeekday)() in pre_((calendar.getMonthOf6monthsLater)(aDate.Year)(), (aDate.Month)()))","legal function application obligation:(forall aDate:Date \u0026 let RESULT \u003d let mk_(year, month):(int * int) \u003d (calendar.getMonthOf6monthsLater)((aDate.Year)(), (aDate.Month)()), date:int \u003d (aDate.day)(), candidateDate:Date \u003d getCandidateDate(year, month, date) in (candidateDate.getPastWeekday)() in pre_((aDate.Year)))","legal function application obligation:(forall aDate:Date \u0026 let RESULT \u003d let mk_(year, month):(int * int) \u003d (calendar.getMonthOf6monthsLater)((aDate.Year)(), (aDate.Month)()), date:int \u003d (aDate.day)(), candidateDate:Date \u003d getCandidateDate(year, month, date) in (candidateDate.getPastWeekday)() in pre_((aDate.Month)))","legal function application obligation:(forall aDate:Date \u0026 let RESULT \u003d let mk_(year, month):(int * int) \u003d (calendar.getMonthOf6monthsLater)((aDate.Year)(), (aDate.Month)()), date:int \u003d (aDate.day)(), candidateDate:Date \u003d getCandidateDate(year, month, date) in (candidateDate.getPastWeekday)() in pre_((aDate.day)))","legal function application obligation:(forall aDate:Date \u0026 let RESULT \u003d let mk_(year, month):(int * int) \u003d (calendar.getMonthOf6monthsLater)((aDate.Year)(), (aDate.Month)()), date:int \u003d (aDate.day)(), candidateDate:Date \u003d getCandidateDate(year, month, date) in (candidateDate.getPastWeekday)() in let mk_(year, month):(int * int) \u003d (calendar.getMonthOf6monthsLater)((aDate.Year)(), (aDate.Month)()), date:int \u003d (aDate.day)(), candidateDate:Date \u003d getCandidateDate(year, month, date) in pre_((candidateDate.getPastWeekday)))","legal function application obligation:(forall aDate:Date \u0026 let RESULT \u003d let mk_(year, month):(int * int) \u003d (calendar.getMonthOf6monthsLater)((aDate.Year)(), (aDate.Month)()), date:int \u003d (aDate.day)(), candidateDate:Date \u003d getCandidateDate(year, month, date) in (candidateDate.getPastWeekday)() in let mk_(year, month):(int * int) \u003d (calendar.getMonthOf6monthsLater)((aDate.Year)(), (aDate.Month)()), date:int \u003d (aDate.day)(), candidateDate:Date \u003d getCandidateDate(year, month, date) in ((RESULT.EQ)((candidateDate.getPastWeekday)()) \u003d\u003e (isDayoffFromTheBeginingOfMonthToCandidateDate(candidateDate) \u003d\u003e pre_((RESULT.Month)))))","legal function application obligation:(forall aDate:Date \u0026 let RESULT \u003d let mk_(year, month):(int * int) \u003d (calendar.getMonthOf6monthsLater)((aDate.Year)(), (aDate.Month)()), date:int \u003d (aDate.day)(), candidateDate:Date \u003d getCandidateDate(year, month, date) in (candidateDate.getPastWeekday)() in let mk_(year, month):(int * int) \u003d (calendar.getMonthOf6monthsLater)((aDate.Year)(), (aDate.Month)()), date:int \u003d (aDate.day)(), candidateDate:Date \u003d getCandidateDate(year, month, date) in ((RESULT.EQ)((candidateDate.getPastWeekday)()) \u003d\u003e ((not isDayoffFromTheBeginingOfMonthToCandidateDate(candidateDate)) \u003d\u003e pre_((RESULT.Month)))))","legal function application obligation:(forall aDate:Date \u0026 pre_((calendar.getMonthOf6monthsLater)(aDate.Year)(), (aDate.Month)()))","legal function application obligation:(forall aDate:Date \u0026 pre_((aDate.Year)))","legal function application obligation:(forall aDate:Date \u0026 pre_((aDate.Month)))","legal function application obligation:(forall aDate:Date \u0026 pre_((aDate.day)))","legal function application obligation:(forall aDate:Date \u0026 let mk_(year, month):(int * int) \u003d (calendar.getMonthOf6monthsLater)((aDate.Year)(), (aDate.Month)()), date:int \u003d (aDate.day)(), candidateDate:Date \u003d getCandidateDate(year, month, date) in pre_((candidateDate.getPastWeekday)))","legal function application obligation:(forall year:int, month:int \u0026 pre_((calendar.getRegularMonth)year, (month + 6)))","legal function application obligation:(forall year:int, month:int, date:int \u0026 pre_((calendar.getLastDayOfMonth)year, month))","legal function application obligation:(forall year:int, month:int, date:int \u0026 let dateOfEndOfMonth:Date \u003d (calendar.getLastDayOfMonth)(year, month) in pre_((dateOfEndOfMonth.day)))","legal function application obligation:(forall candidateDate:Date \u0026 pre_((candidateDate.day)))","legal function application obligation:(forall candidateDate:Date \u0026 (forall day in set {1, ... ,(candidateDate.day)()} \u0026 pre_((calendar.isSundayOrDayoff)(calendar.getDateFrom_yyyy_mm_dd)((candidateDate.Year)(), (candidateDate.Month)(), day))))","legal function application obligation:(forall candidateDate:Date \u0026 (forall day in set {1, ... ,(candidateDate.day)()} \u0026 pre_((candidateDate.Year))))","legal function application obligation:(forall candidateDate:Date \u0026 (forall day in set {1, ... ,(candidateDate.day)()} \u0026 pre_((candidateDate.Month))))","legal function application obligation:(forall year:int, month:int \u0026 pre_((calendar.getRegularMonth)year, (month - 1)))","map compatible obligation:(forall year:int \u0026 ((year \u003e\u003d 2000) \u003d\u003e (forall ldom1 in set (dom Year2Holidays), rdom2 in set (dom {year |-\u003e ((japaneseDayoffSet union TR1のsetOfDayOff) union saturdaySet)}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (Year2Holidays(ldom1) \u003d {year |-\u003e ((japaneseDayoffSet union TR1のsetOfDayOff) union saturdaySet)}(rdom2))))))","legal function application obligation:(forall fname:seq of (char) \u0026 pre_(((io.freadval))[(int * int * int)]fname))","type compatibility obligation:is_(RESULT, Date)","type compatibility obligation:(forall fname:seq of (char) \u0026 is_(RESULT, Date))","legal map application obligation:(forall companyCode:seq of (char) \u0026 (forall iTodayOnBusiness4:[Date], iTodayOnCompanyMap5:[map (seq of (char)) to (Date)], timeOfSystem6:[Time] \u0026 (true \u003d\u003e (companyCode in set (dom iTodayOnCompanyMap5)))))","legal function application obligation:pre_(((io.freadval))[Time](homedir ^ \"/temp/SystemTime.txt\"))","type compatibility obligation:(forall iTodayOnBusiness1:[Date], iTodayOnCompanyMap2:[map (seq of (char)) to (Date)], timeOfSystem3:[Time] \u0026 (true \u003d\u003e is_(RESULT, Time)))","legal function application obligation:(forall cal:Calendar, year:int, month:int, 日:int, 時:nat, aMinute:nat, aSecond:nat, milliSecond:nat \u0026 pre_((self.IntProduct2TimeMillieSeconds)時, aMinute, aSecond, milliSecond))","type compatibility obligation:(forall cal:Calendar, year:int, month:int, 日:int, 時:nat, aMinute:nat, aSecond:nat, milliSecond:nat \u0026 is_((self.IntProduct2TimeMillieSeconds)(時, aMinute, aSecond, milliSecond), nat))","legal function application obligation:(forall cal:Calendar, year:int, month:int, 日:int \u0026 pre_((self.IntProduct2TimeMillieSeconds)0, 0, 0, 0))","type compatibility obligation:(forall cal:Calendar, year:int, month:int, 日:int \u0026 is_((self.IntProduct2TimeMillieSeconds)(0, 0, 0, 0), nat))","legal function application obligation:(forall aDate:Date \u0026 pre_((self.IntProduct2TimeMillieSeconds)0, 0, 0, 0))","type compatibility obligation:(forall aDate:Date \u0026 is_((self.IntProduct2TimeMillieSeconds)(0, 0, 0, 0), nat))","legal function application obligation:(forall dateFileName:seq of (char), 時間fname:seq of (char), cal:Calendar \u0026 pre_(((io.freadval))[(int * int * int * int)]時間fname))","legal function application obligation:(forall dateFileName:seq of (char), 時間fname:seq of (char), cal:Calendar \u0026 pre_((d.Year)))","legal function application obligation:(forall dateFileName:seq of (char), 時間fname:seq of (char), cal:Calendar \u0026 pre_((d.Month)))","legal function application obligation:(forall dateFileName:seq of (char), 時間fname:seq of (char), cal:Calendar \u0026 pre_((d.day)))","legal function application obligation:pre_((self.Time2IntProduct)(self.getTime)())","legal function application obligation:(forall aTime:nat \u0026 pre_((self.Time2IntProduct)(self.getTime)()))","legal function application obligation:pre_((self.Time2IntProduct)(self.getTime)())","legal function application obligation:(forall minute:nat \u0026 pre_((self.Time2IntProduct)(self.getTime)()))","legal function application obligation:pre_((self.Time2IntProduct)(self.getTime)())","legal function application obligation:(forall aSecond:nat \u0026 pre_((self.Time2IntProduct)(self.getTime)()))","legal function application obligation:pre_((self.Time2IntProduct)(self.getTime)())","legal function application obligation:(forall aMilliSecond:nat \u0026 pre_((self.Time2IntProduct)(self.getTime)()))","legal function application obligation:pre_((((self.getDate)().calendar)().Year)(self.getDate)())","legal function application obligation:pre_((((self.getDate)().calendar)().Month)(self.getDate)())","legal function application obligation:pre_((((self.getDate)().calendar)().day)(self.getDate)())","legal function application obligation:(forall aTime:Time \u0026 let date1:int \u003d (floor ((self.getDate)().getModifiedJulianDate)()), date2:int \u003d (floor ((aTime.getDate)().getModifiedJulianDate)()) in ((not ((date1 \u003c date2) \u003d true)) \u003d\u003e (((date1 \u003d date2) \u003d true) \u003d\u003e pre_((self.getTimeAsNat)))))","legal function application obligation:(forall aTime:Time \u0026 let date1:int \u003d (floor ((self.getDate)().getModifiedJulianDate)()), date2:int \u003d (floor ((aTime.getDate)().getModifiedJulianDate)()) in ((not ((date1 \u003c date2) \u003d true)) \u003d\u003e (((date1 \u003d date2) \u003d true) \u003d\u003e pre_((aTime.getTimeAsNat)))))","legal function application obligation:(forall aTime:Time \u0026 pre_((self.LT)aTime))","legal function application obligation:(forall aTime:Time \u0026 ((not (self.LT)(aTime)) \u003d\u003e pre_((self.EQ)aTime)))","legal function application obligation:(forall aTime:Time \u0026 pre_((self.GT)aTime))","legal function application obligation:(forall aTime:Time \u0026 pre_((self.LT)aTime))","legal function application obligation:(forall aTime:Time \u0026 (((self.getDate)().EQ)((aTime.getDate)()) \u003d\u003e pre_((self.getTimeAsNat))))","legal function application obligation:(forall aTime:Time \u0026 (((self.getDate)().EQ)((aTime.getDate)()) \u003d\u003e pre_((aTime.getTimeAsNat))))","legal function application obligation:(forall aTime:Time \u0026 pre_((self.EQ)aTime))","non-zero obligation:(forall aTime:TimeInMilliSeconds \u0026 (ミリ \u003c\u003e 0))","non-zero obligation:(forall aTime:TimeInMilliSeconds \u0026 (secondsPerMinute \u003c\u003e 0))","non-zero obligation:(forall aTime:TimeInMilliSeconds \u0026 (minutesPerHour \u003c\u003e 0))","type compatibility obligation:(forall aTime:TimeInMilliSeconds \u0026 is_(let hms:int \u003d (aTime div ミリ), milliSecond:int \u003d (aTime mod ミリ), hm:int \u003d (hms div secondsPerMinute), aSecond:int \u003d (hms mod secondsPerMinute), hour:int \u003d (hm div minutesPerHour), aMinute:int \u003d (hm mod minutesPerHour) in mk_(hour, aMinute, aSecond, milliSecond), (nat * nat * nat * nat)))","legal function application obligation:pre_((self.Time2IntProduct)(self.getTime)())","legal function application obligation:pre_(Integer`asStringZ(\"009\")milliSecond)","legal function application obligation:pre_((self.Time2IntProduct)(self.getTime)())","legal function application obligation:pre_(Integer`asStringZ(\"009\")milliSecond)","non-zero obligation:(forall aMilliSecond:int \u0026 ((time \u003e\u003d 0) \u003d\u003e (milliSecondsPerDay \u003c\u003e 0)))","non-zero obligation:(forall aMilliSecond:int \u0026 ((not (time \u003e\u003d 0)) \u003d\u003e (milliSecondsPerDay \u003c\u003e 0)))","legal function application obligation:(forall aMilliSecond:int \u0026 pre_((self.calendar)))","legal function application obligation:(forall aMilliSecond:int \u0026 pre_((self.Year)))","legal function application obligation:(forall aMilliSecond:int \u0026 pre_((self.Month)))","legal function application obligation:(forall aMilliSecond:int \u0026 pre_((self.day)))","legal function application obligation:(((c.todayOnBusiness)().EQ)((c.getDateFrom_yyyy_mm_dd)(2001, 9, 12)) \u003d\u003e pre_((c.isDateNil)nil))","legal function application obligation:(((c.todayOnBusiness)().EQ)((c.getDateFrom_yyyy_mm_dd)(2001, 9, 12)) \u003d\u003e (((c.isDateNil)(nil) \u003d true) \u003d\u003e pre_((c.isDateNil)(c.todayOnBusiness)())))","legal function application obligation:(((c.todayOnBusiness)().EQ)((c.getDateFrom_yyyy_mm_dd)(2001, 9, 12)) \u003d\u003e (((c.isDateNil)(nil) \u003d true) \u003d\u003e (((c.isDateNil)((c.todayOnBusiness)()) \u003d false) \u003d\u003e pre_((c.systemDate)))))","legal function application obligation:(((c.todayOnBusiness)().EQ)((c.getDateFrom_yyyy_mm_dd)(2001, 9, 12)) \u003d\u003e (((c.isDateNil)(nil) \u003d true) \u003d\u003e (((c.isDateNil)((c.todayOnBusiness)()) \u003d false) \u003d\u003e (((c.systemDate)().EQ)((c.today)()) \u003d\u003e pre_(((c.systemTime)().EQ)new Time(c, 2003, 10, 23, 13, 12, 34, 567))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:(forall dayOff in set setOfDayOff \u0026 pre_((jc.getYyyymmdd)dayOff))","legal function application obligation:(forall dayOff in set setOfDayOff2006 \u0026 pre_((jc.getYyyymmdd)dayOff))","legal function application obligation:((setOfDayOffBy_yyyy_mm_dd \u003d {mk_(2001, 1, 1), mk_(2001, 1, 2), mk_(2001, 1, 3), mk_(2001, 1, 6), mk_(2001, 1, 8), mk_(2001, 1, 13), mk_(2001, 1, 20), mk_(2001, 1, 27), mk_(2001, 2, 3), mk_(2001, 2, 10), mk_(2001, 2, 11), mk_(2001, 2, 12), mk_(2001, 2, 17), mk_(2001, 2, 24), mk_(2001, 3, 3), mk_(2001, 3, 10), mk_(2001, 3, 17), mk_(2001, 3, 20), mk_(2001, 3, 24), mk_(2001, 3, 31), mk_(2001, 4, 7), mk_(2001, 4, 14), mk_(2001, 4, 21), mk_(2001, 4, 28), mk_(2001, 4, 29), mk_(2001, 4, 30), mk_(2001, 5, 3), mk_(2001, 5, 4), mk_(2001, 5, 5), mk_(2001, 5, 12), mk_(2001, 5, 19), mk_(2001, 5, 26), mk_(2001, 6, 2), mk_(2001, 6, 9), mk_(2001, 6, 16), mk_(2001, 6, 23), mk_(2001, 6, 30), mk_(2001, 7, 7), mk_(2001, 7, 14), mk_(2001, 7, 20), mk_(2001, 7, 21), mk_(2001, 7, 28), mk_(2001, 8, 4), mk_(2001, 8, 11), mk_(2001, 8, 18), mk_(2001, 8, 25), mk_(2001, 9, 1), mk_(2001, 9, 8), mk_(2001, 9, 15), mk_(2001, 9, 22), mk_(2001, 9, 23), mk_(2001, 9, 24), mk_(2001, 9, 29), mk_(2001, 10, 6), mk_(2001, 10, 8), mk_(2001, 10, 13), mk_(2001, 10, 20), mk_(2001, 10, 27), mk_(2001, 11, 3), mk_(2001, 11, 10), mk_(2001, 11, 17), mk_(2001, 11, 23), mk_(2001, 11, 24), mk_(2001, 12, 1), mk_(2001, 12, 8), mk_(2001, 12, 15), mk_(2001, 12, 22), mk_(2001, 12, 23), mk_(2001, 12, 24), mk_(2001, 12, 29), mk_(2001, 12, 30), mk_(2001, 12, 31)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_dd2006 \u003d {mk_(2006, 1, 1), mk_(2006, 1, 2), mk_(2006, 1, 3), mk_(2006, 1, 7), mk_(2006, 1, 9), mk_(2006, 1, 14), mk_(2006, 1, 21), mk_(2006, 1, 28), mk_(2006, 2, 4), mk_(2006, 2, 11), mk_(2006, 2, 18), mk_(2006, 2, 25), mk_(2006, 3, 4), mk_(2006, 3, 11), mk_(2006, 3, 18), mk_(2006, 3, 21), mk_(2006, 3, 25), mk_(2006, 4, 1), mk_(2006, 4, 8), mk_(2006, 4, 15), mk_(2006, 4, 22), mk_(2006, 4, 29), mk_(2006, 5, 3), mk_(2006, 5, 4), mk_(2006, 5, 5), mk_(2006, 5, 6), mk_(2006, 5, 13), mk_(2006, 5, 20), mk_(2006, 5, 27), mk_(2006, 6, 3), mk_(2006, 6, 10), mk_(2006, 6, 17), mk_(2006, 6, 24), mk_(2006, 7, 1), mk_(2006, 7, 8), mk_(2006, 7, 15), mk_(2006, 7, 17), mk_(2006, 7, 22), mk_(2006, 7, 29), mk_(2006, 8, 5), mk_(2006, 8, 12), mk_(2006, 8, 19), mk_(2006, 8, 26), mk_(2006, 9, 2), mk_(2006, 9, 9), mk_(2006, 9, 16), mk_(2006, 9, 18), mk_(2006, 9, 23), mk_(2006, 9, 30), mk_(2006, 10, 7), mk_(2006, 10, 9), mk_(2006, 10, 14), mk_(2006, 10, 21), mk_(2006, 10, 28), mk_(2006, 11, 3), mk_(2006, 11, 4), mk_(2006, 11, 11), mk_(2006, 11, 18), mk_(2006, 11, 23), mk_(2006, 11, 25), mk_(2006, 12, 2), mk_(2006, 12, 9), mk_(2006, 12, 16), mk_(2006, 12, 23), mk_(2006, 12, 29), mk_(2006, 12, 30), mk_(2006, 12, 31)}) \u003d\u003e pre_((jc.getDayOffsExceptSunday)d0401, d0430)))","type compatibility obligation:((setOfDayOffBy_yyyy_mm_dd \u003d {mk_(2001, 1, 1), mk_(2001, 1, 2), mk_(2001, 1, 3), mk_(2001, 1, 6), mk_(2001, 1, 8), mk_(2001, 1, 13), mk_(2001, 1, 20), mk_(2001, 1, 27), mk_(2001, 2, 3), mk_(2001, 2, 10), mk_(2001, 2, 11), mk_(2001, 2, 12), mk_(2001, 2, 17), mk_(2001, 2, 24), mk_(2001, 3, 3), mk_(2001, 3, 10), mk_(2001, 3, 17), mk_(2001, 3, 20), mk_(2001, 3, 24), mk_(2001, 3, 31), mk_(2001, 4, 7), mk_(2001, 4, 14), mk_(2001, 4, 21), mk_(2001, 4, 28), mk_(2001, 4, 29), mk_(2001, 4, 30), mk_(2001, 5, 3), mk_(2001, 5, 4), mk_(2001, 5, 5), mk_(2001, 5, 12), mk_(2001, 5, 19), mk_(2001, 5, 26), mk_(2001, 6, 2), mk_(2001, 6, 9), mk_(2001, 6, 16), mk_(2001, 6, 23), mk_(2001, 6, 30), mk_(2001, 7, 7), mk_(2001, 7, 14), mk_(2001, 7, 20), mk_(2001, 7, 21), mk_(2001, 7, 28), mk_(2001, 8, 4), mk_(2001, 8, 11), mk_(2001, 8, 18), mk_(2001, 8, 25), mk_(2001, 9, 1), mk_(2001, 9, 8), mk_(2001, 9, 15), mk_(2001, 9, 22), mk_(2001, 9, 23), mk_(2001, 9, 24), mk_(2001, 9, 29), mk_(2001, 10, 6), mk_(2001, 10, 8), mk_(2001, 10, 13), mk_(2001, 10, 20), mk_(2001, 10, 27), mk_(2001, 11, 3), mk_(2001, 11, 10), mk_(2001, 11, 17), mk_(2001, 11, 23), mk_(2001, 11, 24), mk_(2001, 12, 1), mk_(2001, 12, 8), mk_(2001, 12, 15), mk_(2001, 12, 22), mk_(2001, 12, 23), mk_(2001, 12, 24), mk_(2001, 12, 29), mk_(2001, 12, 30), mk_(2001, 12, 31)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_dd2006 \u003d {mk_(2006, 1, 1), mk_(2006, 1, 2), mk_(2006, 1, 3), mk_(2006, 1, 7), mk_(2006, 1, 9), mk_(2006, 1, 14), mk_(2006, 1, 21), mk_(2006, 1, 28), mk_(2006, 2, 4), mk_(2006, 2, 11), mk_(2006, 2, 18), mk_(2006, 2, 25), mk_(2006, 3, 4), mk_(2006, 3, 11), mk_(2006, 3, 18), mk_(2006, 3, 21), mk_(2006, 3, 25), mk_(2006, 4, 1), mk_(2006, 4, 8), mk_(2006, 4, 15), mk_(2006, 4, 22), mk_(2006, 4, 29), mk_(2006, 5, 3), mk_(2006, 5, 4), mk_(2006, 5, 5), mk_(2006, 5, 6), mk_(2006, 5, 13), mk_(2006, 5, 20), mk_(2006, 5, 27), mk_(2006, 6, 3), mk_(2006, 6, 10), mk_(2006, 6, 17), mk_(2006, 6, 24), mk_(2006, 7, 1), mk_(2006, 7, 8), mk_(2006, 7, 15), mk_(2006, 7, 17), mk_(2006, 7, 22), mk_(2006, 7, 29), mk_(2006, 8, 5), mk_(2006, 8, 12), mk_(2006, 8, 19), mk_(2006, 8, 26), mk_(2006, 9, 2), mk_(2006, 9, 9), mk_(2006, 9, 16), mk_(2006, 9, 18), mk_(2006, 9, 23), mk_(2006, 9, 30), mk_(2006, 10, 7), mk_(2006, 10, 9), mk_(2006, 10, 14), mk_(2006, 10, 21), mk_(2006, 10, 28), mk_(2006, 11, 3), mk_(2006, 11, 4), mk_(2006, 11, 11), mk_(2006, 11, 18), mk_(2006, 11, 23), mk_(2006, 11, 25), mk_(2006, 12, 2), mk_(2006, 12, 9), mk_(2006, 12, 16), mk_(2006, 12, 23), mk_(2006, 12, 29), mk_(2006, 12, 30), mk_(2006, 12, 31)}) \u003d\u003e is_(d0401, Date)))","type compatibility obligation:((setOfDayOffBy_yyyy_mm_dd \u003d {mk_(2001, 1, 1), mk_(2001, 1, 2), mk_(2001, 1, 3), mk_(2001, 1, 6), mk_(2001, 1, 8), mk_(2001, 1, 13), mk_(2001, 1, 20), mk_(2001, 1, 27), mk_(2001, 2, 3), mk_(2001, 2, 10), mk_(2001, 2, 11), mk_(2001, 2, 12), mk_(2001, 2, 17), mk_(2001, 2, 24), mk_(2001, 3, 3), mk_(2001, 3, 10), mk_(2001, 3, 17), mk_(2001, 3, 20), mk_(2001, 3, 24), mk_(2001, 3, 31), mk_(2001, 4, 7), mk_(2001, 4, 14), mk_(2001, 4, 21), mk_(2001, 4, 28), mk_(2001, 4, 29), mk_(2001, 4, 30), mk_(2001, 5, 3), mk_(2001, 5, 4), mk_(2001, 5, 5), mk_(2001, 5, 12), mk_(2001, 5, 19), mk_(2001, 5, 26), mk_(2001, 6, 2), mk_(2001, 6, 9), mk_(2001, 6, 16), mk_(2001, 6, 23), mk_(2001, 6, 30), mk_(2001, 7, 7), mk_(2001, 7, 14), mk_(2001, 7, 20), mk_(2001, 7, 21), mk_(2001, 7, 28), mk_(2001, 8, 4), mk_(2001, 8, 11), mk_(2001, 8, 18), mk_(2001, 8, 25), mk_(2001, 9, 1), mk_(2001, 9, 8), mk_(2001, 9, 15), mk_(2001, 9, 22), mk_(2001, 9, 23), mk_(2001, 9, 24), mk_(2001, 9, 29), mk_(2001, 10, 6), mk_(2001, 10, 8), mk_(2001, 10, 13), mk_(2001, 10, 20), mk_(2001, 10, 27), mk_(2001, 11, 3), mk_(2001, 11, 10), mk_(2001, 11, 17), mk_(2001, 11, 23), mk_(2001, 11, 24), mk_(2001, 12, 1), mk_(2001, 12, 8), mk_(2001, 12, 15), mk_(2001, 12, 22), mk_(2001, 12, 23), mk_(2001, 12, 24), mk_(2001, 12, 29), mk_(2001, 12, 30), mk_(2001, 12, 31)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_dd2006 \u003d {mk_(2006, 1, 1), mk_(2006, 1, 2), mk_(2006, 1, 3), mk_(2006, 1, 7), mk_(2006, 1, 9), mk_(2006, 1, 14), mk_(2006, 1, 21), mk_(2006, 1, 28), mk_(2006, 2, 4), mk_(2006, 2, 11), mk_(2006, 2, 18), mk_(2006, 2, 25), mk_(2006, 3, 4), mk_(2006, 3, 11), mk_(2006, 3, 18), mk_(2006, 3, 21), mk_(2006, 3, 25), mk_(2006, 4, 1), mk_(2006, 4, 8), mk_(2006, 4, 15), mk_(2006, 4, 22), mk_(2006, 4, 29), mk_(2006, 5, 3), mk_(2006, 5, 4), mk_(2006, 5, 5), mk_(2006, 5, 6), mk_(2006, 5, 13), mk_(2006, 5, 20), mk_(2006, 5, 27), mk_(2006, 6, 3), mk_(2006, 6, 10), mk_(2006, 6, 17), mk_(2006, 6, 24), mk_(2006, 7, 1), mk_(2006, 7, 8), mk_(2006, 7, 15), mk_(2006, 7, 17), mk_(2006, 7, 22), mk_(2006, 7, 29), mk_(2006, 8, 5), mk_(2006, 8, 12), mk_(2006, 8, 19), mk_(2006, 8, 26), mk_(2006, 9, 2), mk_(2006, 9, 9), mk_(2006, 9, 16), mk_(2006, 9, 18), mk_(2006, 9, 23), mk_(2006, 9, 30), mk_(2006, 10, 7), mk_(2006, 10, 9), mk_(2006, 10, 14), mk_(2006, 10, 21), mk_(2006, 10, 28), mk_(2006, 11, 3), mk_(2006, 11, 4), mk_(2006, 11, 11), mk_(2006, 11, 18), mk_(2006, 11, 23), mk_(2006, 11, 25), mk_(2006, 12, 2), mk_(2006, 12, 9), mk_(2006, 12, 16), mk_(2006, 12, 23), mk_(2006, 12, 29), mk_(2006, 12, 30), mk_(2006, 12, 31)}) \u003d\u003e is_(d0430, Date)))","legal function application obligation:((setOfDayOffBy_yyyy_mm_dd \u003d {mk_(2001, 1, 1), mk_(2001, 1, 2), mk_(2001, 1, 3), mk_(2001, 1, 6), mk_(2001, 1, 8), mk_(2001, 1, 13), mk_(2001, 1, 20), mk_(2001, 1, 27), mk_(2001, 2, 3), mk_(2001, 2, 10), mk_(2001, 2, 11), mk_(2001, 2, 12), mk_(2001, 2, 17), mk_(2001, 2, 24), mk_(2001, 3, 3), mk_(2001, 3, 10), mk_(2001, 3, 17), mk_(2001, 3, 20), mk_(2001, 3, 24), mk_(2001, 3, 31), mk_(2001, 4, 7), mk_(2001, 4, 14), mk_(2001, 4, 21), mk_(2001, 4, 28), mk_(2001, 4, 29), mk_(2001, 4, 30), mk_(2001, 5, 3), mk_(2001, 5, 4), mk_(2001, 5, 5), mk_(2001, 5, 12), mk_(2001, 5, 19), mk_(2001, 5, 26), mk_(2001, 6, 2), mk_(2001, 6, 9), mk_(2001, 6, 16), mk_(2001, 6, 23), mk_(2001, 6, 30), mk_(2001, 7, 7), mk_(2001, 7, 14), mk_(2001, 7, 20), mk_(2001, 7, 21), mk_(2001, 7, 28), mk_(2001, 8, 4), mk_(2001, 8, 11), mk_(2001, 8, 18), mk_(2001, 8, 25), mk_(2001, 9, 1), mk_(2001, 9, 8), mk_(2001, 9, 15), mk_(2001, 9, 22), mk_(2001, 9, 23), mk_(2001, 9, 24), mk_(2001, 9, 29), mk_(2001, 10, 6), mk_(2001, 10, 8), mk_(2001, 10, 13), mk_(2001, 10, 20), mk_(2001, 10, 27), mk_(2001, 11, 3), mk_(2001, 11, 10), mk_(2001, 11, 17), mk_(2001, 11, 23), mk_(2001, 11, 24), mk_(2001, 12, 1), mk_(2001, 12, 8), mk_(2001, 12, 15), mk_(2001, 12, 22), mk_(2001, 12, 23), mk_(2001, 12, 24), mk_(2001, 12, 29), mk_(2001, 12, 30), mk_(2001, 12, 31)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_dd2006 \u003d {mk_(2006, 1, 1), mk_(2006, 1, 2), mk_(2006, 1, 3), mk_(2006, 1, 7), mk_(2006, 1, 9), mk_(2006, 1, 14), mk_(2006, 1, 21), mk_(2006, 1, 28), mk_(2006, 2, 4), mk_(2006, 2, 11), mk_(2006, 2, 18), mk_(2006, 2, 25), mk_(2006, 3, 4), mk_(2006, 3, 11), mk_(2006, 3, 18), mk_(2006, 3, 21), mk_(2006, 3, 25), mk_(2006, 4, 1), mk_(2006, 4, 8), mk_(2006, 4, 15), mk_(2006, 4, 22), mk_(2006, 4, 29), mk_(2006, 5, 3), mk_(2006, 5, 4), mk_(2006, 5, 5), mk_(2006, 5, 6), mk_(2006, 5, 13), mk_(2006, 5, 20), mk_(2006, 5, 27), mk_(2006, 6, 3), mk_(2006, 6, 10), mk_(2006, 6, 17), mk_(2006, 6, 24), mk_(2006, 7, 1), mk_(2006, 7, 8), mk_(2006, 7, 15), mk_(2006, 7, 17), mk_(2006, 7, 22), mk_(2006, 7, 29), mk_(2006, 8, 5), mk_(2006, 8, 12), mk_(2006, 8, 19), mk_(2006, 8, 26), mk_(2006, 9, 2), mk_(2006, 9, 9), mk_(2006, 9, 16), mk_(2006, 9, 18), mk_(2006, 9, 23), mk_(2006, 9, 30), mk_(2006, 10, 7), mk_(2006, 10, 9), mk_(2006, 10, 14), mk_(2006, 10, 21), mk_(2006, 10, 28), mk_(2006, 11, 3), mk_(2006, 11, 4), mk_(2006, 11, 11), mk_(2006, 11, 18), mk_(2006, 11, 23), mk_(2006, 11, 25), mk_(2006, 12, 2), mk_(2006, 12, 9), mk_(2006, 12, 16), mk_(2006, 12, 23), mk_(2006, 12, 29), mk_(2006, 12, 30), mk_(2006, 12, 31)}) \u003d\u003e (((jc.getDayOffsExceptSunday)(d0401, d0430) \u003d 6) \u003d\u003e pre_((jc.getDayOffsAndSunday)d0401, d0430))))","type compatibility obligation:((setOfDayOffBy_yyyy_mm_dd \u003d {mk_(2001, 1, 1), mk_(2001, 1, 2), mk_(2001, 1, 3), mk_(2001, 1, 6), mk_(2001, 1, 8), mk_(2001, 1, 13), mk_(2001, 1, 20), mk_(2001, 1, 27), mk_(2001, 2, 3), mk_(2001, 2, 10), mk_(2001, 2, 11), mk_(2001, 2, 12), mk_(2001, 2, 17), mk_(2001, 2, 24), mk_(2001, 3, 3), mk_(2001, 3, 10), mk_(2001, 3, 17), mk_(2001, 3, 20), mk_(2001, 3, 24), mk_(2001, 3, 31), mk_(2001, 4, 7), mk_(2001, 4, 14), mk_(2001, 4, 21), mk_(2001, 4, 28), mk_(2001, 4, 29), mk_(2001, 4, 30), mk_(2001, 5, 3), mk_(2001, 5, 4), mk_(2001, 5, 5), mk_(2001, 5, 12), mk_(2001, 5, 19), mk_(2001, 5, 26), mk_(2001, 6, 2), mk_(2001, 6, 9), mk_(2001, 6, 16), mk_(2001, 6, 23), mk_(2001, 6, 30), mk_(2001, 7, 7), mk_(2001, 7, 14), mk_(2001, 7, 20), mk_(2001, 7, 21), mk_(2001, 7, 28), mk_(2001, 8, 4), mk_(2001, 8, 11), mk_(2001, 8, 18), mk_(2001, 8, 25), mk_(2001, 9, 1), mk_(2001, 9, 8), mk_(2001, 9, 15), mk_(2001, 9, 22), mk_(2001, 9, 23), mk_(2001, 9, 24), mk_(2001, 9, 29), mk_(2001, 10, 6), mk_(2001, 10, 8), mk_(2001, 10, 13), mk_(2001, 10, 20), mk_(2001, 10, 27), mk_(2001, 11, 3), mk_(2001, 11, 10), mk_(2001, 11, 17), mk_(2001, 11, 23), mk_(2001, 11, 24), mk_(2001, 12, 1), mk_(2001, 12, 8), mk_(2001, 12, 15), mk_(2001, 12, 22), mk_(2001, 12, 23), mk_(2001, 12, 24), mk_(2001, 12, 29), mk_(2001, 12, 30), mk_(2001, 12, 31)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_dd2006 \u003d {mk_(2006, 1, 1), mk_(2006, 1, 2), mk_(2006, 1, 3), mk_(2006, 1, 7), mk_(2006, 1, 9), mk_(2006, 1, 14), mk_(2006, 1, 21), mk_(2006, 1, 28), mk_(2006, 2, 4), mk_(2006, 2, 11), mk_(2006, 2, 18), mk_(2006, 2, 25), mk_(2006, 3, 4), mk_(2006, 3, 11), mk_(2006, 3, 18), mk_(2006, 3, 21), mk_(2006, 3, 25), mk_(2006, 4, 1), mk_(2006, 4, 8), mk_(2006, 4, 15), mk_(2006, 4, 22), mk_(2006, 4, 29), mk_(2006, 5, 3), mk_(2006, 5, 4), mk_(2006, 5, 5), mk_(2006, 5, 6), mk_(2006, 5, 13), mk_(2006, 5, 20), mk_(2006, 5, 27), mk_(2006, 6, 3), mk_(2006, 6, 10), mk_(2006, 6, 17), mk_(2006, 6, 24), mk_(2006, 7, 1), mk_(2006, 7, 8), mk_(2006, 7, 15), mk_(2006, 7, 17), mk_(2006, 7, 22), mk_(2006, 7, 29), mk_(2006, 8, 5), mk_(2006, 8, 12), mk_(2006, 8, 19), mk_(2006, 8, 26), mk_(2006, 9, 2), mk_(2006, 9, 9), mk_(2006, 9, 16), mk_(2006, 9, 18), mk_(2006, 9, 23), mk_(2006, 9, 30), mk_(2006, 10, 7), mk_(2006, 10, 9), mk_(2006, 10, 14), mk_(2006, 10, 21), mk_(2006, 10, 28), mk_(2006, 11, 3), mk_(2006, 11, 4), mk_(2006, 11, 11), mk_(2006, 11, 18), mk_(2006, 11, 23), mk_(2006, 11, 25), mk_(2006, 12, 2), mk_(2006, 12, 9), mk_(2006, 12, 16), mk_(2006, 12, 23), mk_(2006, 12, 29), mk_(2006, 12, 30), mk_(2006, 12, 31)}) \u003d\u003e (((jc.getDayOffsExceptSunday)(d0401, d0430) \u003d 6) \u003d\u003e is_(d0401, Date))))","type compatibility obligation:((setOfDayOffBy_yyyy_mm_dd \u003d {mk_(2001, 1, 1), mk_(2001, 1, 2), mk_(2001, 1, 3), mk_(2001, 1, 6), mk_(2001, 1, 8), mk_(2001, 1, 13), mk_(2001, 1, 20), mk_(2001, 1, 27), mk_(2001, 2, 3), mk_(2001, 2, 10), mk_(2001, 2, 11), mk_(2001, 2, 12), mk_(2001, 2, 17), mk_(2001, 2, 24), mk_(2001, 3, 3), mk_(2001, 3, 10), mk_(2001, 3, 17), mk_(2001, 3, 20), mk_(2001, 3, 24), mk_(2001, 3, 31), mk_(2001, 4, 7), mk_(2001, 4, 14), mk_(2001, 4, 21), mk_(2001, 4, 28), mk_(2001, 4, 29), mk_(2001, 4, 30), mk_(2001, 5, 3), mk_(2001, 5, 4), mk_(2001, 5, 5), mk_(2001, 5, 12), mk_(2001, 5, 19), mk_(2001, 5, 26), mk_(2001, 6, 2), mk_(2001, 6, 9), mk_(2001, 6, 16), mk_(2001, 6, 23), mk_(2001, 6, 30), mk_(2001, 7, 7), mk_(2001, 7, 14), mk_(2001, 7, 20), mk_(2001, 7, 21), mk_(2001, 7, 28), mk_(2001, 8, 4), mk_(2001, 8, 11), mk_(2001, 8, 18), mk_(2001, 8, 25), mk_(2001, 9, 1), mk_(2001, 9, 8), mk_(2001, 9, 15), mk_(2001, 9, 22), mk_(2001, 9, 23), mk_(2001, 9, 24), mk_(2001, 9, 29), mk_(2001, 10, 6), mk_(2001, 10, 8), mk_(2001, 10, 13), mk_(2001, 10, 20), mk_(2001, 10, 27), mk_(2001, 11, 3), mk_(2001, 11, 10), mk_(2001, 11, 17), mk_(2001, 11, 23), mk_(2001, 11, 24), mk_(2001, 12, 1), mk_(2001, 12, 8), mk_(2001, 12, 15), mk_(2001, 12, 22), mk_(2001, 12, 23), mk_(2001, 12, 24), mk_(2001, 12, 29), mk_(2001, 12, 30), mk_(2001, 12, 31)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_dd2006 \u003d {mk_(2006, 1, 1), mk_(2006, 1, 2), mk_(2006, 1, 3), mk_(2006, 1, 7), mk_(2006, 1, 9), mk_(2006, 1, 14), mk_(2006, 1, 21), mk_(2006, 1, 28), mk_(2006, 2, 4), mk_(2006, 2, 11), mk_(2006, 2, 18), mk_(2006, 2, 25), mk_(2006, 3, 4), mk_(2006, 3, 11), mk_(2006, 3, 18), mk_(2006, 3, 21), mk_(2006, 3, 25), mk_(2006, 4, 1), mk_(2006, 4, 8), mk_(2006, 4, 15), mk_(2006, 4, 22), mk_(2006, 4, 29), mk_(2006, 5, 3), mk_(2006, 5, 4), mk_(2006, 5, 5), mk_(2006, 5, 6), mk_(2006, 5, 13), mk_(2006, 5, 20), mk_(2006, 5, 27), mk_(2006, 6, 3), mk_(2006, 6, 10), mk_(2006, 6, 17), mk_(2006, 6, 24), mk_(2006, 7, 1), mk_(2006, 7, 8), mk_(2006, 7, 15), mk_(2006, 7, 17), mk_(2006, 7, 22), mk_(2006, 7, 29), mk_(2006, 8, 5), mk_(2006, 8, 12), mk_(2006, 8, 19), mk_(2006, 8, 26), mk_(2006, 9, 2), mk_(2006, 9, 9), mk_(2006, 9, 16), mk_(2006, 9, 18), mk_(2006, 9, 23), mk_(2006, 9, 30), mk_(2006, 10, 7), mk_(2006, 10, 9), mk_(2006, 10, 14), mk_(2006, 10, 21), mk_(2006, 10, 28), mk_(2006, 11, 3), mk_(2006, 11, 4), mk_(2006, 11, 11), mk_(2006, 11, 18), mk_(2006, 11, 23), mk_(2006, 11, 25), mk_(2006, 12, 2), mk_(2006, 12, 9), mk_(2006, 12, 16), mk_(2006, 12, 23), mk_(2006, 12, 29), mk_(2006, 12, 30), mk_(2006, 12, 31)}) \u003d\u003e (((jc.getDayOffsExceptSunday)(d0401, d0430) \u003d 6) \u003d\u003e is_(d0430, Date))))","legal function application obligation:((setOfDayOffBy_yyyy_mm_dd \u003d {mk_(2001, 1, 1), mk_(2001, 1, 2), mk_(2001, 1, 3), mk_(2001, 1, 6), mk_(2001, 1, 8), mk_(2001, 1, 13), mk_(2001, 1, 20), mk_(2001, 1, 27), mk_(2001, 2, 3), mk_(2001, 2, 10), mk_(2001, 2, 11), mk_(2001, 2, 12), mk_(2001, 2, 17), mk_(2001, 2, 24), mk_(2001, 3, 3), mk_(2001, 3, 10), mk_(2001, 3, 17), mk_(2001, 3, 20), mk_(2001, 3, 24), mk_(2001, 3, 31), mk_(2001, 4, 7), mk_(2001, 4, 14), mk_(2001, 4, 21), mk_(2001, 4, 28), mk_(2001, 4, 29), mk_(2001, 4, 30), mk_(2001, 5, 3), mk_(2001, 5, 4), mk_(2001, 5, 5), mk_(2001, 5, 12), mk_(2001, 5, 19), mk_(2001, 5, 26), mk_(2001, 6, 2), mk_(2001, 6, 9), mk_(2001, 6, 16), mk_(2001, 6, 23), mk_(2001, 6, 30), mk_(2001, 7, 7), mk_(2001, 7, 14), mk_(2001, 7, 20), mk_(2001, 7, 21), mk_(2001, 7, 28), mk_(2001, 8, 4), mk_(2001, 8, 11), mk_(2001, 8, 18), mk_(2001, 8, 25), mk_(2001, 9, 1), mk_(2001, 9, 8), mk_(2001, 9, 15), mk_(2001, 9, 22), mk_(2001, 9, 23), mk_(2001, 9, 24), mk_(2001, 9, 29), mk_(2001, 10, 6), mk_(2001, 10, 8), mk_(2001, 10, 13), mk_(2001, 10, 20), mk_(2001, 10, 27), mk_(2001, 11, 3), mk_(2001, 11, 10), mk_(2001, 11, 17), mk_(2001, 11, 23), mk_(2001, 11, 24), mk_(2001, 12, 1), mk_(2001, 12, 8), mk_(2001, 12, 15), mk_(2001, 12, 22), mk_(2001, 12, 23), mk_(2001, 12, 24), mk_(2001, 12, 29), mk_(2001, 12, 30), mk_(2001, 12, 31)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_dd2006 \u003d {mk_(2006, 1, 1), mk_(2006, 1, 2), mk_(2006, 1, 3), mk_(2006, 1, 7), mk_(2006, 1, 9), mk_(2006, 1, 14), mk_(2006, 1, 21), mk_(2006, 1, 28), mk_(2006, 2, 4), mk_(2006, 2, 11), mk_(2006, 2, 18), mk_(2006, 2, 25), mk_(2006, 3, 4), mk_(2006, 3, 11), mk_(2006, 3, 18), mk_(2006, 3, 21), mk_(2006, 3, 25), mk_(2006, 4, 1), mk_(2006, 4, 8), mk_(2006, 4, 15), mk_(2006, 4, 22), mk_(2006, 4, 29), mk_(2006, 5, 3), mk_(2006, 5, 4), mk_(2006, 5, 5), mk_(2006, 5, 6), mk_(2006, 5, 13), mk_(2006, 5, 20), mk_(2006, 5, 27), mk_(2006, 6, 3), mk_(2006, 6, 10), mk_(2006, 6, 17), mk_(2006, 6, 24), mk_(2006, 7, 1), mk_(2006, 7, 8), mk_(2006, 7, 15), mk_(2006, 7, 17), mk_(2006, 7, 22), mk_(2006, 7, 29), mk_(2006, 8, 5), mk_(2006, 8, 12), mk_(2006, 8, 19), mk_(2006, 8, 26), mk_(2006, 9, 2), mk_(2006, 9, 9), mk_(2006, 9, 16), mk_(2006, 9, 18), mk_(2006, 9, 23), mk_(2006, 9, 30), mk_(2006, 10, 7), mk_(2006, 10, 9), mk_(2006, 10, 14), mk_(2006, 10, 21), mk_(2006, 10, 28), mk_(2006, 11, 3), mk_(2006, 11, 4), mk_(2006, 11, 11), mk_(2006, 11, 18), mk_(2006, 11, 23), mk_(2006, 11, 25), mk_(2006, 12, 2), mk_(2006, 12, 9), mk_(2006, 12, 16), mk_(2006, 12, 23), mk_(2006, 12, 29), mk_(2006, 12, 30), mk_(2006, 12, 31)}) \u003d\u003e (((jc.getDayOffsExceptSunday)(d0401, d0430) \u003d 6) \u003d\u003e (((card (jc.getDayOffsAndSunday)(d0401, d0430)) \u003d 1) \u003d\u003e pre_((jc.getDayOffsAndSunday)d0401, d0408)))))","type compatibility obligation:((setOfDayOffBy_yyyy_mm_dd \u003d {mk_(2001, 1, 1), mk_(2001, 1, 2), mk_(2001, 1, 3), mk_(2001, 1, 6), mk_(2001, 1, 8), mk_(2001, 1, 13), mk_(2001, 1, 20), mk_(2001, 1, 27), mk_(2001, 2, 3), mk_(2001, 2, 10), mk_(2001, 2, 11), mk_(2001, 2, 12), mk_(2001, 2, 17), mk_(2001, 2, 24), mk_(2001, 3, 3), mk_(2001, 3, 10), mk_(2001, 3, 17), mk_(2001, 3, 20), mk_(2001, 3, 24), mk_(2001, 3, 31), mk_(2001, 4, 7), mk_(2001, 4, 14), mk_(2001, 4, 21), mk_(2001, 4, 28), mk_(2001, 4, 29), mk_(2001, 4, 30), mk_(2001, 5, 3), mk_(2001, 5, 4), mk_(2001, 5, 5), mk_(2001, 5, 12), mk_(2001, 5, 19), mk_(2001, 5, 26), mk_(2001, 6, 2), mk_(2001, 6, 9), mk_(2001, 6, 16), mk_(2001, 6, 23), mk_(2001, 6, 30), mk_(2001, 7, 7), mk_(2001, 7, 14), mk_(2001, 7, 20), mk_(2001, 7, 21), mk_(2001, 7, 28), mk_(2001, 8, 4), mk_(2001, 8, 11), mk_(2001, 8, 18), mk_(2001, 8, 25), mk_(2001, 9, 1), mk_(2001, 9, 8), mk_(2001, 9, 15), mk_(2001, 9, 22), mk_(2001, 9, 23), mk_(2001, 9, 24), mk_(2001, 9, 29), mk_(2001, 10, 6), mk_(2001, 10, 8), mk_(2001, 10, 13), mk_(2001, 10, 20), mk_(2001, 10, 27), mk_(2001, 11, 3), mk_(2001, 11, 10), mk_(2001, 11, 17), mk_(2001, 11, 23), mk_(2001, 11, 24), mk_(2001, 12, 1), mk_(2001, 12, 8), mk_(2001, 12, 15), mk_(2001, 12, 22), mk_(2001, 12, 23), mk_(2001, 12, 24), mk_(2001, 12, 29), mk_(2001, 12, 30), mk_(2001, 12, 31)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_dd2006 \u003d {mk_(2006, 1, 1), mk_(2006, 1, 2), mk_(2006, 1, 3), mk_(2006, 1, 7), mk_(2006, 1, 9), mk_(2006, 1, 14), mk_(2006, 1, 21), mk_(2006, 1, 28), mk_(2006, 2, 4), mk_(2006, 2, 11), mk_(2006, 2, 18), mk_(2006, 2, 25), mk_(2006, 3, 4), mk_(2006, 3, 11), mk_(2006, 3, 18), mk_(2006, 3, 21), mk_(2006, 3, 25), mk_(2006, 4, 1), mk_(2006, 4, 8), mk_(2006, 4, 15), mk_(2006, 4, 22), mk_(2006, 4, 29), mk_(2006, 5, 3), mk_(2006, 5, 4), mk_(2006, 5, 5), mk_(2006, 5, 6), mk_(2006, 5, 13), mk_(2006, 5, 20), mk_(2006, 5, 27), mk_(2006, 6, 3), mk_(2006, 6, 10), mk_(2006, 6, 17), mk_(2006, 6, 24), mk_(2006, 7, 1), mk_(2006, 7, 8), mk_(2006, 7, 15), mk_(2006, 7, 17), mk_(2006, 7, 22), mk_(2006, 7, 29), mk_(2006, 8, 5), mk_(2006, 8, 12), mk_(2006, 8, 19), mk_(2006, 8, 26), mk_(2006, 9, 2), mk_(2006, 9, 9), mk_(2006, 9, 16), mk_(2006, 9, 18), mk_(2006, 9, 23), mk_(2006, 9, 30), mk_(2006, 10, 7), mk_(2006, 10, 9), mk_(2006, 10, 14), mk_(2006, 10, 21), mk_(2006, 10, 28), mk_(2006, 11, 3), mk_(2006, 11, 4), mk_(2006, 11, 11), mk_(2006, 11, 18), mk_(2006, 11, 23), mk_(2006, 11, 25), mk_(2006, 12, 2), mk_(2006, 12, 9), mk_(2006, 12, 16), mk_(2006, 12, 23), mk_(2006, 12, 29), mk_(2006, 12, 30), mk_(2006, 12, 31)}) \u003d\u003e (((jc.getDayOffsExceptSunday)(d0401, d0430) \u003d 6) \u003d\u003e (((card (jc.getDayOffsAndSunday)(d0401, d0430)) \u003d 1) \u003d\u003e is_(d0401, Date)))))","type compatibility obligation:((setOfDayOffBy_yyyy_mm_dd \u003d {mk_(2001, 1, 1), mk_(2001, 1, 2), mk_(2001, 1, 3), mk_(2001, 1, 6), mk_(2001, 1, 8), mk_(2001, 1, 13), mk_(2001, 1, 20), mk_(2001, 1, 27), mk_(2001, 2, 3), mk_(2001, 2, 10), mk_(2001, 2, 11), mk_(2001, 2, 12), mk_(2001, 2, 17), mk_(2001, 2, 24), mk_(2001, 3, 3), mk_(2001, 3, 10), mk_(2001, 3, 17), mk_(2001, 3, 20), mk_(2001, 3, 24), mk_(2001, 3, 31), mk_(2001, 4, 7), mk_(2001, 4, 14), mk_(2001, 4, 21), mk_(2001, 4, 28), mk_(2001, 4, 29), mk_(2001, 4, 30), mk_(2001, 5, 3), mk_(2001, 5, 4), mk_(2001, 5, 5), mk_(2001, 5, 12), mk_(2001, 5, 19), mk_(2001, 5, 26), mk_(2001, 6, 2), mk_(2001, 6, 9), mk_(2001, 6, 16), mk_(2001, 6, 23), mk_(2001, 6, 30), mk_(2001, 7, 7), mk_(2001, 7, 14), mk_(2001, 7, 20), mk_(2001, 7, 21), mk_(2001, 7, 28), mk_(2001, 8, 4), mk_(2001, 8, 11), mk_(2001, 8, 18), mk_(2001, 8, 25), mk_(2001, 9, 1), mk_(2001, 9, 8), mk_(2001, 9, 15), mk_(2001, 9, 22), mk_(2001, 9, 23), mk_(2001, 9, 24), mk_(2001, 9, 29), mk_(2001, 10, 6), mk_(2001, 10, 8), mk_(2001, 10, 13), mk_(2001, 10, 20), mk_(2001, 10, 27), mk_(2001, 11, 3), mk_(2001, 11, 10), mk_(2001, 11, 17), mk_(2001, 11, 23), mk_(2001, 11, 24), mk_(2001, 12, 1), mk_(2001, 12, 8), mk_(2001, 12, 15), mk_(2001, 12, 22), mk_(2001, 12, 23), mk_(2001, 12, 24), mk_(2001, 12, 29), mk_(2001, 12, 30), mk_(2001, 12, 31)}) \u003d\u003e ((setOfDayOffBy_yyyy_mm_dd2006 \u003d {mk_(2006, 1, 1), mk_(2006, 1, 2), mk_(2006, 1, 3), mk_(2006, 1, 7), mk_(2006, 1, 9), mk_(2006, 1, 14), mk_(2006, 1, 21), mk_(2006, 1, 28), mk_(2006, 2, 4), mk_(2006, 2, 11), mk_(2006, 2, 18), mk_(2006, 2, 25), mk_(2006, 3, 4), mk_(2006, 3, 11), mk_(2006, 3, 18), mk_(2006, 3, 21), mk_(2006, 3, 25), mk_(2006, 4, 1), mk_(2006, 4, 8), mk_(2006, 4, 15), mk_(2006, 4, 22), mk_(2006, 4, 29), mk_(2006, 5, 3), mk_(2006, 5, 4), mk_(2006, 5, 5), mk_(2006, 5, 6), mk_(2006, 5, 13), mk_(2006, 5, 20), mk_(2006, 5, 27), mk_(2006, 6, 3), mk_(2006, 6, 10), mk_(2006, 6, 17), mk_(2006, 6, 24), mk_(2006, 7, 1), mk_(2006, 7, 8), mk_(2006, 7, 15), mk_(2006, 7, 17), mk_(2006, 7, 22), mk_(2006, 7, 29), mk_(2006, 8, 5), mk_(2006, 8, 12), mk_(2006, 8, 19), mk_(2006, 8, 26), mk_(2006, 9, 2), mk_(2006, 9, 9), mk_(2006, 9, 16), mk_(2006, 9, 18), mk_(2006, 9, 23), mk_(2006, 9, 30), mk_(2006, 10, 7), mk_(2006, 10, 9), mk_(2006, 10, 14), mk_(2006, 10, 21), mk_(2006, 10, 28), mk_(2006, 11, 3), mk_(2006, 11, 4), mk_(2006, 11, 11), mk_(2006, 11, 18), mk_(2006, 11, 23), mk_(2006, 11, 25), mk_(2006, 12, 2), mk_(2006, 12, 9), mk_(2006, 12, 16), mk_(2006, 12, 23), mk_(2006, 12, 29), mk_(2006, 12, 30), mk_(2006, 12, 31)}) \u003d\u003e (((jc.getDayOffsExceptSunday)(d0401, d0430) \u003d 6) \u003d\u003e (((card (jc.getDayOffsAndSunday)(d0401, d0430)) \u003d 1) \u003d\u003e is_(d0408, Date)))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((c.getExerciseDate)\"200111\")","legal function application obligation:(((c.getExerciseDate)(\"200111\").EQ)((c.getDateFrom_yyyy_mm_dd)(2001, 11, 9)) \u003d\u003e pre_((c.getExerciseDate)\"200109\"))","legal function application obligation:(((c.getExerciseDate)(\"200111\").EQ)((c.getDateFrom_yyyy_mm_dd)(2001, 11, 9)) \u003d\u003e (((c.getExerciseDate)(\"200109\").EQ)((c.getDateFrom_yyyy_mm_dd)(2001, 9, 14)) \u003d\u003e pre_((c.isCorrectContractMonth)\"200206\")))","legal function application obligation:(((c.getExerciseDate)(\"200111\").EQ)((c.getDateFrom_yyyy_mm_dd)(2001, 11, 9)) \u003d\u003e (((c.getExerciseDate)(\"200109\").EQ)((c.getDateFrom_yyyy_mm_dd)(2001, 9, 14)) \u003d\u003e (((c.isCorrectContractMonth)(\"200206\") \u003d true) \u003d\u003e pre_((c.isCorrectContractMonth)\"200206.01\"))))","legal function application obligation:(((c.getExerciseDate)(\"200111\").EQ)((c.getDateFrom_yyyy_mm_dd)(2001, 11, 9)) \u003d\u003e (((c.getExerciseDate)(\"200109\").EQ)((c.getDateFrom_yyyy_mm_dd)(2001, 9, 14)) \u003d\u003e (((c.isCorrectContractMonth)(\"200206\") \u003d true) \u003d\u003e (((c.isCorrectContractMonth)(\"200206.01\") \u003d false) \u003d\u003e pre_((c.isCorrectContractMonth)\"Shin Sahara\")))))","type compatibility obligation:is_(RESULT, ())","type compatibility obligation:is_(RESULT, ())","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2004, 1, 5))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2004, 2, 1))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2004, 2, 27))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2004, 3, 30))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2004, 4, 1))))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 1)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)))))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 29)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2004, 5, 6))))))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 29)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 6)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2004, 5, 7)))))))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 29)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 6)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 7)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2004, 5, 10))))))))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 29)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 6)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 7)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 10)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 10)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2004, 6, 1)))))))))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 29)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 6)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 7)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 10)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 10)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 1)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2004, 6, 28))))))))))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 29)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 6)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 7)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 10)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 10)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2004, 6, 29)))))))))))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 29)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 6)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 7)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 10)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 10)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2004, 6, 30))))))))))))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 29)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 6)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 7)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 10)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 10)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2004, 7, 1)))))))))))))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 29)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 6)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 7)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 10)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 10)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2004, 7, 2))))))))))))))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 29)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 6)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 7)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 10)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 10)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)))))))))))))))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 29)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 6)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 7)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 10)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 10)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2005, 1, 5)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2004, 7, 30))))))))))))))))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 29)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 6)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 7)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 10)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 10)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2005, 1, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2005, 1, 28)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2003, 8, 2)))))))))))))))))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 29)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 6)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 7)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 10)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 10)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2005, 1, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2005, 1, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2003, 8, 28))))))))))))))))))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 29)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 6)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 7)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 10)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 10)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2005, 1, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2005, 1, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2003, 8, 29)))))))))))))))))))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 29)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 6)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 7)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 10)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 10)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2005, 1, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2005, 1, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2003, 9, 1))))))))))))))))))))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 29)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 6)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 7)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 10)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 10)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2005, 1, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2005, 1, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 9, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2003, 9, 30)))))))))))))))))))))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 29)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 6)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 7)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 10)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 10)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2005, 1, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2005, 1, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 9, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 9, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2003, 10, 1))))))))))))))))))))))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 29)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 6)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 7)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 10)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 10)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2005, 1, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2005, 1, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 9, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 9, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 10, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2003, 10, 29)))))))))))))))))))))))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 29)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 6)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 7)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 10)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 10)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2005, 1, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2005, 1, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 9, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 9, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 10, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 10, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 4, 28)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2003, 11, 1))))))))))))))))))))))))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 29)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 6)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 7)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 10)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 10)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2005, 1, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2005, 1, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 9, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 9, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 10, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 10, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 4, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 11, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2003, 11, 30)))))))))))))))))))))))))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 29)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 6)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 7)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 10)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 10)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2005, 1, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2005, 1, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 9, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 9, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 10, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 10, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 4, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 11, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 11, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 5, 28)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2003, 12, 1))))))))))))))))))))))))))))))))","legal function application obligation:((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 1, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 8, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 3, 31)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 9, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 10, 29)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 6)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 7)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 5, 10)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 11, 10)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 6, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 12, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 5)).EQ)((c.getDateFrom_yyyy_mm_dd)(2005, 1, 5)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2004, 7, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2005, 1, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 2)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 2)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 28)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 8, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 2, 27)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 9, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 3, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 9, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 3, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 10, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 4, 1)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 10, 29)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 4, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 11, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 4, 30)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 11, 30)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 5, 28)) \u003d\u003e ((sDate((c.getDateFrom_yyyy_mm_dd)(2003, 12, 1)).EQ)((c.getDateFrom_yyyy_mm_dd)(2004, 6, 1)) \u003d\u003e pre_(sDate(c.getDateFrom_yyyy_mm_dd)(2003, 12, 26)))))))))))))))))))))))))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:(forall f:(@e * @e -\u003e bool), n1:@e, n2:@e \u0026 pre_(fn1, n2))","legal function application obligation:(forall f:(@e * @e -\u003e bool), n1:@e, n2:@e \u0026 pre_(fn1, n2))","recursive function obligation:(forall i:int, numberOfDigit:nat \u0026 let q:int \u003d (i div 10) in ((not (0 \u003d q)) \u003d\u003e (idiv10(i, numberOfDigit) \u003e idiv10(q, (numberOfDigit + 1)))))","type compatibility obligation:(forall i:int, -:nat \u0026 ((i div 10) \u003e\u003d 0))","non-zero obligation:(forall r:real, numberOfDigit:nat \u0026 ((r \u003e\u003d 0) \u003d\u003e let multiple:nat1 \u003d (10 ** numberOfDigit) in (multiple \u003c\u003e 0)))","legal function application obligation:(forall f:(real -\u003e real), x:real \u0026 pre_(f(x + Variation)))","legal function application obligation:(forall f:(real -\u003e real), x:real \u0026 pre_(fx))","non-zero obligation:(forall f:(real -\u003e real), x:real \u0026 (Variation \u003c\u003e 0))","legal function application obligation:(forall f:(real -\u003e real), x:real \u0026 (forall y:real \u0026 pre_(fy)))","legal function application obligation:(forall f:(real -\u003e real), x:real \u0026 (forall y:real \u0026 pre_(fy)))","legal function application obligation:(forall f:(real -\u003e real), x:real \u0026 (forall y:real \u0026 pre_(Differentiate(f)y)))","non-zero obligation:(forall f:(real -\u003e real), x:real \u0026 (forall y:real \u0026 (Differentiate(f)(y) \u003c\u003e 0)))","legal function application obligation:(forall f:(real -\u003e real), x:real \u0026 let terminationCondition:(real -\u003e bool) \u003d (lambda [y:real] \u0026 ((abs f(y)) \u003c Tolerance)), nextApproximation:(real -\u003e real) \u003d (lambda [y:real] \u0026 (y - (f(y) / Differentiate(f)(y)))) in pre_(((new Function().Funtil))[real](terminationCondition)(nextApproximation)x))","legal function application obligation:(forall f:(real -\u003e real), x:real \u0026 let terminationCondition:(real -\u003e bool) \u003d (lambda [y:real] \u0026 ((abs f(y)) \u003c Tolerance)), nextApproximation:(real -\u003e real) \u003d (lambda [y:real] \u0026 (y - (f(y) / Differentiate(f)(y)))) in pre_(((new Function().Funtil))[real](terminationCondition)nextApproximation))","legal function application obligation:(forall f:(real -\u003e real), x:real \u0026 let terminationCondition:(real -\u003e bool) \u003d (lambda [y:real] \u0026 ((abs f(y)) \u003c Tolerance)), nextApproximation:(real -\u003e real) \u003d (lambda [y:real] \u0026 (y - (f(y) / Differentiate(f)(y)))) in pre_(((new Function().Funtil))[real]terminationCondition))","non-zero obligation:(forall f:(real -\u003e real), n:nat1, a:real, b:real \u0026 (n \u003c\u003e 0))","legal function application obligation:(forall f:(real -\u003e real), n:nat1, a:real, b:real \u0026 let h:real \u003d ((b - a) / n), s:seq of (real) \u003d seqGenerate(n, a, h) in pre_(fa))","legal function application obligation:(forall f:(real -\u003e real), n:nat1, a:real, b:real \u0026 let h:real \u003d ((b - a) / n), s:seq of (real) \u003d seqGenerate(n, a, h) in pre_Sum((Sequence`fmap)[real, real](f)(s)))","legal function application obligation:(forall f:(real -\u003e real), n:nat1, a:real, b:real \u0026 let h:real \u003d ((b - a) / n), s:seq of (real) \u003d seqGenerate(n, a, h) in pre_((Sequence`fmap)[real, real](f)s))","legal function application obligation:(forall f:(real -\u003e real), n:nat1, a:real, b:real \u0026 let h:real \u003d ((b - a) / n), s:seq of (real) \u003d seqGenerate(n, a, h) in pre_(fb))","legal function application obligation:(forall x:real \u0026 let f:(real -\u003e real) \u003d (lambda [y:real] \u0026 ((y ** 2) - x)) in pre_(NewtonMethod(f)x))","legal function application obligation:(forall multiple:real, years:int \u0026 (forall Interest:real \u0026 pre_getTotalPrincipal(Interest, years)))","legal function application obligation:(forall multiple:real, years:int \u0026 let f:(real -\u003e real) \u003d (lambda [Interest:real] \u0026 (multiple - getTotalPrincipal(Interest, years))) in pre_(NewtonMethod(f)0))","non-empty sequence obligation:(forall aQueue:seq of (@T) \u0026 ((not (aQueue \u003d [])) \u003d\u003e (aQueue \u003c\u003e [])))","non-empty sequence obligation:(forall aQueue:seq of (@T) \u0026 ((not (aQueue \u003d [])) \u003d\u003e (aQueue \u003c\u003e [])))","legal function application obligation:pre_((d.getNumberOfDayOfTheWeek))","legal function application obligation:pre_((jc.getNumberOfDayOfTheWeekFromName)\u003cTue\u003e)","legal function application obligation:(((d.getNumberOfDayOfTheWeek)() \u003d (jc.getNumberOfDayOfTheWeekFromName)(\u003cTue\u003e)) \u003d\u003e pre_((d.getNameOfDayOfTheWeek)))","legal function application obligation:(((d.getNumberOfDayOfTheWeek)() \u003d (jc.getNumberOfDayOfTheWeekFromName)(\u003cTue\u003e)) \u003d\u003e (((d.getNameOfDayOfTheWeek)() \u003d \u003cTue\u003e) \u003d\u003e pre_((d1.getNameOfDayOfTheWeek))))","legal function application obligation:(((d.getNumberOfDayOfTheWeek)() \u003d (jc.getNumberOfDayOfTheWeekFromName)(\u003cTue\u003e)) \u003d\u003e (((d.getNameOfDayOfTheWeek)() \u003d \u003cTue\u003e) \u003d\u003e (((d1.getNameOfDayOfTheWeek)() \u003d \u003cSun\u003e) \u003d\u003e pre_((d2.getNameOfDayOfTheWeek)))))","legal function application obligation:(((d.getNumberOfDayOfTheWeek)() \u003d (jc.getNumberOfDayOfTheWeekFromName)(\u003cTue\u003e)) \u003d\u003e (((d.getNameOfDayOfTheWeek)() \u003d \u003cTue\u003e) \u003d\u003e (((d1.getNameOfDayOfTheWeek)() \u003d \u003cSun\u003e) \u003d\u003e (((d2.getNameOfDayOfTheWeek)() \u003d \u003cSat\u003e) \u003d\u003e pre_((d.isSunday))))))","legal function application obligation:(((d.getNumberOfDayOfTheWeek)() \u003d (jc.getNumberOfDayOfTheWeekFromName)(\u003cTue\u003e)) \u003d\u003e (((d.getNameOfDayOfTheWeek)() \u003d \u003cTue\u003e) \u003d\u003e (((d1.getNameOfDayOfTheWeek)() \u003d \u003cSun\u003e) \u003d\u003e (((d2.getNameOfDayOfTheWeek)() \u003d \u003cSat\u003e) \u003d\u003e (((d.isSunday)() \u003d false) \u003d\u003e pre_((d.isSaturday)))))))","legal function application obligation:(((d.getNumberOfDayOfTheWeek)() \u003d (jc.getNumberOfDayOfTheWeekFromName)(\u003cTue\u003e)) \u003d\u003e (((d.getNameOfDayOfTheWeek)() \u003d \u003cTue\u003e) \u003d\u003e (((d1.getNameOfDayOfTheWeek)() \u003d \u003cSun\u003e) \u003d\u003e (((d2.getNameOfDayOfTheWeek)() \u003d \u003cSat\u003e) \u003d\u003e (((d.isSunday)() \u003d false) \u003d\u003e (((d.isSaturday)() \u003d false) \u003d\u003e pre_((d.isWeekday))))))))","legal function application obligation:(((d.getNumberOfDayOfTheWeek)() \u003d (jc.getNumberOfDayOfTheWeekFromName)(\u003cTue\u003e)) \u003d\u003e (((d.getNameOfDayOfTheWeek)() \u003d \u003cTue\u003e) \u003d\u003e (((d1.getNameOfDayOfTheWeek)() \u003d \u003cSun\u003e) \u003d\u003e (((d2.getNameOfDayOfTheWeek)() \u003d \u003cSat\u003e) \u003d\u003e (((d.isSunday)() \u003d false) \u003d\u003e (((d.isSaturday)() \u003d false) \u003d\u003e (((d.isWeekday)() \u003d true) \u003d\u003e pre_((d.isDayOff)))))))))","legal function application obligation:(((d.getNumberOfDayOfTheWeek)() \u003d (jc.getNumberOfDayOfTheWeekFromName)(\u003cTue\u003e)) \u003d\u003e (((d.getNameOfDayOfTheWeek)() \u003d \u003cTue\u003e) \u003d\u003e (((d1.getNameOfDayOfTheWeek)() \u003d \u003cSun\u003e) \u003d\u003e (((d2.getNameOfDayOfTheWeek)() \u003d \u003cSat\u003e) \u003d\u003e (((d.isSunday)() \u003d false) \u003d\u003e (((d.isSaturday)() \u003d false) \u003d\u003e (((d.isWeekday)() \u003d true) \u003d\u003e (((d.isDayOff)() \u003d false) \u003d\u003e pre_((d.isNotDayOff))))))))))","legal function application obligation:(((d.getNumberOfDayOfTheWeek)() \u003d (jc.getNumberOfDayOfTheWeekFromName)(\u003cTue\u003e)) \u003d\u003e (((d.getNameOfDayOfTheWeek)() \u003d \u003cTue\u003e) \u003d\u003e (((d1.getNameOfDayOfTheWeek)() \u003d \u003cSun\u003e) \u003d\u003e (((d2.getNameOfDayOfTheWeek)() \u003d \u003cSat\u003e) \u003d\u003e (((d.isSunday)() \u003d false) \u003d\u003e (((d.isSaturday)() \u003d false) \u003d\u003e (((d.isWeekday)() \u003d true) \u003d\u003e (((d.isDayOff)() \u003d false) \u003d\u003e (((d.isNotDayOff)() \u003d true) \u003d\u003e pre_((d.isSundayOrDayoff)))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((d.get_yyyy_mm_dd))","legal function application obligation:(((d.get_yyyy_mm_dd)() \u003d mk_(2001, 5, 1)) \u003d\u003e pre_((d.date2Str)))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((d0301.getTheNumberOfDayOff)d0711)","legal function application obligation:(((d0301.getTheNumberOfDayOff)(d0711) \u003d 24) \u003d\u003e pre_((d0501.getTheNumberOfDayOffExceptStartDate)d0711))","legal function application obligation:(((d0301.getTheNumberOfDayOff)(d0711) \u003d 24) \u003d\u003e (((d0501.getTheNumberOfDayOffExceptStartDate)(d0711) \u003d 13) \u003d\u003e pre_((d20000101.getTheNumberOfDayOff)d0711)))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((((d0502.addWeekday)(1).getFutureWeekday)().date2Str))","legal function application obligation:pre_(((d0502.addWeekday)(1).getFutureWeekday))","legal function application obligation:pre_((d0502.addWeekday)1)","legal function application obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e pre_((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)))","legal function application obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e pre_(((d0502.getPastWeekday)().subtractWeekday)1))","legal function application obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e pre_((d0502.getPastWeekday)))","legal function application obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e pre_((((d0501.getPastWeekday)().subtractWeekday)(1).date2Str))))","legal function application obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e pre_(((d0501.getPastWeekday)().subtractWeekday)1)))","legal function application obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e pre_((d0501.getPastWeekday))))","legal function application obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e (((((d0501.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010427\") \u003d\u003e pre_(((d0501.getFutureWeekday)().date2Str)))))","legal function application obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e (((((d0501.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010427\") \u003d\u003e pre_((d0501.getFutureWeekday)))))","legal function application obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e (((((d0501.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010427\") \u003d\u003e ((((d0501.getFutureWeekday)().date2Str)() \u003d \"20010501\") \u003d\u003e pre_(((d0501.addWeekday)(2).date2Str))))))","legal function application obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e (((((d0501.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010427\") \u003d\u003e ((((d0501.getFutureWeekday)().date2Str)() \u003d \"20010501\") \u003d\u003e pre_((d0501.addWeekday)2)))))","legal function application obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e (((((d0501.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010427\") \u003d\u003e ((((d0501.getFutureWeekday)().date2Str)() \u003d \"20010501\") \u003d\u003e ((((d0501.addWeekday)(2).date2Str)() \u003d \"20010507\") \u003d\u003e pre_(((d0502.subtractWeekday)(2).date2Str)))))))","legal function application obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e (((((d0501.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010427\") \u003d\u003e ((((d0501.getFutureWeekday)().date2Str)() \u003d \"20010501\") \u003d\u003e ((((d0501.addWeekday)(2).date2Str)() \u003d \"20010507\") \u003d\u003e pre_((d0502.subtractWeekday)2))))))","legal function application obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e (((((d0501.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010427\") \u003d\u003e ((((d0501.getFutureWeekday)().date2Str)() \u003d \"20010501\") \u003d\u003e ((((d0501.addWeekday)(2).date2Str)() \u003d \"20010507\") \u003d\u003e ((((d0502.subtractWeekday)(2).date2Str)() \u003d \"20010427\") \u003d\u003e pre_((d1231.daysFromNewYear))))))))","legal function application obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e (((((d0501.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010427\") \u003d\u003e ((((d0501.getFutureWeekday)().date2Str)() \u003d \"20010501\") \u003d\u003e ((((d0501.addWeekday)(2).date2Str)() \u003d \"20010507\") \u003d\u003e ((((d0502.subtractWeekday)(2).date2Str)() \u003d \"20010427\") \u003d\u003e (((d1231.daysFromNewYear)() \u003d 365) \u003d\u003e pre_((d20001231.daysFromNewYear)))))))))","legal function application obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e (((((d0501.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010427\") \u003d\u003e ((((d0501.getFutureWeekday)().date2Str)() \u003d \"20010501\") \u003d\u003e ((((d0501.addWeekday)(2).date2Str)() \u003d \"20010507\") \u003d\u003e ((((d0502.subtractWeekday)(2).date2Str)() \u003d \"20010427\") \u003d\u003e (((d1231.daysFromNewYear)() \u003d 365) \u003d\u003e (((d20001231.daysFromNewYear)() \u003d 366) \u003d\u003e pre_((d0501.getNumberOfTheDayOfWeek)d0626, \u003cTue\u003e)))))))))","legal function application obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e (((((d0501.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010427\") \u003d\u003e ((((d0501.getFutureWeekday)().date2Str)() \u003d \"20010501\") \u003d\u003e ((((d0501.addWeekday)(2).date2Str)() \u003d \"20010507\") \u003d\u003e ((((d0502.subtractWeekday)(2).date2Str)() \u003d \"20010427\") \u003d\u003e (((d1231.daysFromNewYear)() \u003d 365) \u003d\u003e (((d20001231.daysFromNewYear)() \u003d 366) \u003d\u003e (((d0501.getNumberOfTheDayOfWeek)(d0626, \u003cTue\u003e) \u003d 9) \u003d\u003e pre_(((jc.getFutureWeekday)(d0505).date2Str)))))))))))","legal function application obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e (((((d0501.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010427\") \u003d\u003e ((((d0501.getFutureWeekday)().date2Str)() \u003d \"20010501\") \u003d\u003e ((((d0501.addWeekday)(2).date2Str)() \u003d \"20010507\") \u003d\u003e ((((d0502.subtractWeekday)(2).date2Str)() \u003d \"20010427\") \u003d\u003e (((d1231.daysFromNewYear)() \u003d 365) \u003d\u003e (((d20001231.daysFromNewYear)() \u003d 366) \u003d\u003e (((d0501.getNumberOfTheDayOfWeek)(d0626, \u003cTue\u003e) \u003d 9) \u003d\u003e pre_((jc.getFutureWeekday)d0505))))))))))","type compatibility obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e (((((d0501.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010427\") \u003d\u003e ((((d0501.getFutureWeekday)().date2Str)() \u003d \"20010501\") \u003d\u003e ((((d0501.addWeekday)(2).date2Str)() \u003d \"20010507\") \u003d\u003e ((((d0502.subtractWeekday)(2).date2Str)() \u003d \"20010427\") \u003d\u003e (((d1231.daysFromNewYear)() \u003d 365) \u003d\u003e (((d20001231.daysFromNewYear)() \u003d 366) \u003d\u003e (((d0501.getNumberOfTheDayOfWeek)(d0626, \u003cTue\u003e) \u003d 9) \u003d\u003e is_(d0505, Date))))))))))","legal function application obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e (((((d0501.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010427\") \u003d\u003e ((((d0501.getFutureWeekday)().date2Str)() \u003d \"20010501\") \u003d\u003e ((((d0501.addWeekday)(2).date2Str)() \u003d \"20010507\") \u003d\u003e ((((d0502.subtractWeekday)(2).date2Str)() \u003d \"20010427\") \u003d\u003e (((d1231.daysFromNewYear)() \u003d 365) \u003d\u003e (((d20001231.daysFromNewYear)() \u003d 366) \u003d\u003e (((d0501.getNumberOfTheDayOfWeek)(d0626, \u003cTue\u003e) \u003d 9) \u003d\u003e ((((jc.getFutureWeekday)(d0505).date2Str)() \u003d \"20010507\") \u003d\u003e pre_(((jc.getFutureWeekday)(d0501).date2Str))))))))))))","legal function application obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e (((((d0501.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010427\") \u003d\u003e ((((d0501.getFutureWeekday)().date2Str)() \u003d \"20010501\") \u003d\u003e ((((d0501.addWeekday)(2).date2Str)() \u003d \"20010507\") \u003d\u003e ((((d0502.subtractWeekday)(2).date2Str)() \u003d \"20010427\") \u003d\u003e (((d1231.daysFromNewYear)() \u003d 365) \u003d\u003e (((d20001231.daysFromNewYear)() \u003d 366) \u003d\u003e (((d0501.getNumberOfTheDayOfWeek)(d0626, \u003cTue\u003e) \u003d 9) \u003d\u003e ((((jc.getFutureWeekday)(d0505).date2Str)() \u003d \"20010507\") \u003d\u003e pre_((jc.getFutureWeekday)d0501)))))))))))","type compatibility obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e (((((d0501.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010427\") \u003d\u003e ((((d0501.getFutureWeekday)().date2Str)() \u003d \"20010501\") \u003d\u003e ((((d0501.addWeekday)(2).date2Str)() \u003d \"20010507\") \u003d\u003e ((((d0502.subtractWeekday)(2).date2Str)() \u003d \"20010427\") \u003d\u003e (((d1231.daysFromNewYear)() \u003d 365) \u003d\u003e (((d20001231.daysFromNewYear)() \u003d 366) \u003d\u003e (((d0501.getNumberOfTheDayOfWeek)(d0626, \u003cTue\u003e) \u003d 9) \u003d\u003e ((((jc.getFutureWeekday)(d0505).date2Str)() \u003d \"20010507\") \u003d\u003e is_(d0501, Date)))))))))))","legal function application obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e (((((d0501.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010427\") \u003d\u003e ((((d0501.getFutureWeekday)().date2Str)() \u003d \"20010501\") \u003d\u003e ((((d0501.addWeekday)(2).date2Str)() \u003d \"20010507\") \u003d\u003e ((((d0502.subtractWeekday)(2).date2Str)() \u003d \"20010427\") \u003d\u003e (((d1231.daysFromNewYear)() \u003d 365) \u003d\u003e (((d20001231.daysFromNewYear)() \u003d 366) \u003d\u003e (((d0501.getNumberOfTheDayOfWeek)(d0626, \u003cTue\u003e) \u003d 9) \u003d\u003e ((((jc.getFutureWeekday)(d0505).date2Str)() \u003d \"20010507\") \u003d\u003e ((((jc.getFutureWeekday)(d0501).date2Str)() \u003d \"20010501\") \u003d\u003e pre_(((jc.getPastWeekday)(d0501).date2Str)))))))))))))","legal function application obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e (((((d0501.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010427\") \u003d\u003e ((((d0501.getFutureWeekday)().date2Str)() \u003d \"20010501\") \u003d\u003e ((((d0501.addWeekday)(2).date2Str)() \u003d \"20010507\") \u003d\u003e ((((d0502.subtractWeekday)(2).date2Str)() \u003d \"20010427\") \u003d\u003e (((d1231.daysFromNewYear)() \u003d 365) \u003d\u003e (((d20001231.daysFromNewYear)() \u003d 366) \u003d\u003e (((d0501.getNumberOfTheDayOfWeek)(d0626, \u003cTue\u003e) \u003d 9) \u003d\u003e ((((jc.getFutureWeekday)(d0505).date2Str)() \u003d \"20010507\") \u003d\u003e ((((jc.getFutureWeekday)(d0501).date2Str)() \u003d \"20010501\") \u003d\u003e pre_((jc.getPastWeekday)d0501))))))))))))","type compatibility obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e (((((d0501.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010427\") \u003d\u003e ((((d0501.getFutureWeekday)().date2Str)() \u003d \"20010501\") \u003d\u003e ((((d0501.addWeekday)(2).date2Str)() \u003d \"20010507\") \u003d\u003e ((((d0502.subtractWeekday)(2).date2Str)() \u003d \"20010427\") \u003d\u003e (((d1231.daysFromNewYear)() \u003d 365) \u003d\u003e (((d20001231.daysFromNewYear)() \u003d 366) \u003d\u003e (((d0501.getNumberOfTheDayOfWeek)(d0626, \u003cTue\u003e) \u003d 9) \u003d\u003e ((((jc.getFutureWeekday)(d0505).date2Str)() \u003d \"20010507\") \u003d\u003e ((((jc.getFutureWeekday)(d0501).date2Str)() \u003d \"20010501\") \u003d\u003e is_(d0501, Date))))))))))))","legal function application obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e (((((d0501.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010427\") \u003d\u003e ((((d0501.getFutureWeekday)().date2Str)() \u003d \"20010501\") \u003d\u003e ((((d0501.addWeekday)(2).date2Str)() \u003d \"20010507\") \u003d\u003e ((((d0502.subtractWeekday)(2).date2Str)() \u003d \"20010427\") \u003d\u003e (((d1231.daysFromNewYear)() \u003d 365) \u003d\u003e (((d20001231.daysFromNewYear)() \u003d 366) \u003d\u003e (((d0501.getNumberOfTheDayOfWeek)(d0626, \u003cTue\u003e) \u003d 9) \u003d\u003e ((((jc.getFutureWeekday)(d0505).date2Str)() \u003d \"20010507\") \u003d\u003e ((((jc.getFutureWeekday)(d0501).date2Str)() \u003d \"20010501\") \u003d\u003e ((((jc.getPastWeekday)(d0501).date2Str)() \u003d \"20010501\") \u003d\u003e pre_(((jc.getPastWeekday)(d0505).date2Str))))))))))))))","legal function application obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e (((((d0501.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010427\") \u003d\u003e ((((d0501.getFutureWeekday)().date2Str)() \u003d \"20010501\") \u003d\u003e ((((d0501.addWeekday)(2).date2Str)() \u003d \"20010507\") \u003d\u003e ((((d0502.subtractWeekday)(2).date2Str)() \u003d \"20010427\") \u003d\u003e (((d1231.daysFromNewYear)() \u003d 365) \u003d\u003e (((d20001231.daysFromNewYear)() \u003d 366) \u003d\u003e (((d0501.getNumberOfTheDayOfWeek)(d0626, \u003cTue\u003e) \u003d 9) \u003d\u003e ((((jc.getFutureWeekday)(d0505).date2Str)() \u003d \"20010507\") \u003d\u003e ((((jc.getFutureWeekday)(d0501).date2Str)() \u003d \"20010501\") \u003d\u003e ((((jc.getPastWeekday)(d0501).date2Str)() \u003d \"20010501\") \u003d\u003e pre_((jc.getPastWeekday)d0505)))))))))))))","type compatibility obligation:(((((d0502.addWeekday)(1).getFutureWeekday)().date2Str)() \u003d \"20010507\") \u003d\u003e (((((d0502.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010501\") \u003d\u003e (((((d0501.getPastWeekday)().subtractWeekday)(1).date2Str)() \u003d \"20010427\") \u003d\u003e ((((d0501.getFutureWeekday)().date2Str)() \u003d \"20010501\") \u003d\u003e ((((d0501.addWeekday)(2).date2Str)() \u003d \"20010507\") \u003d\u003e ((((d0502.subtractWeekday)(2).date2Str)() \u003d \"20010427\") \u003d\u003e (((d1231.daysFromNewYear)() \u003d 365) \u003d\u003e (((d20001231.daysFromNewYear)() \u003d 366) \u003d\u003e (((d0501.getNumberOfTheDayOfWeek)(d0626, \u003cTue\u003e) \u003d 9) \u003d\u003e ((((jc.getFutureWeekday)(d0505).date2Str)() \u003d \"20010507\") \u003d\u003e ((((jc.getFutureWeekday)(d0501).date2Str)() \u003d \"20010501\") \u003d\u003e ((((jc.getPastWeekday)(d0501).date2Str)() \u003d \"20010501\") \u003d\u003e is_(d0505, Date)))))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0711.NE)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 12)) \u003d\u003e pre_((jc.EQ)d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11))))","type compatibility obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0711.NE)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 12)) \u003d\u003e is_(d0711, Date)))","legal function application obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0711.NE)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 12)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e pre_((jc.LT)d0301, d0711)))))","type compatibility obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0711.NE)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 12)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e is_(d0711, Date)))))","legal function application obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0711.NE)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 12)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e pre_((jc.GT)d0711, d0301)))))))","type compatibility obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0711.NE)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 12)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e is_(d0711, Date)))))))","legal function application obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0711.NE)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 12)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e ((jc.GT)(d0711, d0301) \u003d\u003e ((d0711.GE)(d0711) \u003d\u003e ((d0711.GE)(d0301) \u003d\u003e pre_((jc.GE)d0711, d0711))))))))))","type compatibility obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0711.NE)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 12)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e ((jc.GT)(d0711, d0301) \u003d\u003e ((d0711.GE)(d0711) \u003d\u003e ((d0711.GE)(d0301) \u003d\u003e is_(d0711, Date))))))))))","type compatibility obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0711.NE)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 12)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e ((jc.GT)(d0711, d0301) \u003d\u003e ((d0711.GE)(d0711) \u003d\u003e ((d0711.GE)(d0301) \u003d\u003e is_(d0711, Date))))))))))","legal function application obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0711.NE)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 12)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e ((jc.GT)(d0711, d0301) \u003d\u003e ((d0711.GE)(d0711) \u003d\u003e ((d0711.GE)(d0301) \u003d\u003e ((jc.GE)(d0711, d0711) \u003d\u003e pre_((jc.GE)d0711, d0301)))))))))))","type compatibility obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0711.NE)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 12)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e ((jc.GT)(d0711, d0301) \u003d\u003e ((d0711.GE)(d0711) \u003d\u003e ((d0711.GE)(d0301) \u003d\u003e ((jc.GE)(d0711, d0711) \u003d\u003e is_(d0711, Date)))))))))))","legal function application obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0711.NE)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 12)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e ((jc.GT)(d0711, d0301) \u003d\u003e ((d0711.GE)(d0711) \u003d\u003e ((d0711.GE)(d0301) \u003d\u003e ((jc.GE)(d0711, d0711) \u003d\u003e ((jc.GE)(d0711, d0301) \u003d\u003e ((d0711.LE)(d0711) \u003d\u003e ((d0301.LE)(d0711) \u003d\u003e pre_((jc.LE)d0711, d0711))))))))))))))","type compatibility obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0711.NE)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 12)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e ((jc.GT)(d0711, d0301) \u003d\u003e ((d0711.GE)(d0711) \u003d\u003e ((d0711.GE)(d0301) \u003d\u003e ((jc.GE)(d0711, d0711) \u003d\u003e ((jc.GE)(d0711, d0301) \u003d\u003e ((d0711.LE)(d0711) \u003d\u003e ((d0301.LE)(d0711) \u003d\u003e is_(d0711, Date))))))))))))))","type compatibility obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0711.NE)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 12)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e ((jc.GT)(d0711, d0301) \u003d\u003e ((d0711.GE)(d0711) \u003d\u003e ((d0711.GE)(d0301) \u003d\u003e ((jc.GE)(d0711, d0711) \u003d\u003e ((jc.GE)(d0711, d0301) \u003d\u003e ((d0711.LE)(d0711) \u003d\u003e ((d0301.LE)(d0711) \u003d\u003e is_(d0711, Date))))))))))))))","legal function application obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0711.NE)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 12)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e ((jc.GT)(d0711, d0301) \u003d\u003e ((d0711.GE)(d0711) \u003d\u003e ((d0711.GE)(d0301) \u003d\u003e ((jc.GE)(d0711, d0711) \u003d\u003e ((jc.GE)(d0711, d0301) \u003d\u003e ((d0711.LE)(d0711) \u003d\u003e ((d0301.LE)(d0711) \u003d\u003e ((jc.LE)(d0711, d0711) \u003d\u003e pre_((jc.LE)d0301, d0711)))))))))))))))","type compatibility obligation:((d0711.EQ)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0711.NE)((jc.getDateFrom_yyyy_mm_dd)(2001, 7, 12)) \u003d\u003e ((jc.EQ)(d0711, (jc.getDateFrom_yyyy_mm_dd)(2001, 7, 11)) \u003d\u003e ((d0301.LT)(d0711) \u003d\u003e ((jc.LT)(d0301, d0711) \u003d\u003e ((d0711.GT)(d0301) \u003d\u003e ((jc.GT)(d0711, d0301) \u003d\u003e ((d0711.GE)(d0711) \u003d\u003e ((d0711.GE)(d0301) \u003d\u003e ((jc.GE)(d0711, d0711) \u003d\u003e ((jc.GE)(d0711, d0301) \u003d\u003e ((d0711.LE)(d0711) \u003d\u003e ((d0301.LE)(d0711) \u003d\u003e ((jc.LE)(d0711, d0711) \u003d\u003e is_(d0711, Date)))))))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd))","legal function application obligation:pre_((jc.firstDayOfTheWeekInMonth)2000, 3, \u003cWed\u003e)","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e pre_(((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e pre_((jc.firstDayOfTheWeekInMonth)2001, 7, \u003cSun\u003e))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e pre_(((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd))))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e pre_((jc.lastDayOfTheWeekInMonth)2000, 2, \u003cTue\u003e)))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e pre_(((jc.lastDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)))))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e pre_((jc.lastDayOfTheWeekInMonth)2001, 7, \u003cSun\u003e))))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e pre_(((jc.getNthDayOfTheWeek)(2001, 7, 5, \u003cSun\u003e).get_yyyy_mm_dd))))))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e pre_((jc.getNthDayOfTheWeek)2001, 7, 5, \u003cSun\u003e)))))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e ((((jc.getNthDayOfTheWeek)(2001, 7, 5, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e pre_((jc.getNthDayOfTheWeek)2001, 7, 6, \u003cSun\u003e))))))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e ((((jc.getNthDayOfTheWeek)(2001, 7, 5, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e (((jc.getNthDayOfTheWeek)(2001, 7, 6, \u003cSun\u003e) \u003d false) \u003d\u003e pre_((jc.getNumberOfTheDayOfWeek)d0711, d0301, \u003cSun\u003e)))))))","type compatibility obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e ((((jc.getNthDayOfTheWeek)(2001, 7, 5, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e (((jc.getNthDayOfTheWeek)(2001, 7, 6, \u003cSun\u003e) \u003d false) \u003d\u003e is_(d0711, Date)))))))","legal function application obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e ((((jc.getNthDayOfTheWeek)(2001, 7, 5, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e (((jc.getNthDayOfTheWeek)(2001, 7, 6, \u003cSun\u003e) \u003d false) \u003d\u003e (((jc.getNumberOfTheDayOfWeek)(d0711, d0301, \u003cSun\u003e) \u003d 19) \u003d\u003e pre_((jc.getNumberOfTheDayOfWeek)d0711, d10010301, \u003cSun\u003e))))))))","type compatibility obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e ((((jc.getNthDayOfTheWeek)(2001, 7, 5, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e (((jc.getNthDayOfTheWeek)(2001, 7, 6, \u003cSun\u003e) \u003d false) \u003d\u003e (((jc.getNumberOfTheDayOfWeek)(d0711, d0301, \u003cSun\u003e) \u003d 19) \u003d\u003e is_(d0711, Date))))))))","type compatibility obligation:((((jc.firstDayOfTheWeekInMonth)(2000, 3, \u003cWed\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 3, 1)) \u003d\u003e ((((jc.firstDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 1)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2000, 2, \u003cTue\u003e).get_yyyy_mm_dd)() \u003d mk_(2000, 2, 29)) \u003d\u003e ((((jc.lastDayOfTheWeekInMonth)(2001, 7, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e ((((jc.getNthDayOfTheWeek)(2001, 7, 5, \u003cSun\u003e).get_yyyy_mm_dd)() \u003d mk_(2001, 7, 29)) \u003d\u003e (((jc.getNthDayOfTheWeek)(2001, 7, 6, \u003cSun\u003e) \u003d false) \u003d\u003e (((jc.getNumberOfTheDayOfWeek)(d0711, d0301, \u003cSun\u003e) \u003d 19) \u003d\u003e is_(d10010301, Date))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((jc.isLeapYear)2000)","legal function application obligation:(((jc.isLeapYear)(2000) \u003d true) \u003d\u003e pre_((jc.isLeapYear)2001))","legal function application obligation:(((jc.isLeapYear)(2000) \u003d true) \u003d\u003e (((jc.isLeapYear)(2001) \u003d false) \u003d\u003e pre_((jc.isLeapYear)1996)))","legal function application obligation:(((jc.isLeapYear)(2000) \u003d true) \u003d\u003e (((jc.isLeapYear)(2001) \u003d false) \u003d\u003e (((jc.isLeapYear)(1996) \u003d true) \u003d\u003e pre_((jc.isLeapYear)1900))))","legal function application obligation:(((jc.isLeapYear)(2000) \u003d true) \u003d\u003e (((jc.isLeapYear)(2001) \u003d false) \u003d\u003e (((jc.isLeapYear)(1996) \u003d true) \u003d\u003e (((jc.isLeapYear)(1900) \u003d false) \u003d\u003e pre_((jc.isLeapYear)1600)))))","legal function application obligation:(((jc.isLeapYear)(2000) \u003d true) \u003d\u003e (((jc.isLeapYear)(2001) \u003d false) \u003d\u003e (((jc.isLeapYear)(1996) \u003d true) \u003d\u003e (((jc.isLeapYear)(1900) \u003d false) \u003d\u003e (((jc.isLeapYear)(1600) \u003d true) \u003d\u003e pre_((jc.isDateString)\"sahara\"))))))","legal function application obligation:(((jc.isLeapYear)(2000) \u003d true) \u003d\u003e (((jc.isLeapYear)(2001) \u003d false) \u003d\u003e (((jc.isLeapYear)(1996) \u003d true) \u003d\u003e (((jc.isLeapYear)(1900) \u003d false) \u003d\u003e (((jc.isLeapYear)(1600) \u003d true) \u003d\u003e (((jc.isDateString)(\"sahara\") \u003d false) \u003d\u003e pre_((jc.isDateString)\"20010723\")))))))","legal function application obligation:(((jc.isLeapYear)(2000) \u003d true) \u003d\u003e (((jc.isLeapYear)(2001) \u003d false) \u003d\u003e (((jc.isLeapYear)(1996) \u003d true) \u003d\u003e (((jc.isLeapYear)(1900) \u003d false) \u003d\u003e (((jc.isLeapYear)(1600) \u003d true) \u003d\u003e (((jc.isDateString)(\"sahara\") \u003d false) \u003d\u003e (((jc.isDateString)(\"20010723\") \u003d true) \u003d\u003e pre_((jc.isDateString)\"20011232\"))))))))","legal function application obligation:(((jc.isLeapYear)(2000) \u003d true) \u003d\u003e (((jc.isLeapYear)(2001) \u003d false) \u003d\u003e (((jc.isLeapYear)(1996) \u003d true) \u003d\u003e (((jc.isLeapYear)(1900) \u003d false) \u003d\u003e (((jc.isLeapYear)(1600) \u003d true) \u003d\u003e (((jc.isDateString)(\"sahara\") \u003d false) \u003d\u003e (((jc.isDateString)(\"20010723\") \u003d true) \u003d\u003e (((jc.isDateString)(\"20011232\") \u003d false) \u003d\u003e pre_((jc.isWeekday)\u003cMon\u003e)))))))))","legal function application obligation:(((jc.isLeapYear)(2000) \u003d true) \u003d\u003e (((jc.isLeapYear)(2001) \u003d false) \u003d\u003e (((jc.isLeapYear)(1996) \u003d true) \u003d\u003e (((jc.isLeapYear)(1900) \u003d false) \u003d\u003e (((jc.isLeapYear)(1600) \u003d true) \u003d\u003e (((jc.isDateString)(\"sahara\") \u003d false) \u003d\u003e (((jc.isDateString)(\"20010723\") \u003d true) \u003d\u003e (((jc.isDateString)(\"20011232\") \u003d false) \u003d\u003e (((jc.isWeekday)(\u003cMon\u003e) \u003d true) \u003d\u003e pre_((jc.isWeekday)\u003cTue\u003e))))))))))","legal function application obligation:(((jc.isLeapYear)(2000) \u003d true) \u003d\u003e (((jc.isLeapYear)(2001) \u003d false) \u003d\u003e (((jc.isLeapYear)(1996) \u003d true) \u003d\u003e (((jc.isLeapYear)(1900) \u003d false) \u003d\u003e (((jc.isLeapYear)(1600) \u003d true) \u003d\u003e (((jc.isDateString)(\"sahara\") \u003d false) \u003d\u003e (((jc.isDateString)(\"20010723\") \u003d true) \u003d\u003e (((jc.isDateString)(\"20011232\") \u003d false) \u003d\u003e (((jc.isWeekday)(\u003cMon\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cTue\u003e) \u003d true) \u003d\u003e pre_((jc.isWeekday)\u003cWed\u003e)))))))))))","legal function application obligation:(((jc.isLeapYear)(2000) \u003d true) \u003d\u003e (((jc.isLeapYear)(2001) \u003d false) \u003d\u003e (((jc.isLeapYear)(1996) \u003d true) \u003d\u003e (((jc.isLeapYear)(1900) \u003d false) \u003d\u003e (((jc.isLeapYear)(1600) \u003d true) \u003d\u003e (((jc.isDateString)(\"sahara\") \u003d false) \u003d\u003e (((jc.isDateString)(\"20010723\") \u003d true) \u003d\u003e (((jc.isDateString)(\"20011232\") \u003d false) \u003d\u003e (((jc.isWeekday)(\u003cMon\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cTue\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cWed\u003e) \u003d true) \u003d\u003e pre_((jc.isWeekday)\u003cThu\u003e))))))))))))","legal function application obligation:(((jc.isLeapYear)(2000) \u003d true) \u003d\u003e (((jc.isLeapYear)(2001) \u003d false) \u003d\u003e (((jc.isLeapYear)(1996) \u003d true) \u003d\u003e (((jc.isLeapYear)(1900) \u003d false) \u003d\u003e (((jc.isLeapYear)(1600) \u003d true) \u003d\u003e (((jc.isDateString)(\"sahara\") \u003d false) \u003d\u003e (((jc.isDateString)(\"20010723\") \u003d true) \u003d\u003e (((jc.isDateString)(\"20011232\") \u003d false) \u003d\u003e (((jc.isWeekday)(\u003cMon\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cTue\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cWed\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cThu\u003e) \u003d true) \u003d\u003e pre_((jc.isWeekday)\u003cFri\u003e)))))))))))))","legal function application obligation:(((jc.isLeapYear)(2000) \u003d true) \u003d\u003e (((jc.isLeapYear)(2001) \u003d false) \u003d\u003e (((jc.isLeapYear)(1996) \u003d true) \u003d\u003e (((jc.isLeapYear)(1900) \u003d false) \u003d\u003e (((jc.isLeapYear)(1600) \u003d true) \u003d\u003e (((jc.isDateString)(\"sahara\") \u003d false) \u003d\u003e (((jc.isDateString)(\"20010723\") \u003d true) \u003d\u003e (((jc.isDateString)(\"20011232\") \u003d false) \u003d\u003e (((jc.isWeekday)(\u003cMon\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cTue\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cWed\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cThu\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cFri\u003e) \u003d true) \u003d\u003e pre_((jc.isWeekday)\u003cSat\u003e))))))))))))))","legal function application obligation:(((jc.isLeapYear)(2000) \u003d true) \u003d\u003e (((jc.isLeapYear)(2001) \u003d false) \u003d\u003e (((jc.isLeapYear)(1996) \u003d true) \u003d\u003e (((jc.isLeapYear)(1900) \u003d false) \u003d\u003e (((jc.isLeapYear)(1600) \u003d true) \u003d\u003e (((jc.isDateString)(\"sahara\") \u003d false) \u003d\u003e (((jc.isDateString)(\"20010723\") \u003d true) \u003d\u003e (((jc.isDateString)(\"20011232\") \u003d false) \u003d\u003e (((jc.isWeekday)(\u003cMon\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cTue\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cWed\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cThu\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cFri\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cSat\u003e) \u003d false) \u003d\u003e pre_((jc.isWeekday)\u003cSun\u003e)))))))))))))))","legal function application obligation:(((jc.isLeapYear)(2000) \u003d true) \u003d\u003e (((jc.isLeapYear)(2001) \u003d false) \u003d\u003e (((jc.isLeapYear)(1996) \u003d true) \u003d\u003e (((jc.isLeapYear)(1900) \u003d false) \u003d\u003e (((jc.isLeapYear)(1600) \u003d true) \u003d\u003e (((jc.isDateString)(\"sahara\") \u003d false) \u003d\u003e (((jc.isDateString)(\"20010723\") \u003d true) \u003d\u003e (((jc.isDateString)(\"20011232\") \u003d false) \u003d\u003e (((jc.isWeekday)(\u003cMon\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cTue\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cWed\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cThu\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cFri\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cSat\u003e) \u003d false) \u003d\u003e (((jc.isWeekday)(\u003cSun\u003e) \u003d false) \u003d\u003e pre_((jc.date2Str)(jc.getLastDayOfMonth)(2000, 2)))))))))))))))))","legal function application obligation:(((jc.isLeapYear)(2000) \u003d true) \u003d\u003e (((jc.isLeapYear)(2001) \u003d false) \u003d\u003e (((jc.isLeapYear)(1996) \u003d true) \u003d\u003e (((jc.isLeapYear)(1900) \u003d false) \u003d\u003e (((jc.isLeapYear)(1600) \u003d true) \u003d\u003e (((jc.isDateString)(\"sahara\") \u003d false) \u003d\u003e (((jc.isDateString)(\"20010723\") \u003d true) \u003d\u003e (((jc.isDateString)(\"20011232\") \u003d false) \u003d\u003e (((jc.isWeekday)(\u003cMon\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cTue\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cWed\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cThu\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cFri\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cSat\u003e) \u003d false) \u003d\u003e (((jc.isWeekday)(\u003cSun\u003e) \u003d false) \u003d\u003e pre_((jc.getLastDayOfMonth)2000, 2))))))))))))))))","legal function application obligation:(((jc.isLeapYear)(2000) \u003d true) \u003d\u003e (((jc.isLeapYear)(2001) \u003d false) \u003d\u003e (((jc.isLeapYear)(1996) \u003d true) \u003d\u003e (((jc.isLeapYear)(1900) \u003d false) \u003d\u003e (((jc.isLeapYear)(1600) \u003d true) \u003d\u003e (((jc.isDateString)(\"sahara\") \u003d false) \u003d\u003e (((jc.isDateString)(\"20010723\") \u003d true) \u003d\u003e (((jc.isDateString)(\"20011232\") \u003d false) \u003d\u003e (((jc.isWeekday)(\u003cMon\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cTue\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cWed\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cThu\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cFri\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cSat\u003e) \u003d false) \u003d\u003e (((jc.isWeekday)(\u003cSun\u003e) \u003d false) \u003d\u003e (((jc.date2Str)((jc.getLastDayOfMonth)(2000, 2)) \u003d \"20000229\") \u003d\u003e pre_((jc.date2Str)(jc.getLastDayOfMonth)(2001, 2))))))))))))))))))","legal function application obligation:(((jc.isLeapYear)(2000) \u003d true) \u003d\u003e (((jc.isLeapYear)(2001) \u003d false) \u003d\u003e (((jc.isLeapYear)(1996) \u003d true) \u003d\u003e (((jc.isLeapYear)(1900) \u003d false) \u003d\u003e (((jc.isLeapYear)(1600) \u003d true) \u003d\u003e (((jc.isDateString)(\"sahara\") \u003d false) \u003d\u003e (((jc.isDateString)(\"20010723\") \u003d true) \u003d\u003e (((jc.isDateString)(\"20011232\") \u003d false) \u003d\u003e (((jc.isWeekday)(\u003cMon\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cTue\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cWed\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cThu\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cFri\u003e) \u003d true) \u003d\u003e (((jc.isWeekday)(\u003cSat\u003e) \u003d false) \u003d\u003e (((jc.isWeekday)(\u003cSun\u003e) \u003d false) \u003d\u003e (((jc.date2Str)((jc.getLastDayOfMonth)(2000, 2)) \u003d \"20000229\") \u003d\u003e pre_((jc.getLastDayOfMonth)2001, 2)))))))))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(Real`EQ((r.getInterest)(2, 10))0.07177346254161253)","legal function application obligation:pre_((r.getInterest)2, 10)","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(Real`EQ((r.root)(2))1.414213562382246)","legal function application obligation:pre_((r.root)2)","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((r.isNDigitsAfterTheDecimalPoint)10.01, 2)","legal function application obligation:((r.isNDigitsAfterTheDecimalPoint)(10.01, 2) \u003d\u003e pre_((r.isNDigitsAfterTheDecimalPoint)10.01, 3))","legal function application obligation:((r.isNDigitsAfterTheDecimalPoint)(10.01, 2) \u003d\u003e ((not (r.isNDigitsAfterTheDecimalPoint)(10.01, 3)) \u003d\u003e pre_((r.isNDigitsAfterTheDecimalPoint)10.012, 3)))","legal function application obligation:((r.isNDigitsAfterTheDecimalPoint)(10.01, 2) \u003d\u003e ((not (r.isNDigitsAfterTheDecimalPoint)(10.01, 3)) \u003d\u003e ((r.isNDigitsAfterTheDecimalPoint)(10.012, 3) \u003d\u003e pre_((r.isNDigitsAfterTheDecimalPoint)10.0, 0))))","legal function application obligation:((r.isNDigitsAfterTheDecimalPoint)(10.01, 2) \u003d\u003e ((not (r.isNDigitsAfterTheDecimalPoint)(10.01, 3)) \u003d\u003e ((r.isNDigitsAfterTheDecimalPoint)(10.012, 3) \u003d\u003e ((r.isNDigitsAfterTheDecimalPoint)(10.0, 0) \u003d\u003e pre_((r.isNDigitsAfterTheDecimalPoint)10.011, 2)))))","legal function application obligation:((r.isNDigitsAfterTheDecimalPoint)(10.01, 2) \u003d\u003e ((not (r.isNDigitsAfterTheDecimalPoint)(10.01, 3)) \u003d\u003e ((r.isNDigitsAfterTheDecimalPoint)(10.012, 3) \u003d\u003e ((r.isNDigitsAfterTheDecimalPoint)(10.0, 0) \u003d\u003e (((r.isNDigitsAfterTheDecimalPoint)(10.011, 2) \u003d false) \u003d\u003e pre_((r.isNDigitsAfterTheDecimalPoint)10.1, 0))))))","legal function application obligation:((r.isNDigitsAfterTheDecimalPoint)(10.01, 2) \u003d\u003e ((not (r.isNDigitsAfterTheDecimalPoint)(10.01, 3)) \u003d\u003e ((r.isNDigitsAfterTheDecimalPoint)(10.012, 3) \u003d\u003e ((r.isNDigitsAfterTheDecimalPoint)(10.0, 0) \u003d\u003e (((r.isNDigitsAfterTheDecimalPoint)(10.011, 2) \u003d false) \u003d\u003e (((r.isNDigitsAfterTheDecimalPoint)(10.1, 0) \u003d false) \u003d\u003e pre_((r.getNumberOfDigitsAfterTheDecimalPoint)-1.2)))))))","legal function application obligation:((r.isNDigitsAfterTheDecimalPoint)(10.01, 2) \u003d\u003e ((not (r.isNDigitsAfterTheDecimalPoint)(10.01, 3)) \u003d\u003e ((r.isNDigitsAfterTheDecimalPoint)(10.012, 3) \u003d\u003e ((r.isNDigitsAfterTheDecimalPoint)(10.0, 0) \u003d\u003e (((r.isNDigitsAfterTheDecimalPoint)(10.011, 2) \u003d false) \u003d\u003e (((r.isNDigitsAfterTheDecimalPoint)(10.1, 0) \u003d false) \u003d\u003e (((r.getNumberOfDigitsAfterTheDecimalPoint)(-1.2) \u003d 1) \u003d\u003e pre_((r.getNumberOfDigitsAfterTheDecimalPoint)1.0))))))))","legal function application obligation:((r.isNDigitsAfterTheDecimalPoint)(10.01, 2) \u003d\u003e ((not (r.isNDigitsAfterTheDecimalPoint)(10.01, 3)) \u003d\u003e ((r.isNDigitsAfterTheDecimalPoint)(10.012, 3) \u003d\u003e ((r.isNDigitsAfterTheDecimalPoint)(10.0, 0) \u003d\u003e (((r.isNDigitsAfterTheDecimalPoint)(10.011, 2) \u003d false) \u003d\u003e (((r.isNDigitsAfterTheDecimalPoint)(10.1, 0) \u003d false) \u003d\u003e (((r.getNumberOfDigitsAfterTheDecimalPoint)(-1.2) \u003d 1) \u003d\u003e (((r.getNumberOfDigitsAfterTheDecimalPoint)(1.0) \u003d 0) \u003d\u003e pre_((r.getNumberOfDigitsAfterTheDecimalPoint)1)))))))))","legal function application obligation:((r.isNDigitsAfterTheDecimalPoint)(10.01, 2) \u003d\u003e ((not (r.isNDigitsAfterTheDecimalPoint)(10.01, 3)) \u003d\u003e ((r.isNDigitsAfterTheDecimalPoint)(10.012, 3) \u003d\u003e ((r.isNDigitsAfterTheDecimalPoint)(10.0, 0) \u003d\u003e (((r.isNDigitsAfterTheDecimalPoint)(10.011, 2) \u003d false) \u003d\u003e (((r.isNDigitsAfterTheDecimalPoint)(10.1, 0) \u003d false) \u003d\u003e (((r.getNumberOfDigitsAfterTheDecimalPoint)(-1.2) \u003d 1) \u003d\u003e (((r.getNumberOfDigitsAfterTheDecimalPoint)(1.0) \u003d 0) \u003d\u003e (((r.getNumberOfDigitsAfterTheDecimalPoint)(1) \u003d 0) \u003d\u003e pre_((r.getNumberOfDigitsAfterTheDecimalPoint)1.23))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_((r.numberOfDigit)0)","legal function application obligation:(((r.numberOfDigit)(0) \u003d 1) \u003d\u003e pre_((r.numberOfDigit)1))","legal function application obligation:(((r.numberOfDigit)(0) \u003d 1) \u003d\u003e (((r.numberOfDigit)(1) \u003d 1) \u003d\u003e pre_((r.numberOfDigit)9)))","legal function application obligation:(((r.numberOfDigit)(0) \u003d 1) \u003d\u003e (((r.numberOfDigit)(1) \u003d 1) \u003d\u003e (((r.numberOfDigit)(9) \u003d 1) \u003d\u003e pre_((r.numberOfDigit)10))))","legal function application obligation:(((r.numberOfDigit)(0) \u003d 1) \u003d\u003e (((r.numberOfDigit)(1) \u003d 1) \u003d\u003e (((r.numberOfDigit)(9) \u003d 1) \u003d\u003e (((r.numberOfDigit)(10) \u003d 2) \u003d\u003e pre_((r.numberOfDigit)99)))))","legal function application obligation:(((r.numberOfDigit)(0) \u003d 1) \u003d\u003e (((r.numberOfDigit)(1) \u003d 1) \u003d\u003e (((r.numberOfDigit)(9) \u003d 1) \u003d\u003e (((r.numberOfDigit)(10) \u003d 2) \u003d\u003e (((r.numberOfDigit)(99) \u003d 2) \u003d\u003e pre_((r.numberOfDigit)100))))))","legal function application obligation:(((r.numberOfDigit)(0) \u003d 1) \u003d\u003e (((r.numberOfDigit)(1) \u003d 1) \u003d\u003e (((r.numberOfDigit)(9) \u003d 1) \u003d\u003e (((r.numberOfDigit)(10) \u003d 2) \u003d\u003e (((r.numberOfDigit)(99) \u003d 2) \u003d\u003e (((r.numberOfDigit)(100) \u003d 3) \u003d\u003e pre_((r.numberOfDigit)0.1)))))))","legal function application obligation:(((r.numberOfDigit)(0) \u003d 1) \u003d\u003e (((r.numberOfDigit)(1) \u003d 1) \u003d\u003e (((r.numberOfDigit)(9) \u003d 1) \u003d\u003e (((r.numberOfDigit)(10) \u003d 2) \u003d\u003e (((r.numberOfDigit)(99) \u003d 2) \u003d\u003e (((r.numberOfDigit)(100) \u003d 3) \u003d\u003e (((r.numberOfDigit)(0.1) \u003d 3) \u003d\u003e pre_((r.numberOfDigit)9.1))))))))","legal function application obligation:(((r.numberOfDigit)(0) \u003d 1) \u003d\u003e (((r.numberOfDigit)(1) \u003d 1) \u003d\u003e (((r.numberOfDigit)(9) \u003d 1) \u003d\u003e (((r.numberOfDigit)(10) \u003d 2) \u003d\u003e (((r.numberOfDigit)(99) \u003d 2) \u003d\u003e (((r.numberOfDigit)(100) \u003d 3) \u003d\u003e (((r.numberOfDigit)(0.1) \u003d 3) \u003d\u003e (((r.numberOfDigit)(9.1) \u003d 3) \u003d\u003e pre_((r.numberOfDigit)10.1)))))))))","legal function application obligation:(((r.numberOfDigit)(0) \u003d 1) \u003d\u003e (((r.numberOfDigit)(1) \u003d 1) \u003d\u003e (((r.numberOfDigit)(9) \u003d 1) \u003d\u003e (((r.numberOfDigit)(10) \u003d 2) \u003d\u003e (((r.numberOfDigit)(99) \u003d 2) \u003d\u003e (((r.numberOfDigit)(100) \u003d 3) \u003d\u003e (((r.numberOfDigit)(0.1) \u003d 3) \u003d\u003e (((r.numberOfDigit)(9.1) \u003d 3) \u003d\u003e (((r.numberOfDigit)(10.1) \u003d 4) \u003d\u003e pre_((r.numberOfDigit)10.123))))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 4))10.1235)","legal function application obligation:pre_roundAterDecimalPointByNdigit(10.12345, 4)","legal function application obligation:(Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 4))(10.1235) \u003d\u003e pre_(Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 3))10.123))","legal function application obligation:(Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 4))(10.1235) \u003d\u003e pre_roundAterDecimalPointByNdigit(10.12345, 3))","legal function application obligation:(Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 4))(10.1235) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 3))(10.123) \u003d\u003e pre_(Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 2))10.12)))","legal function application obligation:(Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 4))(10.1235) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 3))(10.123) \u003d\u003e pre_roundAterDecimalPointByNdigit(10.12345, 2)))","legal function application obligation:(Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 4))(10.1235) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 3))(10.123) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 2))(10.12) \u003d\u003e pre_(Real`EQ(Real`roundAterDecimalPointByNdigit(10.125, 2))10.13))))","legal function application obligation:(Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 4))(10.1235) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 3))(10.123) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 2))(10.12) \u003d\u003e pre_roundAterDecimalPointByNdigit(10.125, 2))))","legal function application obligation:(Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 4))(10.1235) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 3))(10.123) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 2))(10.12) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.125, 2))(10.13) \u003d\u003e pre_(Real`EQ(Real`roundAterDecimalPointByNdigit(10.14, 1))10.1)))))","legal function application obligation:(Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 4))(10.1235) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 3))(10.123) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 2))(10.12) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.125, 2))(10.13) \u003d\u003e pre_roundAterDecimalPointByNdigit(10.14, 1)))))","legal function application obligation:(Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 4))(10.1235) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 3))(10.123) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 2))(10.12) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.125, 2))(10.13) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.14, 1))(10.1) \u003d\u003e pre_(Real`EQ(Real`roundAterDecimalPointByNdigit(10.15, 1))10.2))))))","legal function application obligation:(Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 4))(10.1235) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 3))(10.123) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 2))(10.12) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.125, 2))(10.13) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.14, 1))(10.1) \u003d\u003e pre_roundAterDecimalPointByNdigit(10.15, 1))))))","legal function application obligation:(Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 4))(10.1235) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 3))(10.123) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 2))(10.12) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.125, 2))(10.13) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.14, 1))(10.1) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.15, 1))(10.2) \u003d\u003e pre_(Real`EQ(Real`roundAterDecimalPointByNdigit(10.5, 0))11)))))))","legal function application obligation:(Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 4))(10.1235) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 3))(10.123) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 2))(10.12) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.125, 2))(10.13) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.14, 1))(10.1) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.15, 1))(10.2) \u003d\u003e pre_roundAterDecimalPointByNdigit(10.5, 0)))))))","legal function application obligation:(Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 4))(10.1235) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 3))(10.123) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 2))(10.12) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.125, 2))(10.13) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.14, 1))(10.1) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.15, 1))(10.2) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.5, 0))(11) \u003d\u003e pre_(Real`EQ(Real`roundAterDecimalPointByNdigit(10.4, 0))10))))))))","legal function application obligation:(Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 4))(10.1235) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 3))(10.123) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.12345, 2))(10.12) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.125, 2))(10.13) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.14, 1))(10.1) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.15, 1))(10.2) \u003d\u003e (Real`EQ(Real`roundAterDecimalPointByNdigit(10.5, 0))(11) \u003d\u003e pre_roundAterDecimalPointByNdigit(10.4, 0))))))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(Real`EQ(10.0123456678)10.0123456789)","legal function application obligation:((Real`EQ(10.0123456678)(10.0123456789) \u003d false) \u003d\u003e pre_(Real`EQ(10.01234567891)10.01234567892))","legal function application obligation:((Real`EQ(10.0123456678)(10.0123456789) \u003d false) \u003d\u003e (Real`EQ(10.01234567891)(10.01234567892) \u003d\u003e pre_(Real`EQ(10.012345678801)10.0123456789)))","legal function application obligation:((Real`EQ(10.0123456678)(10.0123456789) \u003d false) \u003d\u003e (Real`EQ(10.01234567891)(10.01234567892) \u003d\u003e (Real`EQ(10.012345678801)(10.0123456789) \u003d\u003e pre_(Real`EQE(0.01)(10.12345)10.12987))))","legal function application obligation:((Real`EQ(10.0123456678)(10.0123456789) \u003d false) \u003d\u003e (Real`EQ(10.01234567891)(10.01234567892) \u003d\u003e (Real`EQ(10.012345678801)(10.0123456789) \u003d\u003e pre_(Real`EQE(0.01)10.12345))))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(Real`EQ(Real`integrate(f1)(10)(1)(2))2.735)","legal function application obligation:pre_(Real`integrate(f1)(10)(1)2)","legal function application obligation:pre_(Real`integrate(f1)(10)1)","legal function application obligation:pre_(Real`integrate(f1)10)","legal function application obligation:(Real`EQ(Real`integrate(f1)(10)(1)(2))(2.735) \u003d\u003e pre_(Real`EQ(Real`integrate(f1)(100)(1)(2))2.37335))","legal function application obligation:(Real`EQ(Real`integrate(f1)(10)(1)(2))(2.735) \u003d\u003e pre_(Real`integrate(f1)(100)(1)2))","legal function application obligation:(Real`EQ(Real`integrate(f1)(10)(1)(2))(2.735) \u003d\u003e pre_(Real`integrate(f1)(100)1))","legal function application obligation:(Real`EQ(Real`integrate(f1)(10)(1)(2))(2.735) \u003d\u003e pre_(Real`integrate(f1)100))","legal function application obligation:(Real`EQ(Real`integrate(f1)(10)(1)(2))(2.735) \u003d\u003e (Real`EQ(Real`integrate(f1)(100)(1)(2))(2.37335) \u003d\u003e pre_(Real`EQ(Real`integrate(f1)(1000)(1)(2))2.3373335)))","legal function application obligation:(Real`EQ(Real`integrate(f1)(10)(1)(2))(2.735) \u003d\u003e (Real`EQ(Real`integrate(f1)(100)(1)(2))(2.37335) \u003d\u003e pre_(Real`integrate(f1)(1000)(1)2)))","legal function application obligation:(Real`EQ(Real`integrate(f1)(10)(1)(2))(2.735) \u003d\u003e (Real`EQ(Real`integrate(f1)(100)(1)(2))(2.37335) \u003d\u003e pre_(Real`integrate(f1)(1000)1)))","legal function application obligation:(Real`EQ(Real`integrate(f1)(10)(1)(2))(2.735) \u003d\u003e (Real`EQ(Real`integrate(f1)(100)(1)(2))(2.37335) \u003d\u003e pre_(Real`integrate(f1)1000)))","type compatibility obligation:is_(RESULT, ())","legal function application obligation:pre_(Real`EQ(Real`integrate(sin)(2)(0)(pi))1.5707963278)","legal function application obligation:pre_(Real`integrate(sin)(2)(0)pi)","legal function application obligation:pre_(Real`integrate(sin)(2)0)","legal function application obligation:pre_(Real`integrate(sin)2)","legal function application obligation:(Real`EQ(Real`integrate(sin)(2)(0)(pi))(1.5707963278) \u003d\u003e pre_(Real`EQ(Real`integrate(sin)(3)(0)(pi))1.8137993649))","legal function application obligation:(Real`EQ(Real`integrate(sin)(2)(0)(pi))(1.5707963278) \u003d\u003e pre_(Real`integrate(sin)(3)(0)pi))","legal function application obligation:(Real`EQ(Real`integrate(sin)(2)(0)(pi))(1.5707963278) \u003d\u003e pre_(Real`integrate(sin)(3)0))","legal function application obligation:(Real`EQ(Real`integrate(sin)(2)(0)(pi))(1.5707963278) \u003d\u003e pre_(Real`integrate(sin)3))","legal function application obligation:(Real`EQ(Real`integrate(sin)(2)(0)(pi))(1.5707963278) \u003d\u003e (Real`EQ(Real`integrate(sin)(3)(0)(pi))(1.8137993649) \u003d\u003e pre_(Real`EQ(Real`integrate(sin)(4)(0)(pi))1.8961188984)))","legal function application obligation:(Real`EQ(Real`integrate(sin)(2)(0)(pi))(1.5707963278) \u003d\u003e (Real`EQ(Real`integrate(sin)(3)(0)(pi))(1.8137993649) \u003d\u003e pre_(Real`integrate(sin)(4)(0)pi)))","legal function application obligation:(Real`EQ(Real`integrate(sin)(2)(0)(pi))(1.5707963278) \u003d\u003e (Real`EQ(Real`integrate(sin)(3)(0)(pi))(1.8137993649) \u003d\u003e pre_(Real`integrate(sin)(4)0)))","legal function application obligation:(Real`EQ(Real`integrate(sin)(2)(0)(pi))(1.5707963278) \u003d\u003e (Real`EQ(Real`integrate(sin)(3)(0)(pi))(1.8137993649) \u003d\u003e pre_(Real`integrate(sin)4)))","legal function application obligation:(Real`EQ(Real`integrate(sin)(2)(0)(pi))(1.5707963278) \u003d\u003e (Real`EQ(Real`integrate(sin)(3)(0)(pi))(1.8137993649) \u003d\u003e (Real`EQ(Real`integrate(sin)(4)(0)(pi))(1.8961188984) \u003d\u003e pre_(Real`EQ(Real`integrate(sin)(5)(0)(pi))1.9337655984))))","legal function application obligation:(Real`EQ(Real`integrate(sin)(2)(0)(pi))(1.5707963278) \u003d\u003e (Real`EQ(Real`integrate(sin)(3)(0)(pi))(1.8137993649) \u003d\u003e (Real`EQ(Real`integrate(sin)(4)(0)(pi))(1.8961188984) \u003d\u003e pre_(Real`integrate(sin)(5)(0)pi))))","legal function application obligation:(Real`EQ(Real`integrate(sin)(2)(0)(pi))(1.5707963278) \u003d\u003e (Real`EQ(Real`integrate(sin)(3)(0)(pi))(1.8137993649) \u003d\u003e (Real`EQ(Real`integrate(sin)(4)(0)(pi))(1.8961188984) \u003d\u003e pre_(Real`integrate(sin)(5)0))))","legal function application obligation:(Real`EQ(Real`integrate(sin)(2)(0)(pi))(1.5707963278) \u003d\u003e (Real`EQ(Real`integrate(sin)(3)(0)(pi))(1.8137993649) \u003d\u003e (Real`EQ(Real`integrate(sin)(4)(0)(pi))(1.8961188984) \u003d\u003e pre_(Real`integrate(sin)5))))","legal function application obligation:(Real`EQ(Real`integrate(sin)(2)(0)(pi))(1.5707963278) \u003d\u003e (Real`EQ(Real`integrate(sin)(3)(0)(pi))(1.8137993649) \u003d\u003e (Real`EQ(Real`integrate(sin)(4)(0)(pi))(1.8961188984) \u003d\u003e (Real`EQ(Real`integrate(sin)(5)(0)(pi))(1.9337655984) \u003d\u003e pre_(Real`EQ(Real`integrate(sin)(2000)(1)(pi))1.5403021586)))))","legal function application obligation:(Real`EQ(Real`integrate(sin)(2)(0)(pi))(1.5707963278) \u003d\u003e (Real`EQ(Real`integrate(sin)(3)(0)(pi))(1.8137993649) \u003d\u003e (Real`EQ(Real`integrate(sin)(4)(0)(pi))(1.8961188984) \u003d\u003e (Real`EQ(Real`integrate(sin)(5)(0)(pi))(1.9337655984) \u003d\u003e pre_(Real`integrate(sin)(2000)(1)pi)))))","legal function application obligation:(Real`EQ(Real`integrate(sin)(2)(0)(pi))(1.5707963278) \u003d\u003e (Real`EQ(Real`integrate(sin)(3)(0)(pi))(1.8137993649) \u003d\u003e (Real`EQ(Real`integrate(sin)(4)(0)(pi))(1.8961188984) \u003d\u003e (Real`EQ(Real`integrate(sin)(5)(0)(pi))(1.9337655984) \u003d\u003e pre_(Real`integrate(sin)(2000)1)))))","legal function application obligation:(Real`EQ(Real`integrate(sin)(2)(0)(pi))(1.5707963278) \u003d\u003e (Real`EQ(Real`integrate(sin)(3)(0)(pi))(1.8137993649) \u003d\u003e (Real`EQ(Real`integrate(sin)(4)(0)(pi))(1.8961188984) \u003d\u003e (Real`EQ(Real`integrate(sin)(5)(0)(pi))(1.9337655984) \u003d\u003e pre_(Real`integrate(sin)2000)))))","type compatibility obligation:is_(RESULT, ())","operation call obligation:(forall text:seq of (char) \u0026 ((\"\" \u003d \"\") \u003c\u003d\u003e (\"\" \u003d nil)))","non-zero obligation:(forall a:real \u0026 ((a \u003c\u003e 0) \u003d\u003e (a \u003c\u003e 0)))"] \ No newline at end of file diff --git a/core/pog/src/test/resources/examples/STVSL.result b/core/pog/src/test/resources/examples/STVSL.result index 930c6dc70d..fdee7895d5 100644 --- a/core/pog/src/test/resources/examples/STVSL.result +++ b/core/pog/src/test/resources/examples/STVSL.result @@ -1 +1 @@ -["enumeration map injectivity obligation:(forall m1, m2 in set {{\u003cAdam\u003e |-\u003e 1}, {\u003cBill\u003e |-\u003e 2}, {\u003cCharlie\u003e |-\u003e 3}, {\u003cFrank\u003e |-\u003e 4}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","enumeration map injectivity obligation:(forall m1, m2 in set {{\u003cBill\u003e |-\u003e 1}, {\u003cAdam\u003e |-\u003e 2}, {\u003cCharlie\u003e |-\u003e 3}, {\u003cGeorge\u003e |-\u003e 4}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","enumeration map injectivity obligation:(forall m1, m2 in set {{\u003cAdam\u003e |-\u003e 1}, {\u003cCharlie\u003e |-\u003e 2}, {\u003cBill\u003e |-\u003e 3}, {\u003cHarry\u003e |-\u003e 4}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","enumeration map injectivity obligation:(forall m1, m2 in set {{\u003cBill\u003e |-\u003e 1}, {\u003cCharlie\u003e |-\u003e 2}, {\u003cAdam\u003e |-\u003e 3}, {\u003cIan\u003e |-\u003e 4}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","enumeration map injectivity obligation:(forall m1, m2 in set {{\u003cCharlie\u003e |-\u003e 1}, {\u003cAdam\u003e |-\u003e 2}, {\u003cBill\u003e |-\u003e 3}, {\u003cJohn\u003e |-\u003e 4}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","enumeration map injectivity obligation:(forall m1, m2 in set {{\u003cCharlie\u003e |-\u003e 1}, {\u003cBill\u003e |-\u003e 2}, {\u003cAdam\u003e |-\u003e 3}, {\u003cDonald\u003e |-\u003e 4}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","enumeration map injectivity obligation:(forall m1, m2 in set {{\u003cDonald\u003e |-\u003e 1}, {\u003cAdam\u003e |-\u003e 2}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","enumeration map injectivity obligation:(forall m1, m2 in set {{\u003cFrank\u003e |-\u003e 1}, {\u003cBill\u003e |-\u003e 2}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","enumeration map injectivity obligation:(forall m1, m2 in set {{\u003cGeorge\u003e |-\u003e 1}, {\u003cCharlie\u003e |-\u003e 2}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","enumeration map injectivity obligation:(forall m1, m2 in set {{\u003cHarry\u003e |-\u003e 1}, {\u003cBill\u003e |-\u003e 2}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","enumeration map injectivity obligation:(forall m1, m2 in set {{\u003cIan\u003e |-\u003e 1}, {\u003cAdam\u003e |-\u003e 2}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","enumeration map injectivity obligation:(forall m1, m2 in set {{\u003cJohn\u003e |-\u003e 1}, {\u003cCharlie\u003e |-\u003e 2}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","enumeration map injectivity obligation:(forall m1, m2 in set {{{\u003cAdam\u003e |-\u003e 1, \u003cBill\u003e |-\u003e 2, \u003cCharlie\u003e |-\u003e 3, \u003cFrank\u003e |-\u003e 4} |-\u003e 100000}, {{\u003cBill\u003e |-\u003e 1, \u003cAdam\u003e |-\u003e 2, \u003cCharlie\u003e |-\u003e 3, \u003cGeorge\u003e |-\u003e 4} |-\u003e 100000}, {{\u003cAdam\u003e |-\u003e 1, \u003cCharlie\u003e |-\u003e 2, \u003cBill\u003e |-\u003e 3, \u003cHarry\u003e |-\u003e 4} |-\u003e 100000}, {{\u003cBill\u003e |-\u003e 1, \u003cCharlie\u003e |-\u003e 2, \u003cAdam\u003e |-\u003e 3, \u003cIan\u003e |-\u003e 4} |-\u003e 100000}, {{\u003cCharlie\u003e |-\u003e 1, \u003cAdam\u003e |-\u003e 2, \u003cBill\u003e |-\u003e 3, \u003cJohn\u003e |-\u003e 4} |-\u003e 100000}, {{\u003cCharlie\u003e |-\u003e 1, \u003cBill\u003e |-\u003e 2, \u003cAdam\u003e |-\u003e 3, \u003cDonald\u003e |-\u003e 4} |-\u003e 100000}, {{\u003cDonald\u003e |-\u003e 1, \u003cAdam\u003e |-\u003e 2} |-\u003e 1000}, {{\u003cFrank\u003e |-\u003e 1, \u003cBill\u003e |-\u003e 2} |-\u003e 1000}, {{\u003cGeorge\u003e |-\u003e 1, \u003cCharlie\u003e |-\u003e 2} |-\u003e 1000}, {{\u003cHarry\u003e |-\u003e 1, \u003cBill\u003e |-\u003e 2} |-\u003e 1000}, {{\u003cIan\u003e |-\u003e 1, \u003cAdam\u003e |-\u003e 2} |-\u003e 1000}, {{\u003cJohn\u003e |-\u003e 1, \u003cCharlie\u003e |-\u003e 2} |-\u003e 1000}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","legal map application obligation:(forall v:map (Candidate_names) to (nat1) \u0026 (forall name:Candidate_names \u0026 (name in set (dom v))))","type invariant satisfiable obligation:(exists v:Voting_paper \u0026 (exists1 name:Candidate_names \u0026 (v(name) \u003d 1)))","legal sequence application obligation:(forall s:seq of (Score) \u0026 (forall i in set (inds s), j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e (i in set (inds s)))))","legal sequence application obligation:(forall s:seq of (Score) \u0026 (forall i in set (inds s), j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e (j in set (inds s)))))","legal sequence application obligation:(forall s:seq of (Score) \u0026 (forall i in set (inds s), j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e ((((s(i).count) \u003e\u003d (s(j).count)) and (i \u003c\u003e j)) \u003d\u003e (i in set (inds s))))))","legal sequence application obligation:(forall s:seq of (Score) \u0026 (forall i in set (inds s), j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e ((((s(i).count) \u003e\u003d (s(j).count)) and (i \u003c\u003e j)) \u003d\u003e (j in set (inds s))))))","type invariant satisfiable obligation:(exists s:Stage \u0026 (forall i in set (inds s), j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e ((((s(i).count) \u003e\u003d (s(j).count)) and (i \u003c\u003e j)) \u003d\u003e ((s(i).name) \u003c\u003e (s(j).name))))))","type invariant satisfiable obligation:(exists v:Value \u0026 (v \u003e\u003d 0))","type invariant satisfiable obligation:(exists candidate:Candidate \u0026 ((forall ov in set (dom (candidate.original_votes)) \u0026 (((ov :\u003e {1}) \u003d {(candidate.name) |-\u003e 1}) and (({(candidate.name)} \u003c: ov) \u003d {(candidate.name) |-\u003e 1}))) and (forall sub_parcel in set (elems (candidate.transferred_votes)) \u0026 (forall tv in set (dom (sub_parcel.votes)) \u0026 ((candidate.name) in set (dom tv))))))","let be st existence obligation:(forall s:set of ((nat * Parcel)) \u0026 ((not (s \u003d {})) \u003d\u003e (exists mk_(m, pa) in set s \u0026 true)))","type compatibility obligation:(forall votes:Parcel, names:set of (Candidate_names) \u0026 (forall name in set names \u0026 inv_Candidate(mk_Candidate(name, vote_res(votes, {v | v in set (dom votes) \u0026 ((v :\u003e {1}) \u003d {name |-\u003e 1})}), []))))","legal sequence application obligation:(forall s:seq of (Score) \u0026 ((s \u003c\u003e []) \u003d\u003e ((len s) in set (inds s))))","legal function application obligation:(forall quota:real, stage:Stage \u0026 (((len stage) \u003e 1) \u003d\u003e pre_stage_bk(stage)))","legal sequence application obligation:(forall quota:real, stage:Stage \u0026 (((len stage) \u003e 1) \u003d\u003e (((len stage) - 1) in set (inds stage))))","legal sequence application obligation:(forall quota:real, stage:Stage \u0026 (((len stage) \u003e 1) \u003d\u003e let lowest_value:real \u003d (stage_bk(stage).count), second_lowest_value:real \u003d (stage(((len stage) - 1)).count) in (forall i in set (inds stage) \u0026 (((stage(i).count) \u003e quota) \u003d\u003e (i in set (inds stage))))))","legal sequence application obligation:(forall quota:real, stage:Stage \u0026 (((len stage) \u003e 1) \u003d\u003e let lowest_value:real \u003d (stage_bk(stage).count), second_lowest_value:real \u003d (stage(((len stage) - 1)).count) in (forall i in set (inds stage) \u0026 (i in set (inds stage)))))","non-empty sequence obligation:(forall s:seq of (real) \u0026 ((not (s \u003d [])) \u003d\u003e (s \u003c\u003e [])))","non-empty sequence obligation:(forall s:seq of (real) \u0026 ((not (s \u003d [])) \u003d\u003e (s \u003c\u003e [])))","unique existence binding obligation:(forall stage:Stage, name:Candidate_names, leaders:set of (Candidate_names) \u0026 (exists1 c in set (elems stage) \u0026 ((c.name) \u003d name)))","non-empty sequence obligation:(forall name:Candidate_names, all_stages:seq of (Stage) \u0026 (all_stages \u003c\u003e []))","non-empty sequence obligation:(forall name:Candidate_names, all_stages:seq of (Stage) \u0026 (forall score in set (elems (hd all_stages)) \u0026 (all_stages \u003c\u003e [])))","non-empty sequence obligation:(forall name:Candidate_names, all_stages:seq of (Stage) \u0026 (forall score in set (elems (hd all_stages)) \u0026 ((hd all_stages) \u003c\u003e [])))","legal sequence application obligation:(forall name:Candidate_names, all_stages:seq of (Stage) \u0026 let leaders:set of (Candidate_names) \u003d {(score.name) | score in set (elems (hd all_stages)) \u0026 ((score.count) \u003d ((hd (hd all_stages)).count))} in (forall i in set (inds all_stages) \u0026 (i in set (inds all_stages))))","legal sequence application obligation:(forall name:Candidate_names, all_stages:seq of (Stage) \u0026 let leaders:set of (Candidate_names) \u003d {(score.name) | score in set (elems (hd all_stages)) \u0026 ((score.count) \u003d ((hd (hd all_stages)).count))} in (forall i in set (inds all_stages) \u0026 (sole_leader(all_stages(i), name, leaders) \u003d\u003e (forall j in set {(i + 1), ... ,(len all_stages)}, other_leader in set leaders \u0026 (j in set (inds all_stages))))))","comprehension map injectivity obligation:(forall val:Value, parcel:Parcel, discontinuing:Candidate, continuing_candidates:set of (Candidate) \u0026 let names:set of (Candidate_names) \u003d {(candidate.name) | candidate in set continuing_candidates} in (forall m1, m2 in set {{n |-\u003e mk_Sub_parcel({v |-\u003e parcel(v) | v in set (dom parcel) \u0026 next_preference(n, v, names)}, val)} | n in set names} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4))))))","comprehension map injectivity obligation:(forall val:Value, parcel:Parcel, discontinuing:Candidate, continuing_candidates:set of (Candidate) \u0026 let names:set of (Candidate_names) \u003d {(candidate.name) | candidate in set continuing_candidates} in (forall n in set names \u0026 (forall m1, m2 in set {{v |-\u003e parcel(v)} | v in set (dom parcel) \u0026 next_preference(n, v, names)} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))))","legal map application obligation:(forall val:Value, parcel:Parcel, discontinuing:Candidate, continuing_candidates:set of (Candidate) \u0026 let names:set of (Candidate_names) \u003d {(candidate.name) | candidate in set continuing_candidates} in (forall n in set names \u0026 (forall v in set (dom parcel) \u0026 (next_preference(n, v, names) \u003d\u003e (v in set (dom parcel))))))","comprehension map injectivity obligation:(forall val:Value, parcel:Parcel, discontinuing:Candidate, continuing_candidates:set of (Candidate) \u0026 let names:set of (Candidate_names) \u003d {(candidate.name) | candidate in set continuing_candidates} in let sub_parcel_map:map (Candidate_names) to (Sub_parcel) \u003d {n |-\u003e mk_Sub_parcel({v |-\u003e parcel(v) | v in set (dom parcel) \u0026 next_preference(n, v, names)}, val) | n in set names} in (forall m1, m2 in set {{n |-\u003e sub_parcel_map(n)} | n in set (dom sub_parcel_map) \u0026 ((sub_parcel_map(n).votes) \u003c\u003e {|-\u003e})} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4))))))","legal map application obligation:(forall val:Value, parcel:Parcel, discontinuing:Candidate, continuing_candidates:set of (Candidate) \u0026 let names:set of (Candidate_names) \u003d {(candidate.name) | candidate in set continuing_candidates} in let sub_parcel_map:map (Candidate_names) to (Sub_parcel) \u003d {n |-\u003e mk_Sub_parcel({v |-\u003e parcel(v) | v in set (dom parcel) \u0026 next_preference(n, v, names)}, val) | n in set names} in (forall n in set (dom sub_parcel_map) \u0026 (((sub_parcel_map(n).votes) \u003c\u003e {|-\u003e}) \u003d\u003e (n in set (dom sub_parcel_map)))))","legal map application obligation:(forall val:Value, parcel:Parcel, discontinuing:Candidate, continuing_candidates:set of (Candidate) \u0026 let names:set of (Candidate_names) \u003d {(candidate.name) | candidate in set continuing_candidates} in let sub_parcel_map:map (Candidate_names) to (Sub_parcel) \u003d {n |-\u003e mk_Sub_parcel({v |-\u003e parcel(v) | v in set (dom parcel) \u0026 next_preference(n, v, names)}, val) | n in set names} in (forall n in set (dom sub_parcel_map) \u0026 (n in set (dom sub_parcel_map))))","type compatibility obligation:(forall val:Value, parcel:Parcel, discontinuing:Candidate, continuing_candidates:set of (Candidate) \u0026 let names:set of (Candidate_names) \u003d {(candidate.name) | candidate in set continuing_candidates} in let sub_parcel_map:map (Candidate_names) to (Sub_parcel) \u003d {n |-\u003e mk_Sub_parcel({v |-\u003e parcel(v) | v in set (dom parcel) \u0026 next_preference(n, v, names)}, val) | n in set names} in let non_empty_sub_parcel_map:map (Candidate_names) to (Sub_parcel) \u003d {n |-\u003e sub_parcel_map(n) | n in set (dom sub_parcel_map) \u0026 ((sub_parcel_map(n).votes) \u003c\u003e {|-\u003e})} in inv_Value(1.0))","legal map application obligation:(forall name:Candidate_names, vote:Voting_paper, continuing:set of (Candidate_names) \u0026 ((name in set (dom vote)) \u003d\u003e (forall i in set (rng vote) \u0026 (name in set (dom vote)))))","type compatibility obligation:(forall surplus:real, old_value:Value, old_votes:Parcel, disc:Candidate, cont_cands:set of (Candidate) \u0026 inv_Value(1.0))","type compatibility obligation:(forall surplus:real, old_value:Value, old_votes:Parcel, disc:Candidate, cont_cands:set of (Candidate) \u0026 let new_sub_parcels:Sub_parcel_bundle \u003d construct_sub_parcels(1.0, old_votes, disc, cont_cands) in let total_no_of_trans_votes:int \u003d (size(old_votes) - size(((new_sub_parcels.non_transferable).votes))) in let total_val_trans_votes:real \u003d (total_no_of_trans_votes * old_value) in inv_Value(total_val_trans_votes))","type compatibility obligation:(forall surplus:real, old_value:Value, old_votes:Parcel, disc:Candidate, cont_cands:set of (Candidate) \u0026 let new_sub_parcels:Sub_parcel_bundle \u003d construct_sub_parcels(1.0, old_votes, disc, cont_cands) in let total_no_of_trans_votes:int \u003d (size(old_votes) - size(((new_sub_parcels.non_transferable).votes))) in let total_val_trans_votes:real \u003d (total_no_of_trans_votes * old_value) in (total_no_of_trans_votes \u003e\u003d 0))","comprehension map injectivity obligation:(forall surplus:real, old_value:Value, old_votes:Parcel, disc:Candidate, cont_cands:set of (Candidate) \u0026 let new_sub_parcels:Sub_parcel_bundle \u003d construct_sub_parcels(1.0, old_votes, disc, cont_cands) in let total_no_of_trans_votes:int \u003d (size(old_votes) - size(((new_sub_parcels.non_transferable).votes))) in let total_val_trans_votes:real \u003d (total_no_of_trans_votes * old_value) in let transf_val:Value \u003d calc_transf_value(surplus, total_val_trans_votes, old_value, total_no_of_trans_votes) in (forall m1, m2 in set {{n |-\u003e mk_Sub_parcel(((new_sub_parcels.sub_parcels)(n).votes), transf_val)} | n in set (dom (new_sub_parcels.sub_parcels))} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4))))))","legal map application obligation:(forall surplus:real, old_value:Value, old_votes:Parcel, disc:Candidate, cont_cands:set of (Candidate) \u0026 let new_sub_parcels:Sub_parcel_bundle \u003d construct_sub_parcels(1.0, old_votes, disc, cont_cands) in let total_no_of_trans_votes:int \u003d (size(old_votes) - size(((new_sub_parcels.non_transferable).votes))) in let total_val_trans_votes:real \u003d (total_no_of_trans_votes * old_value) in let transf_val:Value \u003d calc_transf_value(surplus, total_val_trans_votes, old_value, total_no_of_trans_votes) in (forall n in set (dom (new_sub_parcels.sub_parcels)) \u0026 (n in set (dom (new_sub_parcels.sub_parcels)))))","type compatibility obligation:(forall surplus:real, old_value:Value, old_votes:Parcel, disc:Candidate, cont_cands:set of (Candidate) \u0026 let new_sub_parcels:Sub_parcel_bundle \u003d construct_sub_parcels(1.0, old_votes, disc, cont_cands) in let total_no_of_trans_votes:int \u003d (size(old_votes) - size(((new_sub_parcels.non_transferable).votes))) in let total_val_trans_votes:real \u003d (total_no_of_trans_votes * old_value) in let transf_val:Value \u003d calc_transf_value(surplus, total_val_trans_votes, old_value, total_no_of_trans_votes) in inv_Value(total_val_trans_votes))","type compatibility obligation:(forall surplus:real, old_value:Value, old_votes:Parcel, disc:Candidate, cont_cands:set of (Candidate) \u0026 let new_sub_parcels:Sub_parcel_bundle \u003d construct_sub_parcels(1.0, old_votes, disc, cont_cands) in let total_no_of_trans_votes:int \u003d (size(old_votes) - size(((new_sub_parcels.non_transferable).votes))) in let total_val_trans_votes:real \u003d (total_no_of_trans_votes * old_value) in let transf_val:Value \u003d calc_transf_value(surplus, total_val_trans_votes, old_value, total_no_of_trans_votes) in (total_no_of_trans_votes \u003e\u003d 0))","type compatibility obligation:(forall surplus:real, old_value:Value, old_votes:Parcel, disc:Candidate, cont_cands:set of (Candidate) \u0026 let new_sub_parcels:Sub_parcel_bundle \u003d construct_sub_parcels(1.0, old_votes, disc, cont_cands) in let total_no_of_trans_votes:int \u003d (size(old_votes) - size(((new_sub_parcels.non_transferable).votes))) in let total_val_trans_votes:real \u003d (total_no_of_trans_votes * old_value) in let transf_val:Value \u003d calc_transf_value(surplus, total_val_trans_votes, old_value, total_no_of_trans_votes) in inv_Value(total_val_trans_votes))","non-zero obligation:(forall surplus:real, total_value:Value, old_value:Value, total_no:nat \u0026 ((surplus \u003c total_value) \u003d\u003e (total_no \u003c\u003e 0)))","type compatibility obligation:(forall surplus:real, total_value:Value, old_value:Value, total_no:nat \u0026 inv_Value((if (surplus \u003c total_value)\nthen ((floor ((100 * surplus) / total_no)) / 100)\nelse old_value)))","non-zero obligation:(forall surplus:real, total_value:Value, total_number:nat, old_value:Value \u0026 ((surplus \u003c total_value) \u003d\u003e (total_number \u003c\u003e 0)))","non-zero obligation:(forall surplus:real, total_value:Value, total_number:nat, old_value:Value \u0026 ((surplus \u003c total_value) \u003d\u003e (total_value \u003c\u003e 0)))","type compatibility obligation:(forall surplus:real, total_value:Value \u0026 inv_Value((if (surplus \u003e total_value)\nthen (surplus - total_value)\nelse 0)))","legal map application obligation:(forall previous_collection:Candset, bundle:Sub_parcel_bundle \u0026 (((dom (bundle.sub_parcels)) subset {(candidate.name) | candidate in set previous_collection}) \u003d\u003e (forall candidate in set previous_collection, n in set (dom (bundle.sub_parcels)) \u0026 (((candidate.name) \u003d n) \u003d\u003e (n in set (dom (bundle.sub_parcels)))))))","let be st existence obligation:(forall sta:Stage \u0026 ((not ([] \u003d sta)) \u003d\u003e ((not (exists [e]:Stage \u0026 ([e] \u003d sta))) \u003d\u003e (exists sta1 ^ sta2 in set {sta} \u0026 ((abs ((len sta1) - (len sta2))) \u003c 2)))))","non-empty sequence obligation:(forall sta1:Stage, sta2:Stage \u0026 ((not (exists mk_([], sta):(Stage * Stage) \u0026 (mk_([], sta) \u003d mk_(sta1, sta2)))) \u003d\u003e ((not (exists mk_(sta, []):(Stage * Stage) \u0026 (mk_(sta, []) \u003d mk_(sta1, sta2)))) \u003d\u003e (sta1 \u003c\u003e []))))","non-empty sequence obligation:(forall sta1:Stage, sta2:Stage \u0026 ((not (exists mk_([], sta):(Stage * Stage) \u0026 (mk_([], sta) \u003d mk_(sta1, sta2)))) \u003d\u003e ((not (exists mk_(sta, []):(Stage * Stage) \u0026 (mk_(sta, []) \u003d mk_(sta1, sta2)))) \u003d\u003e (sta2 \u003c\u003e []))))","non-empty sequence obligation:(forall sta1:Stage, sta2:Stage \u0026 ((not (exists mk_([], sta):(Stage * Stage) \u0026 (mk_([], sta) \u003d mk_(sta1, sta2)))) \u003d\u003e ((not (exists mk_(sta, []):(Stage * Stage) \u0026 (mk_(sta, []) \u003d mk_(sta1, sta2)))) \u003d\u003e ((((hd sta1).count) \u003e\u003d ((hd sta2).count)) \u003d\u003e (sta1 \u003c\u003e [])))))","non-empty sequence obligation:(forall sta1:Stage, sta2:Stage \u0026 ((not (exists mk_([], sta):(Stage * Stage) \u0026 (mk_([], sta) \u003d mk_(sta1, sta2)))) \u003d\u003e ((not (exists mk_(sta, []):(Stage * Stage) \u0026 (mk_(sta, []) \u003d mk_(sta1, sta2)))) \u003d\u003e ((((hd sta1).count) \u003e\u003d ((hd sta2).count)) \u003d\u003e (sta1 \u003c\u003e [])))))","non-empty sequence obligation:(forall sta1:Stage, sta2:Stage \u0026 ((not (exists mk_([], sta):(Stage * Stage) \u0026 (mk_([], sta) \u003d mk_(sta1, sta2)))) \u003d\u003e ((not (exists mk_(sta, []):(Stage * Stage) \u0026 (mk_(sta, []) \u003d mk_(sta1, sta2)))) \u003d\u003e ((not (((hd sta1).count) \u003e\u003d ((hd sta2).count))) \u003d\u003e (sta2 \u003c\u003e [])))))","non-empty sequence obligation:(forall sta1:Stage, sta2:Stage \u0026 ((not (exists mk_([], sta):(Stage * Stage) \u0026 (mk_([], sta) \u003d mk_(sta1, sta2)))) \u003d\u003e ((not (exists mk_(sta, []):(Stage * Stage) \u0026 (mk_(sta, []) \u003d mk_(sta1, sta2)))) \u003d\u003e ((not (((hd sta1).count) \u003e\u003d ((hd sta2).count))) \u003d\u003e (sta2 \u003c\u003e [])))))","type compatibility obligation:(forall sta1:Stage, sta2:Stage \u0026 inv_Stage((cases mk_(sta1, sta2) :\nmk_([], sta) -\u003e sta,\nmk_(sta, []) -\u003e sta\nothers (if (((hd sta1).count) \u003e\u003d ((hd sta2).count))\nthen ([(hd sta1)] ^ score_merge((tl sta1), sta2))\nelse ([(hd sta2)] ^ score_merge(sta1, (tl sta2))))\n end)))","let be st existence obligation:(forall s:set of (Score) \u0026 ((not (s \u003d {})) \u003d\u003e (exists e in set s \u0026 true)))","type compatibility obligation:(forall s:set of (Score) \u0026 inv_Stage((if (s \u003d {})\nthen []\nelse let e in set s in ([e] ^ set_seq((s \\ {e}))))))","legal map application obligation:(forall old_stage:Stage, discontinuing:Candidate_names, bundle:Sub_parcel_bundle \u0026 let cands_with_more_votes:set of (Candidate_names) \u003d (dom (bundle.sub_parcels)) in (forall mk_Score(name, old_count) in set (elems old_stage) \u0026 ((name in set cands_with_more_votes) \u003d\u003e (name in set (dom (bundle.sub_parcels))))))","legal map application obligation:(forall old_stage:Stage, discontinuing:Candidate_names, bundle:Sub_parcel_bundle \u0026 let cands_with_more_votes:set of (Candidate_names) \u003d (dom (bundle.sub_parcels)) in (forall mk_Score(name, old_count) in set (elems old_stage) \u0026 ((name in set cands_with_more_votes) \u003d\u003e (name in set (dom (bundle.sub_parcels))))))","non-empty sequence obligation:(forall stages:seq of (Stage), quota:real \u0026 (stages \u003c\u003e []))","non-empty sequence obligation:(forall stages:seq of (Stage), quota:real \u0026 ((hd stages) \u003c\u003e []))","legal function application obligation:(forall stages:seq of (Stage), quota:real \u0026 ((((hd (hd stages)).count) \u003e\u003d quota) \u003d\u003e pre_defer_transfer_of_surplus(quota, (hd stages))))","non-empty sequence obligation:(forall stages:seq of (Stage), quota:real \u0026 ((((hd (hd stages)).count) \u003e\u003d quota) \u003d\u003e (stages \u003c\u003e [])))","legal function application obligation:(forall name:Candidate_names, all_stages:seq1 of (Stage) \u0026 pre_stage_bk((hd all_stages)))","legal sequence application obligation:(forall name:Candidate_names, all_stages:seq1 of (Stage) \u0026 let trailing_count:real \u003d (stage_bk((hd all_stages)).count) in let lowest:set of (Candidate_names) \u003d {(score.name) | score in set (elems (hd all_stages)) \u0026 ((score.count) \u003d trailing_count)} in (forall i in set (inds all_stages) \u0026 (i in set (inds all_stages))))","legal sequence application obligation:(forall name:Candidate_names, all_stages:seq1 of (Stage) \u0026 let trailing_count:real \u003d (stage_bk((hd all_stages)).count) in let lowest:set of (Candidate_names) \u003d {(score.name) | score in set (elems (hd all_stages)) \u0026 ((score.count) \u003d trailing_count)} in (forall i in set (inds all_stages) \u0026 (sole_trailer(all_stages(i), name, lowest) \u003d\u003e (forall j in set {(i + 1), ... ,(len all_stages)}, other in set lowest \u0026 (j in set (inds all_stages))))))","unique existence binding obligation:(forall stage:Stage, name:Candidate_names, lowest:set of (Candidate_names) \u0026 (exists1 c in set (elems stage) \u0026 ((c.name) \u003d name)))","type compatibility obligation:(forall cands:set of (Candidate_names) \u0026 ((Number_of_vacancies - (card cands)) \u003e\u003d 0))","non-empty sequence obligation:(forall continuing:set of (Candidate), stages:seq of (Stage), quota:real \u0026 (stages \u003c\u003e []))","legal map application obligation:(forall paper:Voting_paper, discontinuing:Candidate_names, continuing_names:set of (Candidate_names) \u0026 ((not (((dom (paper :-\u003e {1})) inter continuing_names) \u003d {})) \u003d\u003e (discontinuing in set (dom paper))))","legal function application obligation:(forall paper:Voting_paper, discontinuing:Candidate_names, continuing_names:set of (Candidate_names) \u0026 ((not (((dom (paper :-\u003e {1})) inter continuing_names) \u003d {})) \u003d\u003e let s:set of (nat1) \u003d (rng (paper :-\u003e {1, ... ,paper(discontinuing)})) in ((not (s \u003d {})) \u003d\u003e pre_min(s))))","let be st existence obligation:(forall s:set of (real) \u0026 ((s \u003c\u003e {}) \u003d\u003e (exists m in set s \u0026 true)))","legal function application obligation:(forall s:set of (real) \u0026 ((s \u003c\u003e {}) \u003d\u003e (forall m in set s \u0026 ((not ((card s) \u003d 1)) \u003d\u003e pre_min((s \\ {m}))))))","legal sequence application obligation:(forall continuing:set of (Candidate), stages:seq of (Stage), quota:real \u0026 let continuing_names:set of (Candidate_names) \u003d {(c.name) | c in set continuing} in (forall i in set (inds (hd stages)) \u0026 ((((hd stages)(i).name) in set continuing_names) \u003d\u003e (i in set (inds (hd stages))))))","non-empty sequence obligation:(forall continuing:set of (Candidate), stages:seq of (Stage), quota:real \u0026 let continuing_names:set of (Candidate_names) \u003d {(c.name) | c in set continuing} in (forall i in set (inds (hd stages)) \u0026 ((((hd stages)(i).name) in set continuing_names) \u003d\u003e (stages \u003c\u003e []))))","non-empty sequence obligation:(forall continuing:set of (Candidate), stages:seq of (Stage), quota:real \u0026 let continuing_names:set of (Candidate_names) \u003d {(c.name) | c in set continuing} in (stages \u003c\u003e []))","legal sequence application obligation:(forall continuing:set of (Candidate), stages:seq of (Stage), quota:real \u0026 let continuing_names:set of (Candidate_names) \u003d {(c.name) | c in set continuing} in (forall i in set (inds (hd stages)) \u0026 (i in set (inds (hd stages)))))","non-empty sequence obligation:(forall continuing:set of (Candidate), stages:seq of (Stage), quota:real \u0026 let continuing_names:set of (Candidate_names) \u003d {(c.name) | c in set continuing} in (forall i in set (inds (hd stages)) \u0026 (stages \u003c\u003e [])))","legal sequence application obligation:(forall continuing:set of (Candidate), stages:seq of (Stage), quota:real \u0026 let continuing_names:set of (Candidate_names) \u003d {(c.name) | c in set continuing} in (forall i in set (inds (hd stages)) \u0026 ((((hd stages)(i).count) \u003e quota) \u003d\u003e (i in set (inds (hd stages))))))","non-empty sequence obligation:(forall continuing:set of (Candidate), stages:seq of (Stage), quota:real \u0026 let continuing_names:set of (Candidate_names) \u003d {(c.name) | c in set continuing} in (forall i in set (inds (hd stages)) \u0026 ((((hd stages)(i).count) \u003e quota) \u003d\u003e (stages \u003c\u003e []))))","non-empty sequence obligation:(forall continuing:set of (Candidate), stages:seq of (Stage), quota:real \u0026 let continuing_names:set of (Candidate_names) \u003d {(c.name) | c in set continuing} in (stages \u003c\u003e []))","legal sequence application obligation:(forall continuing:set of (Candidate), stages:seq of (Stage), quota:real \u0026 let continuing_names:set of (Candidate_names) \u003d {(c.name) | c in set continuing} in (forall i in set (inds (hd stages)) \u0026 (i in set (inds (hd stages)))))","non-empty sequence obligation:(forall continuing:set of (Candidate), stages:seq of (Stage), quota:real \u0026 let continuing_names:set of (Candidate_names) \u003d {(c.name) | c in set continuing} in (forall i in set (inds (hd stages)) \u0026 (stages \u003c\u003e [])))","legal sequence application obligation:(forall continuing:set of (Candidate), stages:seq of (Stage), quota:real \u0026 let continuing_names:set of (Candidate_names) \u003d {(c.name) | c in set continuing} in let continuing_scores:seq of (Score) \u003d [(hd stages)(i) | i in set (inds (hd stages)) \u0026 (((hd stages)(i).name) in set continuing_names)], surplus_scores:seq of (Score) \u003d [(hd stages)(i) | i in set (inds (hd stages)) \u0026 (((hd stages)(i).count) \u003e quota)] in (forall i in set (inds continuing_scores) \u0026 (i in set (inds continuing_scores))))","legal sequence application obligation:(forall continuing:set of (Candidate), stages:seq of (Stage), quota:real \u0026 let continuing_names:set of (Candidate_names) \u003d {(c.name) | c in set continuing} in let continuing_scores:seq of (Score) \u003d [(hd stages)(i) | i in set (inds (hd stages)) \u0026 (((hd stages)(i).name) in set continuing_names)], surplus_scores:seq of (Score) \u003d [(hd stages)(i) | i in set (inds (hd stages)) \u0026 (((hd stages)(i).count) \u003e quota)] in (forall i in set (inds continuing_scores) \u0026 (forall j in set ((inds continuing_scores) \\ {i}) \u0026 (j in set (inds continuing_scores)))))","legal sequence application obligation:(forall continuing:set of (Candidate), stages:seq of (Stage), quota:real \u0026 let continuing_names:set of (Candidate_names) \u003d {(c.name) | c in set continuing} in let continuing_scores:seq of (Score) \u003d [(hd stages)(i) | i in set (inds (hd stages)) \u0026 (((hd stages)(i).name) in set continuing_names)], surplus_scores:seq of (Score) \u003d [(hd stages)(i) | i in set (inds (hd stages)) \u0026 (((hd stages)(i).count) \u003e quota)] in (forall i in set (inds continuing_scores) \u0026 (forall j in set (inds surplus_scores) \u0026 (j in set (inds surplus_scores)))))","legal sequence application obligation:(forall stages:seq of (Stage), quota:real, record:seq of (Record_entry), elected:set of (Candidate_names) \u0026 (forall i:nat1 \u0026 ((i + 1) in set (inds stages))))","legal sequence application obligation:(forall stages:seq of (Stage), quota:real, record:seq of (Record_entry), elected:set of (Candidate_names) \u0026 (forall i:nat1 \u0026 (i in set (inds stages))))","unique existence binding obligation:(forall stages:seq of (Stage), quota:real, record:seq of (Record_entry), elected:set of (Candidate_names) \u0026 (forall i:nat1 \u0026 (((len stages((i + 1))) \u003e (len stages(i))) \u003d\u003e (exists1 ex in set Cand_names \u0026 (ex in set {(sc.name) | sc in set (elems stages((i + 1))) \u0026 (forall osc in set (elems stages(i)) \u0026 ((osc.name) \u003c\u003e (sc.name)))})))))","legal sequence application obligation:(forall stages:seq of (Stage), quota:real, record:seq of (Record_entry), elected:set of (Candidate_names) \u0026 (forall i:nat1 \u0026 (((len stages((i + 1))) \u003e (len stages(i))) \u003d\u003e (forall ex in set Cand_names \u0026 ((i + 1) in set (inds stages))))))","legal sequence application obligation:(forall stages:seq of (Stage), quota:real, record:seq of (Record_entry), elected:set of (Candidate_names) \u0026 (forall i:nat1 \u0026 (((len stages((i + 1))) \u003e (len stages(i))) \u003d\u003e (forall ex in set Cand_names \u0026 (forall sc in set (elems stages((i + 1))) \u0026 (i in set (inds stages)))))))","legal sequence application obligation:(forall stages:seq of (Stage), quota:real, record:seq of (Record_entry), elected:set of (Candidate_names) \u0026 (forall i:nat1 \u0026 (((len stages((i + 1))) \u003e (len stages(i))) \u003d\u003e let excluded:(\u003cAdam\u003e | \u003cBill\u003e | \u003cCharlie\u003e | \u003cDonald\u003e | \u003cEdward\u003e | \u003cFrank\u003e | \u003cGeorge\u003e | \u003cHarry\u003e | \u003cIan\u003e | \u003cJohn\u003e) \u003d (iota ex in set Cand_names \u0026 (ex in set {(sc.name) | sc in set (elems stages((i + 1))) \u0026 (forall osc in set (elems stages(i)) \u0026 ((osc.name) \u003c\u003e (sc.name)))})) in ((i + 1) in set (inds record)))))","unique existence binding obligation:(forall stages:seq of (Stage), quota:real, record:seq of (Record_entry), elected:set of (Candidate_names) \u0026 (forall i:nat1 \u0026 ((not ((len stages((i + 1))) \u003e (len stages(i)))) \u003d\u003e (exists1 tf in set Cand_names \u0026 (tf in set {(sc.name) | sc in set (elems stages((i + 1))) \u0026 ((mk_Score((sc.name), quota) in set (elems stages(i))) and ((sc.count) \u003e quota))})))))","legal sequence application obligation:(forall stages:seq of (Stage), quota:real, record:seq of (Record_entry), elected:set of (Candidate_names) \u0026 (forall i:nat1 \u0026 ((not ((len stages((i + 1))) \u003e (len stages(i)))) \u003d\u003e (forall tf in set Cand_names \u0026 ((i + 1) in set (inds stages))))))","legal sequence application obligation:(forall stages:seq of (Stage), quota:real, record:seq of (Record_entry), elected:set of (Candidate_names) \u0026 (forall i:nat1 \u0026 ((not ((len stages((i + 1))) \u003e (len stages(i)))) \u003d\u003e (forall tf in set Cand_names \u0026 (forall sc in set (elems stages((i + 1))) \u0026 (i in set (inds stages)))))))","legal sequence application obligation:(forall stages:seq of (Stage), quota:real, record:seq of (Record_entry), elected:set of (Candidate_names) \u0026 (forall i:nat1 \u0026 ((not ((len stages((i + 1))) \u003e (len stages(i)))) \u003d\u003e let transferred:(\u003cAdam\u003e | \u003cBill\u003e | \u003cCharlie\u003e | \u003cDonald\u003e | \u003cEdward\u003e | \u003cFrank\u003e | \u003cGeorge\u003e | \u003cHarry\u003e | \u003cIan\u003e | \u003cJohn\u003e) \u003d (iota tf in set Cand_names \u0026 (tf in set {(sc.name) | sc in set (elems stages((i + 1))) \u0026 ((mk_Score((sc.name), quota) in set (elems stages(i))) and ((sc.count) \u003e quota))})) in ((i + 1) in set (inds record)))))","type compatibility obligation:(forall stages:seq of (Stage), quota:real, record:seq of (Record_entry), elected:set of (Candidate_names) \u0026 let result: (nat1 -\u003e Result)\n\tresult(i) \u003d\u003d\n(if ((len stages((i + 1))) \u003e (len stages(i)))\nthen let excluded:(\u003cAdam\u003e | \u003cBill\u003e | \u003cCharlie\u003e | \u003cDonald\u003e | \u003cEdward\u003e | \u003cFrank\u003e | \u003cGeorge\u003e | \u003cHarry\u003e | \u003cIan\u003e | \u003cJohn\u003e) \u003d (iota ex in set Cand_names \u0026 (ex in set {(sc.name) | sc in set (elems stages((i + 1))) \u0026 (forall osc in set (elems stages(i)) \u0026 ((osc.name) \u003c\u003e (sc.name)))})) in mk_Result((record((i + 1)).scores), nil, excluded)\nelse let transferred:(\u003cAdam\u003e | \u003cBill\u003e | \u003cCharlie\u003e | \u003cDonald\u003e | \u003cEdward\u003e | \u003cFrank\u003e | \u003cGeorge\u003e | \u003cHarry\u003e | \u003cIan\u003e | \u003cJohn\u003e) \u003d (iota tf in set Cand_names \u0026 (tf in set {(sc.name) | sc in set (elems stages((i + 1))) \u0026 ((mk_Score((sc.name), quota) in set (elems stages(i))) and ((sc.count) \u003e quota))})) in mk_Result((record((i + 1)).scores), transferred, nil)) in (forall j in set {1, ... ,((len record) - 1)} \u0026 (((len record) - j) \u003e 0)))","let be st existence obligation:(forall s:set of (Sub_parcel) \u0026 ((not (s \u003d {})) \u003d\u003e (exists e in set s \u0026 true)))","let be st existence obligation:(forall sps:seq of (Sub_parcel) \u0026 ((not ([] \u003d sps)) \u003d\u003e ((not (exists [e]:seq of (Sub_parcel) \u0026 ([e] \u003d sps))) \u003d\u003e (exists sps1 ^ sps2 in set {sps} \u0026 ((abs ((len sps1) - (len sps2))) \u003c 2)))))","non-empty sequence obligation:(forall sps1:seq of (Sub_parcel), sps2:seq of (Sub_parcel) \u0026 ((not (exists mk_([], sps):(seq of (Sub_parcel) * seq of (Sub_parcel)) \u0026 (mk_([], sps) \u003d mk_(sps1, sps2)))) \u003d\u003e ((not (exists mk_(sps, []):(seq of (Sub_parcel) * seq of (Sub_parcel)) \u0026 (mk_(sps, []) \u003d mk_(sps1, sps2)))) \u003d\u003e (sps1 \u003c\u003e []))))","non-empty sequence obligation:(forall sps1:seq of (Sub_parcel), sps2:seq of (Sub_parcel) \u0026 ((not (exists mk_([], sps):(seq of (Sub_parcel) * seq of (Sub_parcel)) \u0026 (mk_([], sps) \u003d mk_(sps1, sps2)))) \u003d\u003e ((not (exists mk_(sps, []):(seq of (Sub_parcel) * seq of (Sub_parcel)) \u0026 (mk_(sps, []) \u003d mk_(sps1, sps2)))) \u003d\u003e (sps2 \u003c\u003e []))))","non-empty sequence obligation:(forall sps1:seq of (Sub_parcel), sps2:seq of (Sub_parcel) \u0026 ((not (exists mk_([], sps):(seq of (Sub_parcel) * seq of (Sub_parcel)) \u0026 (mk_([], sps) \u003d mk_(sps1, sps2)))) \u003d\u003e ((not (exists mk_(sps, []):(seq of (Sub_parcel) * seq of (Sub_parcel)) \u0026 (mk_(sps, []) \u003d mk_(sps1, sps2)))) \u003d\u003e ((total_value((hd sps1)) \u003e\u003d total_value((hd sps2))) \u003d\u003e (sps1 \u003c\u003e [])))))","non-empty sequence obligation:(forall sps1:seq of (Sub_parcel), sps2:seq of (Sub_parcel) \u0026 ((not (exists mk_([], sps):(seq of (Sub_parcel) * seq of (Sub_parcel)) \u0026 (mk_([], sps) \u003d mk_(sps1, sps2)))) \u003d\u003e ((not (exists mk_(sps, []):(seq of (Sub_parcel) * seq of (Sub_parcel)) \u0026 (mk_(sps, []) \u003d mk_(sps1, sps2)))) \u003d\u003e ((total_value((hd sps1)) \u003e\u003d total_value((hd sps2))) \u003d\u003e (sps1 \u003c\u003e [])))))","non-empty sequence obligation:(forall sps1:seq of (Sub_parcel), sps2:seq of (Sub_parcel) \u0026 ((not (exists mk_([], sps):(seq of (Sub_parcel) * seq of (Sub_parcel)) \u0026 (mk_([], sps) \u003d mk_(sps1, sps2)))) \u003d\u003e ((not (exists mk_(sps, []):(seq of (Sub_parcel) * seq of (Sub_parcel)) \u0026 (mk_(sps, []) \u003d mk_(sps1, sps2)))) \u003d\u003e ((not (total_value((hd sps1)) \u003e\u003d total_value((hd sps2)))) \u003d\u003e (sps2 \u003c\u003e [])))))","non-empty sequence obligation:(forall sps1:seq of (Sub_parcel), sps2:seq of (Sub_parcel) \u0026 ((not (exists mk_([], sps):(seq of (Sub_parcel) * seq of (Sub_parcel)) \u0026 (mk_([], sps) \u003d mk_(sps1, sps2)))) \u003d\u003e ((not (exists mk_(sps, []):(seq of (Sub_parcel) * seq of (Sub_parcel)) \u0026 (mk_(sps, []) \u003d mk_(sps1, sps2)))) \u003d\u003e ((not (total_value((hd sps1)) \u003e\u003d total_value((hd sps2)))) \u003d\u003e (sps2 \u003c\u003e [])))))","non-empty sequence obligation:((stages \u003c\u003e []) \u003d\u003e (stages \u003c\u003e []))","non-empty sequence obligation:((stages \u003c\u003e []) \u003d\u003e (forall score in set (elems (hd stages)) \u0026 (stages \u003c\u003e [])))","non-empty sequence obligation:((stages \u003c\u003e []) \u003d\u003e (forall score in set (elems (hd stages)) \u0026 ((hd stages) \u003c\u003e [])))","unique existence binding obligation:((stages \u003c\u003e []) \u003d\u003e (exists1 name in set leaders \u0026 greatest_value_at_earliest_stage(name, stages)))","non-empty sequence obligation:((stages \u003c\u003e []) \u003d\u003e (stages \u003c\u003e []))","legal function application obligation:((stages \u003c\u003e []) \u003d\u003e (forall score in set (elems (hd stages)) \u0026 pre_stage_bk((hd stages))))","non-empty sequence obligation:((stages \u003c\u003e []) \u003d\u003e (forall score in set (elems (hd stages)) \u0026 (stages \u003c\u003e [])))","type compatibility obligation:((stages \u003c\u003e []) \u003d\u003e (forall n in set lowest \u0026 is_(stages, seq1 of (Stage))))","unique existence binding obligation:((stages \u003c\u003e []) \u003d\u003e (exists1 name in set lowest \u0026 trailing_candidate(name, stages)))","type compatibility obligation:((stages \u003c\u003e []) \u003d\u003e (forall name in set lowest \u0026 is_(stages, seq1 of (Stage))))","non-empty sequence obligation:(forall s:Candnset, oldstate:St \u0026 (next_choice \u003c\u003e []))","state invariant holds obligation:(forall s:Candnset, oldstate:St \u0026 let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","non-empty sequence obligation:(forall s:Candnset, oldstate:St \u0026 (next_choice \u003c\u003e []))","state invariant holds obligation:(forall votes:Parcel, oldstate:St \u0026 let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","state invariant holds obligation:(forall votes:Parcel, oldstate:St \u0026 let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","state invariant holds obligation:(forall votes:Parcel, oldstate:St \u0026 let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","state invariant holds obligation:(forall votes:Parcel, oldstate:St \u0026 let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","state invariant holds obligation:(forall votes:Parcel, oldstate:St \u0026 let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","state invariant holds obligation:(forall votes:Parcel, oldstate:St \u0026 let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","non-zero obligation:(forall votes:Parcel, oldstate:St \u0026 ((Number_of_vacancies + 1) \u003c\u003e 0))","state invariant holds obligation:(forall votes:Parcel, oldstate:St \u0026 let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","non-empty sequence obligation:(forall votes:Parcel, oldstate:St \u0026 ([build_first_stage(curr_cont)] \u003c\u003e []))","operation call obligation:(forall votes:Parcel, oldstate:St \u0026 (number_of_candidates_satisfying_quota(continuing, stages, quota) \u003c\u003d number_of_remaining_vacancies({(e.name) | e in set elected})))","state invariant holds obligation:let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name))))))","state invariant holds obligation:let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name))))))","type compatibility obligation:(forall ex_cand:Candidate, sub_parcels:seq of (Sub_parcel), oldstate:St \u0026 inv_Value(0.0))","non-empty sequence obligation:(forall ex_cand:Candidate, sub_parcels:seq of (Sub_parcel), oldstate:St \u0026 (stages \u003c\u003e []))","while loop termination obligation:NotYetImplemented","state invariant holds obligation:(forall ex_cand:Candidate, sub_parcels:seq of (Sub_parcel), oldstate:St \u0026 let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","state invariant holds obligation:(forall ex_cand:Candidate, sub_parcels:seq of (Sub_parcel), oldstate:St \u0026 let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","legal sequence application obligation:(forall ex_cand:Candidate, sub_parcels:seq of (Sub_parcel), oldstate:St \u0026 ((i + 1) in set (inds sub_parcels)))","legal sequence application obligation:(forall ex_cand:Candidate, sub_parcels:seq of (Sub_parcel), oldstate:St \u0026 ((i + 1) in set (inds sub_parcels)))","state invariant holds obligation:(forall ex_cand:Candidate, sub_parcels:seq of (Sub_parcel), oldstate:St \u0026 let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","legal sequence application obligation:(forall ex_cand:Candidate, sub_parcels:seq of (Sub_parcel), oldstate:St \u0026 ((i + 1) in set (inds sub_parcels)))","state invariant holds obligation:(forall ex_cand:Candidate, sub_parcels:seq of (Sub_parcel), oldstate:St \u0026 let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","legal function application obligation:(forall ex_cand:Candidate, sub_parcels:seq of (Sub_parcel), oldstate:St \u0026 pre_redistribute_parcels(new_candidates, bundle))","state invariant holds obligation:(forall ex_cand:Candidate, sub_parcels:seq of (Sub_parcel), oldstate:St \u0026 let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","state invariant holds obligation:(forall ex_cand:Candidate, sub_parcels:seq of (Sub_parcel), oldstate:St \u0026 let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","state invariant holds obligation:(forall ex_cand:Candidate, sub_parcels:seq of (Sub_parcel), oldstate:St \u0026 let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","state invariant holds obligation:(forall ex_cand:Candidate, sub_parcels:seq of (Sub_parcel), oldstate:St \u0026 let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","state invariant holds obligation:(forall ex_cand:Candidate, sub_parcels:seq of (Sub_parcel), oldstate:St \u0026 let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","state invariant holds obligation:(forall ex_cand:Candidate, sub_parcels:seq of (Sub_parcel), oldstate:St \u0026 let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","non-empty sequence obligation:(forall ex_cand:Candidate, sub_parcels:seq of (Sub_parcel), oldstate:St \u0026 (record \u003c\u003e []))","state invariant holds obligation:(forall ex_cand:Candidate, sub_parcels:seq of (Sub_parcel), oldstate:St \u0026 let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","legal sequence application obligation:(forall ex_cand:Candidate, sub_parcels:seq of (Sub_parcel), oldstate:St \u0026 (forall i in set (inds new_stage) \u0026 (((new_stage(i).name) \u003c\u003e (ex_cand.name)) \u003d\u003e (i in set (inds new_stage)))))","legal sequence application obligation:(forall ex_cand:Candidate, sub_parcels:seq of (Sub_parcel), oldstate:St \u0026 (forall i in set (inds new_stage) \u0026 (i in set (inds new_stage))))","type compatibility obligation:(forall ex_cand:Candidate, sub_parcels:seq of (Sub_parcel), oldstate:St \u0026 is_(([[new_stage(i) | i in set (inds new_stage) \u0026 ((new_stage(i).name) \u003c\u003e (ex_cand.name))]] ^ stages), seq of (Stage)))","unique existence binding obligation:(last_vacancy_fillable(continuing, stages, quota) \u003d\u003e (exists1 leader in set continuing \u0026 ((leader.name) \u003d ((hd stages)(Number_of_vacancies).name))))","legal sequence application obligation:(last_vacancy_fillable(continuing, stages, quota) \u003d\u003e (forall leader in set continuing \u0026 (Number_of_vacancies in set (inds (hd stages)))))","non-empty sequence obligation:(last_vacancy_fillable(continuing, stages, quota) \u003d\u003e (forall leader in set continuing \u0026 (stages \u003c\u003e [])))","state invariant holds obligation:(last_vacancy_fillable(continuing, stages, quota) \u003d\u003e let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","state invariant holds obligation:(last_vacancy_fillable(continuing, stages, quota) \u003d\u003e let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","unique existence binding obligation:(exists_non_deferable_surplus(stages, quota) \u003d\u003e (exists1 c in set elected \u0026 ((c.name) \u003d name)))","non-empty sequence obligation:(exists_non_deferable_surplus(stages, quota) \u003d\u003e (stages \u003c\u003e []))","non-empty sequence obligation:(exists_non_deferable_surplus(stages, quota) \u003d\u003e ((hd stages) \u003c\u003e []))","type compatibility obligation:(exists_non_deferable_surplus(stages, quota) \u003d\u003e (surplus_from_original_votes(candidate) \u003d\u003e inv_Value(1.0)))","non-empty sequence obligation:(exists_non_deferable_surplus(stages, quota) \u003d\u003e ((not surplus_from_original_votes(candidate)) \u003d\u003e ((candidate.transferred_votes) \u003c\u003e [])))","type compatibility obligation:(exists_non_deferable_surplus(stages, quota) \u003d\u003e inv_Stage(([mk_Score(name, quota)] ^ [(hd stages)(i) | i in set (inds (hd stages)) \u0026 (((hd stages)(i).name) \u003c\u003e name)])))","legal sequence application obligation:(exists_non_deferable_surplus(stages, quota) \u003d\u003e (forall i in set (inds (hd stages)) \u0026 ((((hd stages)(i).name) \u003c\u003e name) \u003d\u003e (i in set (inds (hd stages))))))","non-empty sequence obligation:(exists_non_deferable_surplus(stages, quota) \u003d\u003e (forall i in set (inds (hd stages)) \u0026 ((((hd stages)(i).name) \u003c\u003e name) \u003d\u003e (stages \u003c\u003e []))))","non-empty sequence obligation:(exists_non_deferable_surplus(stages, quota) \u003d\u003e (stages \u003c\u003e []))","legal sequence application obligation:(exists_non_deferable_surplus(stages, quota) \u003d\u003e (forall i in set (inds (hd stages)) \u0026 (i in set (inds (hd stages)))))","non-empty sequence obligation:(exists_non_deferable_surplus(stages, quota) \u003d\u003e (forall i in set (inds (hd stages)) \u0026 (stages \u003c\u003e [])))","legal function application obligation:(exists_non_deferable_surplus(stages, quota) \u003d\u003e pre_redistribute_parcels((continuing \\ {candidate}), sub_parcel_bundle))","state invariant holds obligation:(exists_non_deferable_surplus(stages, quota) \u003d\u003e let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","state invariant holds obligation:(exists_non_deferable_surplus(stages, quota) \u003d\u003e let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","non-empty sequence obligation:(exists_non_deferable_surplus(stages, quota) \u003d\u003e (record \u003c\u003e []))","state invariant holds obligation:(exists_non_deferable_surplus(stages, quota) \u003d\u003e let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","operation call obligation:(exists_non_deferable_surplus(stages, quota) \u003d\u003e (number_of_candidates_satisfying_quota(continuing, stages, quota) \u003c\u003d number_of_remaining_vacancies({(e.name) | e in set elected})))","unique existence binding obligation:(exists1 c in set continuing \u0026 ((c.name) \u003d name))","type compatibility obligation:inv_Value(1.0)","operation call obligation:(true \u003d\u003e (number_of_candidates_satisfying_quota(continuing, stages, quota) \u003c\u003d number_of_remaining_vacancies({(e.name) | e in set elected})))","operation call obligation:(true \u003d\u003e (true \u003d\u003e last_vacancy_fillable(continuing, stages, quota)))","operation call obligation:(true \u003d\u003e (true \u003d\u003e (true \u003d\u003e exists_non_deferable_surplus(stages, quota))))","while loop termination obligation:NotYetImplemented","non-empty sequence obligation:((number_of_candidates_satisfying_quota(continuing, stages, quota) \u003c\u003d number_of_remaining_vacancies({(e.name) | e in set elected})) \u003d\u003e (stages \u003c\u003e []))","state invariant holds obligation:((number_of_candidates_satisfying_quota(continuing, stages, quota) \u003c\u003d number_of_remaining_vacancies({(e.name) | e in set elected})) \u003d\u003e let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","state invariant holds obligation:((number_of_candidates_satisfying_quota(continuing, stages, quota) \u003c\u003d number_of_remaining_vacancies({(e.name) | e in set elected})) \u003d\u003e let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))"] \ No newline at end of file +["enumeration map injectivity obligation:(forall m1, m2 in set {{\u003cAdam\u003e |-\u003e 1}, {\u003cBill\u003e |-\u003e 2}, {\u003cCharlie\u003e |-\u003e 3}, {\u003cFrank\u003e |-\u003e 4}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","enumeration map injectivity obligation:(forall m1, m2 in set {{\u003cBill\u003e |-\u003e 1}, {\u003cAdam\u003e |-\u003e 2}, {\u003cCharlie\u003e |-\u003e 3}, {\u003cGeorge\u003e |-\u003e 4}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","enumeration map injectivity obligation:(forall m1, m2 in set {{\u003cAdam\u003e |-\u003e 1}, {\u003cCharlie\u003e |-\u003e 2}, {\u003cBill\u003e |-\u003e 3}, {\u003cHarry\u003e |-\u003e 4}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","enumeration map injectivity obligation:(forall m1, m2 in set {{\u003cBill\u003e |-\u003e 1}, {\u003cCharlie\u003e |-\u003e 2}, {\u003cAdam\u003e |-\u003e 3}, {\u003cIan\u003e |-\u003e 4}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","enumeration map injectivity obligation:(forall m1, m2 in set {{\u003cCharlie\u003e |-\u003e 1}, {\u003cAdam\u003e |-\u003e 2}, {\u003cBill\u003e |-\u003e 3}, {\u003cJohn\u003e |-\u003e 4}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","enumeration map injectivity obligation:(forall m1, m2 in set {{\u003cCharlie\u003e |-\u003e 1}, {\u003cBill\u003e |-\u003e 2}, {\u003cAdam\u003e |-\u003e 3}, {\u003cDonald\u003e |-\u003e 4}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","enumeration map injectivity obligation:(forall m1, m2 in set {{\u003cDonald\u003e |-\u003e 1}, {\u003cAdam\u003e |-\u003e 2}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","enumeration map injectivity obligation:(forall m1, m2 in set {{\u003cFrank\u003e |-\u003e 1}, {\u003cBill\u003e |-\u003e 2}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","enumeration map injectivity obligation:(forall m1, m2 in set {{\u003cGeorge\u003e |-\u003e 1}, {\u003cCharlie\u003e |-\u003e 2}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","enumeration map injectivity obligation:(forall m1, m2 in set {{\u003cHarry\u003e |-\u003e 1}, {\u003cBill\u003e |-\u003e 2}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","enumeration map injectivity obligation:(forall m1, m2 in set {{\u003cIan\u003e |-\u003e 1}, {\u003cAdam\u003e |-\u003e 2}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","enumeration map injectivity obligation:(forall m1, m2 in set {{\u003cJohn\u003e |-\u003e 1}, {\u003cCharlie\u003e |-\u003e 2}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","enumeration map injectivity obligation:(forall m1, m2 in set {{{\u003cAdam\u003e |-\u003e 1, \u003cBill\u003e |-\u003e 2, \u003cCharlie\u003e |-\u003e 3, \u003cFrank\u003e |-\u003e 4} |-\u003e 100000}, {{\u003cBill\u003e |-\u003e 1, \u003cAdam\u003e |-\u003e 2, \u003cCharlie\u003e |-\u003e 3, \u003cGeorge\u003e |-\u003e 4} |-\u003e 100000}, {{\u003cAdam\u003e |-\u003e 1, \u003cCharlie\u003e |-\u003e 2, \u003cBill\u003e |-\u003e 3, \u003cHarry\u003e |-\u003e 4} |-\u003e 100000}, {{\u003cBill\u003e |-\u003e 1, \u003cCharlie\u003e |-\u003e 2, \u003cAdam\u003e |-\u003e 3, \u003cIan\u003e |-\u003e 4} |-\u003e 100000}, {{\u003cCharlie\u003e |-\u003e 1, \u003cAdam\u003e |-\u003e 2, \u003cBill\u003e |-\u003e 3, \u003cJohn\u003e |-\u003e 4} |-\u003e 100000}, {{\u003cCharlie\u003e |-\u003e 1, \u003cBill\u003e |-\u003e 2, \u003cAdam\u003e |-\u003e 3, \u003cDonald\u003e |-\u003e 4} |-\u003e 100000}, {{\u003cDonald\u003e |-\u003e 1, \u003cAdam\u003e |-\u003e 2} |-\u003e 1000}, {{\u003cFrank\u003e |-\u003e 1, \u003cBill\u003e |-\u003e 2} |-\u003e 1000}, {{\u003cGeorge\u003e |-\u003e 1, \u003cCharlie\u003e |-\u003e 2} |-\u003e 1000}, {{\u003cHarry\u003e |-\u003e 1, \u003cBill\u003e |-\u003e 2} |-\u003e 1000}, {{\u003cIan\u003e |-\u003e 1, \u003cAdam\u003e |-\u003e 2} |-\u003e 1000}, {{\u003cJohn\u003e |-\u003e 1, \u003cCharlie\u003e |-\u003e 2} |-\u003e 1000}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))","legal map application obligation:(forall v:map (Candidate_names) to (nat1) \u0026 (forall name:Candidate_names \u0026 (name in set (dom v))))","type invariant satisfiable obligation:(exists v:Voting_paper \u0026 (exists1 name:Candidate_names \u0026 (v(name) \u003d 1)))","legal sequence application obligation:(forall s:seq of (Score) \u0026 (forall i in set (inds s), j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e (i in set (inds s)))))","legal sequence application obligation:(forall s:seq of (Score) \u0026 (forall i in set (inds s), j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e (j in set (inds s)))))","legal sequence application obligation:(forall s:seq of (Score) \u0026 (forall i in set (inds s), j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e ((((s(i).count) \u003e\u003d (s(j).count)) and (i \u003c\u003e j)) \u003d\u003e (i in set (inds s))))))","legal sequence application obligation:(forall s:seq of (Score) \u0026 (forall i in set (inds s), j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e ((((s(i).count) \u003e\u003d (s(j).count)) and (i \u003c\u003e j)) \u003d\u003e (j in set (inds s))))))","type invariant satisfiable obligation:(exists s:Stage \u0026 (forall i in set (inds s), j in set (inds s) \u0026 ((i \u003c j) \u003d\u003e ((((s(i).count) \u003e\u003d (s(j).count)) and (i \u003c\u003e j)) \u003d\u003e ((s(i).name) \u003c\u003e (s(j).name))))))","type invariant satisfiable obligation:(exists v:Value \u0026 (v \u003e\u003d 0))","type invariant satisfiable obligation:(exists candidate:Candidate \u0026 ((forall ov in set (dom (candidate.original_votes)) \u0026 (((ov :\u003e {1}) \u003d {(candidate.name) |-\u003e 1}) and (({(candidate.name)} \u003c: ov) \u003d {(candidate.name) |-\u003e 1}))) and (forall sub_parcel in set (elems (candidate.transferred_votes)) \u0026 (forall tv in set (dom (sub_parcel.votes)) \u0026 ((candidate.name) in set (dom tv))))))","let be st existence obligation:(forall s:set of ((nat * Parcel)) \u0026 ((not (s \u003d {})) \u003d\u003e (exists mk_(m, pa) in set s \u0026 true)))","type compatibility obligation:(forall votes:Parcel, names:set of (Candidate_names) \u0026 (forall name in set names \u0026 inv_Candidate(mk_Candidate(name, vote_res(votes, {v | v in set (dom votes) \u0026 ((v :\u003e {1}) \u003d {name |-\u003e 1})}), []))))","legal sequence application obligation:(forall s:seq of (Score) \u0026 ((s \u003c\u003e []) \u003d\u003e ((len s) in set (inds s))))","legal function application obligation:(forall quota:real, stage:Stage \u0026 (((len stage) \u003e 1) \u003d\u003e pre_stage_bk(stage)))","legal sequence application obligation:(forall quota:real, stage:Stage \u0026 (((len stage) \u003e 1) \u003d\u003e (((len stage) - 1) in set (inds stage))))","legal sequence application obligation:(forall quota:real, stage:Stage \u0026 (((len stage) \u003e 1) \u003d\u003e let lowest_value:real \u003d (stage_bk(stage).count), second_lowest_value:real \u003d (stage(((len stage) - 1)).count) in (forall i in set (inds stage) \u0026 (((stage(i).count) \u003e quota) \u003d\u003e (i in set (inds stage))))))","legal sequence application obligation:(forall quota:real, stage:Stage \u0026 (((len stage) \u003e 1) \u003d\u003e let lowest_value:real \u003d (stage_bk(stage).count), second_lowest_value:real \u003d (stage(((len stage) - 1)).count) in (forall i in set (inds stage) \u0026 (i in set (inds stage)))))","non-empty sequence obligation:(forall s:seq of (real) \u0026 ((not (s \u003d [])) \u003d\u003e (s \u003c\u003e [])))","non-empty sequence obligation:(forall s:seq of (real) \u0026 ((not (s \u003d [])) \u003d\u003e (s \u003c\u003e [])))","unique existence binding obligation:(forall stage:Stage, name:Candidate_names, leaders:set of (Candidate_names) \u0026 (exists1 c in set (elems stage) \u0026 ((c.name) \u003d name)))","non-empty sequence obligation:(forall name:Candidate_names, all_stages:seq of (Stage) \u0026 (all_stages \u003c\u003e []))","non-empty sequence obligation:(forall name:Candidate_names, all_stages:seq of (Stage) \u0026 (forall score in set (elems (hd all_stages)) \u0026 (all_stages \u003c\u003e [])))","non-empty sequence obligation:(forall name:Candidate_names, all_stages:seq of (Stage) \u0026 (forall score in set (elems (hd all_stages)) \u0026 ((hd all_stages) \u003c\u003e [])))","legal sequence application obligation:(forall name:Candidate_names, all_stages:seq of (Stage) \u0026 let leaders:set of (Candidate_names) \u003d {(score.name) | score in set (elems (hd all_stages)) \u0026 ((score.count) \u003d ((hd (hd all_stages)).count))} in (forall i in set (inds all_stages) \u0026 (i in set (inds all_stages))))","legal sequence application obligation:(forall name:Candidate_names, all_stages:seq of (Stage) \u0026 let leaders:set of (Candidate_names) \u003d {(score.name) | score in set (elems (hd all_stages)) \u0026 ((score.count) \u003d ((hd (hd all_stages)).count))} in (forall i in set (inds all_stages) \u0026 (sole_leader(all_stages(i), name, leaders) \u003d\u003e (forall j in set {(i + 1), ... ,(len all_stages)}, other_leader in set leaders \u0026 (j in set (inds all_stages))))))","comprehension map injectivity obligation:(forall val:Value, parcel:Parcel, discontinuing:Candidate, continuing_candidates:set of (Candidate) \u0026 let names:set of (Candidate_names) \u003d {(candidate.name) | candidate in set continuing_candidates} in (forall m1, m2 in set {{n |-\u003e mk_Sub_parcel({v |-\u003e parcel(v) | v in set (dom parcel) \u0026 next_preference(n, v, names)}, val)} | n in set names} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4))))))","comprehension map injectivity obligation:(forall val:Value, parcel:Parcel, discontinuing:Candidate, continuing_candidates:set of (Candidate) \u0026 let names:set of (Candidate_names) \u003d {(candidate.name) | candidate in set continuing_candidates} in (forall n in set names \u0026 (forall m1, m2 in set {{v |-\u003e parcel(v)} | v in set (dom parcel) \u0026 next_preference(n, v, names)} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4)))))))","legal map application obligation:(forall val:Value, parcel:Parcel, discontinuing:Candidate, continuing_candidates:set of (Candidate) \u0026 let names:set of (Candidate_names) \u003d {(candidate.name) | candidate in set continuing_candidates} in (forall n in set names \u0026 (forall v in set (dom parcel) \u0026 (next_preference(n, v, names) \u003d\u003e (v in set (dom parcel))))))","comprehension map injectivity obligation:(forall val:Value, parcel:Parcel, discontinuing:Candidate, continuing_candidates:set of (Candidate) \u0026 let names:set of (Candidate_names) \u003d {(candidate.name) | candidate in set continuing_candidates} in let sub_parcel_map:map (Candidate_names) to (Sub_parcel) \u003d {n |-\u003e mk_Sub_parcel({v |-\u003e parcel(v) | v in set (dom parcel) \u0026 next_preference(n, v, names)}, val) | n in set names} in (forall m1, m2 in set {{n |-\u003e sub_parcel_map(n)} | n in set (dom sub_parcel_map) \u0026 ((sub_parcel_map(n).votes) \u003c\u003e {|-\u003e})} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4))))))","legal map application obligation:(forall val:Value, parcel:Parcel, discontinuing:Candidate, continuing_candidates:set of (Candidate) \u0026 let names:set of (Candidate_names) \u003d {(candidate.name) | candidate in set continuing_candidates} in let sub_parcel_map:map (Candidate_names) to (Sub_parcel) \u003d {n |-\u003e mk_Sub_parcel({v |-\u003e parcel(v) | v in set (dom parcel) \u0026 next_preference(n, v, names)}, val) | n in set names} in (forall n in set (dom sub_parcel_map) \u0026 (((sub_parcel_map(n).votes) \u003c\u003e {|-\u003e}) \u003d\u003e (n in set (dom sub_parcel_map)))))","legal map application obligation:(forall val:Value, parcel:Parcel, discontinuing:Candidate, continuing_candidates:set of (Candidate) \u0026 let names:set of (Candidate_names) \u003d {(candidate.name) | candidate in set continuing_candidates} in let sub_parcel_map:map (Candidate_names) to (Sub_parcel) \u003d {n |-\u003e mk_Sub_parcel({v |-\u003e parcel(v) | v in set (dom parcel) \u0026 next_preference(n, v, names)}, val) | n in set names} in (forall n in set (dom sub_parcel_map) \u0026 (n in set (dom sub_parcel_map))))","type compatibility obligation:(forall val:Value, parcel:Parcel, discontinuing:Candidate, continuing_candidates:set of (Candidate) \u0026 let names:set of (Candidate_names) \u003d {(candidate.name) | candidate in set continuing_candidates} in let sub_parcel_map:map (Candidate_names) to (Sub_parcel) \u003d {n |-\u003e mk_Sub_parcel({v |-\u003e parcel(v) | v in set (dom parcel) \u0026 next_preference(n, v, names)}, val) | n in set names} in let non_empty_sub_parcel_map:map (Candidate_names) to (Sub_parcel) \u003d {n |-\u003e sub_parcel_map(n) | n in set (dom sub_parcel_map) \u0026 ((sub_parcel_map(n).votes) \u003c\u003e {|-\u003e})} in inv_Value(1.0))","legal map application obligation:(forall name:Candidate_names, vote:Voting_paper, continuing:set of (Candidate_names) \u0026 ((name in set (dom vote)) \u003d\u003e (forall i in set (rng vote) \u0026 (name in set (dom vote)))))","type compatibility obligation:(forall surplus:real, old_value:Value, old_votes:Parcel, disc:Candidate, cont_cands:set of (Candidate) \u0026 inv_Value(1.0))","type compatibility obligation:(forall surplus:real, old_value:Value, old_votes:Parcel, disc:Candidate, cont_cands:set of (Candidate) \u0026 let new_sub_parcels:Sub_parcel_bundle \u003d construct_sub_parcels(1.0, old_votes, disc, cont_cands) in let total_no_of_trans_votes:int \u003d (size(old_votes) - size(((new_sub_parcels.non_transferable).votes))) in let total_val_trans_votes:real \u003d (total_no_of_trans_votes * old_value) in inv_Value(total_val_trans_votes))","type compatibility obligation:(forall surplus:real, old_value:Value, old_votes:Parcel, disc:Candidate, cont_cands:set of (Candidate) \u0026 let new_sub_parcels:Sub_parcel_bundle \u003d construct_sub_parcels(1.0, old_votes, disc, cont_cands) in let total_no_of_trans_votes:int \u003d (size(old_votes) - size(((new_sub_parcels.non_transferable).votes))) in let total_val_trans_votes:real \u003d (total_no_of_trans_votes * old_value) in (total_no_of_trans_votes \u003e\u003d 0))","comprehension map injectivity obligation:(forall surplus:real, old_value:Value, old_votes:Parcel, disc:Candidate, cont_cands:set of (Candidate) \u0026 let new_sub_parcels:Sub_parcel_bundle \u003d construct_sub_parcels(1.0, old_votes, disc, cont_cands) in let total_no_of_trans_votes:int \u003d (size(old_votes) - size(((new_sub_parcels.non_transferable).votes))) in let total_val_trans_votes:real \u003d (total_no_of_trans_votes * old_value) in let transf_val:Value \u003d calc_transf_value(surplus, total_val_trans_votes, old_value, total_no_of_trans_votes) in (forall m1, m2 in set {{n |-\u003e mk_Sub_parcel(((new_sub_parcels.sub_parcels)(n).votes), transf_val)} | n in set (dom (new_sub_parcels.sub_parcels))} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4))))))","legal map application obligation:(forall surplus:real, old_value:Value, old_votes:Parcel, disc:Candidate, cont_cands:set of (Candidate) \u0026 let new_sub_parcels:Sub_parcel_bundle \u003d construct_sub_parcels(1.0, old_votes, disc, cont_cands) in let total_no_of_trans_votes:int \u003d (size(old_votes) - size(((new_sub_parcels.non_transferable).votes))) in let total_val_trans_votes:real \u003d (total_no_of_trans_votes * old_value) in let transf_val:Value \u003d calc_transf_value(surplus, total_val_trans_votes, old_value, total_no_of_trans_votes) in (forall n in set (dom (new_sub_parcels.sub_parcels)) \u0026 (n in set (dom (new_sub_parcels.sub_parcels)))))","type compatibility obligation:(forall surplus:real, old_value:Value, old_votes:Parcel, disc:Candidate, cont_cands:set of (Candidate) \u0026 let new_sub_parcels:Sub_parcel_bundle \u003d construct_sub_parcels(1.0, old_votes, disc, cont_cands) in let total_no_of_trans_votes:int \u003d (size(old_votes) - size(((new_sub_parcels.non_transferable).votes))) in let total_val_trans_votes:real \u003d (total_no_of_trans_votes * old_value) in let transf_val:Value \u003d calc_transf_value(surplus, total_val_trans_votes, old_value, total_no_of_trans_votes) in inv_Value(total_val_trans_votes))","type compatibility obligation:(forall surplus:real, old_value:Value, old_votes:Parcel, disc:Candidate, cont_cands:set of (Candidate) \u0026 let new_sub_parcels:Sub_parcel_bundle \u003d construct_sub_parcels(1.0, old_votes, disc, cont_cands) in let total_no_of_trans_votes:int \u003d (size(old_votes) - size(((new_sub_parcels.non_transferable).votes))) in let total_val_trans_votes:real \u003d (total_no_of_trans_votes * old_value) in let transf_val:Value \u003d calc_transf_value(surplus, total_val_trans_votes, old_value, total_no_of_trans_votes) in (total_no_of_trans_votes \u003e\u003d 0))","type compatibility obligation:(forall surplus:real, old_value:Value, old_votes:Parcel, disc:Candidate, cont_cands:set of (Candidate) \u0026 let new_sub_parcels:Sub_parcel_bundle \u003d construct_sub_parcels(1.0, old_votes, disc, cont_cands) in let total_no_of_trans_votes:int \u003d (size(old_votes) - size(((new_sub_parcels.non_transferable).votes))) in let total_val_trans_votes:real \u003d (total_no_of_trans_votes * old_value) in let transf_val:Value \u003d calc_transf_value(surplus, total_val_trans_votes, old_value, total_no_of_trans_votes) in inv_Value(total_val_trans_votes))","non-zero obligation:(forall surplus:real, total_value:Value, old_value:Value, total_no:nat \u0026 ((surplus \u003c total_value) \u003d\u003e (total_no \u003c\u003e 0)))","type compatibility obligation:(forall surplus:real, total_value:Value, old_value:Value, total_no:nat \u0026 inv_Value((if (surplus \u003c total_value)\nthen ((floor ((100 * surplus) / total_no)) / 100)\nelse old_value)))","non-zero obligation:(forall surplus:real, total_value:Value, total_number:nat, old_value:Value \u0026 ((surplus \u003c total_value) \u003d\u003e (total_number \u003c\u003e 0)))","non-zero obligation:(forall surplus:real, total_value:Value, total_number:nat, old_value:Value \u0026 ((surplus \u003c total_value) \u003d\u003e (total_value \u003c\u003e 0)))","type compatibility obligation:(forall surplus:real, total_value:Value \u0026 inv_Value((if (surplus \u003e total_value)\nthen (surplus - total_value)\nelse 0)))","legal map application obligation:(forall previous_collection:Candset, bundle:Sub_parcel_bundle \u0026 (((dom (bundle.sub_parcels)) subset {(candidate.name) | candidate in set previous_collection}) \u003d\u003e (forall candidate in set previous_collection, n in set (dom (bundle.sub_parcels)) \u0026 (((candidate.name) \u003d n) \u003d\u003e (n in set (dom (bundle.sub_parcels)))))))","let be st existence obligation:(forall sta:Stage \u0026 ((not ([] \u003d sta)) \u003d\u003e ((not (exists [e]:Stage \u0026 ([e] \u003d sta))) \u003d\u003e (exists sta1 ^ sta2 in set {sta} \u0026 ((abs ((len sta1) - (len sta2))) \u003c 2)))))","non-empty sequence obligation:(forall sta1:Stage, sta2:Stage \u0026 ((not (exists mk_([], sta):(Stage * Stage) \u0026 (mk_([], sta) \u003d mk_(sta1, sta2)))) \u003d\u003e ((not (exists mk_(sta, []):(Stage * Stage) \u0026 (mk_(sta, []) \u003d mk_(sta1, sta2)))) \u003d\u003e (sta1 \u003c\u003e []))))","non-empty sequence obligation:(forall sta1:Stage, sta2:Stage \u0026 ((not (exists mk_([], sta):(Stage * Stage) \u0026 (mk_([], sta) \u003d mk_(sta1, sta2)))) \u003d\u003e ((not (exists mk_(sta, []):(Stage * Stage) \u0026 (mk_(sta, []) \u003d mk_(sta1, sta2)))) \u003d\u003e (sta2 \u003c\u003e []))))","non-empty sequence obligation:(forall sta1:Stage, sta2:Stage \u0026 ((not (exists mk_([], sta):(Stage * Stage) \u0026 (mk_([], sta) \u003d mk_(sta1, sta2)))) \u003d\u003e ((not (exists mk_(sta, []):(Stage * Stage) \u0026 (mk_(sta, []) \u003d mk_(sta1, sta2)))) \u003d\u003e ((((hd sta1).count) \u003e\u003d ((hd sta2).count)) \u003d\u003e (sta1 \u003c\u003e [])))))","non-empty sequence obligation:(forall sta1:Stage, sta2:Stage \u0026 ((not (exists mk_([], sta):(Stage * Stage) \u0026 (mk_([], sta) \u003d mk_(sta1, sta2)))) \u003d\u003e ((not (exists mk_(sta, []):(Stage * Stage) \u0026 (mk_(sta, []) \u003d mk_(sta1, sta2)))) \u003d\u003e ((((hd sta1).count) \u003e\u003d ((hd sta2).count)) \u003d\u003e (sta1 \u003c\u003e [])))))","non-empty sequence obligation:(forall sta1:Stage, sta2:Stage \u0026 ((not (exists mk_([], sta):(Stage * Stage) \u0026 (mk_([], sta) \u003d mk_(sta1, sta2)))) \u003d\u003e ((not (exists mk_(sta, []):(Stage * Stage) \u0026 (mk_(sta, []) \u003d mk_(sta1, sta2)))) \u003d\u003e ((not (((hd sta1).count) \u003e\u003d ((hd sta2).count))) \u003d\u003e (sta2 \u003c\u003e [])))))","non-empty sequence obligation:(forall sta1:Stage, sta2:Stage \u0026 ((not (exists mk_([], sta):(Stage * Stage) \u0026 (mk_([], sta) \u003d mk_(sta1, sta2)))) \u003d\u003e ((not (exists mk_(sta, []):(Stage * Stage) \u0026 (mk_(sta, []) \u003d mk_(sta1, sta2)))) \u003d\u003e ((not (((hd sta1).count) \u003e\u003d ((hd sta2).count))) \u003d\u003e (sta2 \u003c\u003e [])))))","type compatibility obligation:(forall sta1:Stage, sta2:Stage \u0026 inv_Stage((cases mk_(sta1, sta2) :\nmk_([], sta) -\u003e sta,\nmk_(sta, []) -\u003e sta\nothers (if (((hd sta1).count) \u003e\u003d ((hd sta2).count))\nthen ([(hd sta1)] ^ score_merge((tl sta1), sta2))\nelse ([(hd sta2)] ^ score_merge(sta1, (tl sta2))))\n end)))","let be st existence obligation:(forall s:set of (Score) \u0026 ((not (s \u003d {})) \u003d\u003e (exists e in set s \u0026 true)))","type compatibility obligation:(forall s:set of (Score) \u0026 inv_Stage((if (s \u003d {})\nthen []\nelse let e in set s in ([e] ^ set_seq((s \\ {e}))))))","legal map application obligation:(forall old_stage:Stage, discontinuing:Candidate_names, bundle:Sub_parcel_bundle \u0026 let cands_with_more_votes:set of (Candidate_names) \u003d (dom (bundle.sub_parcels)) in (forall mk_Score(name, old_count) in set (elems old_stage) \u0026 ((name in set cands_with_more_votes) \u003d\u003e (name in set (dom (bundle.sub_parcels))))))","legal map application obligation:(forall old_stage:Stage, discontinuing:Candidate_names, bundle:Sub_parcel_bundle \u0026 let cands_with_more_votes:set of (Candidate_names) \u003d (dom (bundle.sub_parcels)) in (forall mk_Score(name, old_count) in set (elems old_stage) \u0026 ((name in set cands_with_more_votes) \u003d\u003e (name in set (dom (bundle.sub_parcels))))))","non-empty sequence obligation:(forall stages:seq of (Stage), quota:real \u0026 (stages \u003c\u003e []))","non-empty sequence obligation:(forall stages:seq of (Stage), quota:real \u0026 ((hd stages) \u003c\u003e []))","legal function application obligation:(forall stages:seq of (Stage), quota:real \u0026 ((((hd (hd stages)).count) \u003e\u003d quota) \u003d\u003e pre_defer_transfer_of_surplus(quota, (hd stages))))","non-empty sequence obligation:(forall stages:seq of (Stage), quota:real \u0026 ((((hd (hd stages)).count) \u003e\u003d quota) \u003d\u003e (stages \u003c\u003e [])))","legal function application obligation:(forall name:Candidate_names, all_stages:seq1 of (Stage) \u0026 pre_stage_bk((hd all_stages)))","legal sequence application obligation:(forall name:Candidate_names, all_stages:seq1 of (Stage) \u0026 let trailing_count:real \u003d (stage_bk((hd all_stages)).count) in let lowest:set of (Candidate_names) \u003d {(score.name) | score in set (elems (hd all_stages)) \u0026 ((score.count) \u003d trailing_count)} in (forall i in set (inds all_stages) \u0026 (i in set (inds all_stages))))","legal sequence application obligation:(forall name:Candidate_names, all_stages:seq1 of (Stage) \u0026 let trailing_count:real \u003d (stage_bk((hd all_stages)).count) in let lowest:set of (Candidate_names) \u003d {(score.name) | score in set (elems (hd all_stages)) \u0026 ((score.count) \u003d trailing_count)} in (forall i in set (inds all_stages) \u0026 (sole_trailer(all_stages(i), name, lowest) \u003d\u003e (forall j in set {(i + 1), ... ,(len all_stages)}, other in set lowest \u0026 (j in set (inds all_stages))))))","unique existence binding obligation:(forall stage:Stage, name:Candidate_names, lowest:set of (Candidate_names) \u0026 (exists1 c in set (elems stage) \u0026 ((c.name) \u003d name)))","type compatibility obligation:(forall cands:set of (Candidate_names) \u0026 ((Number_of_vacancies - (card cands)) \u003e\u003d 0))","non-empty sequence obligation:(forall continuing:set of (Candidate), stages:seq of (Stage), quota:real \u0026 (stages \u003c\u003e []))","legal map application obligation:(forall paper:Voting_paper, discontinuing:Candidate_names, continuing_names:set of (Candidate_names) \u0026 ((not (((dom (paper :-\u003e {1})) inter continuing_names) \u003d {})) \u003d\u003e (discontinuing in set (dom paper))))","legal function application obligation:(forall paper:Voting_paper, discontinuing:Candidate_names, continuing_names:set of (Candidate_names) \u0026 ((not (((dom (paper :-\u003e {1})) inter continuing_names) \u003d {})) \u003d\u003e let s:set of (nat1) \u003d (rng (paper :-\u003e {1, ... ,paper(discontinuing)})) in ((not (s \u003d {})) \u003d\u003e pre_min(s))))","let be st existence obligation:(forall s:set of (real) \u0026 ((s \u003c\u003e {}) \u003d\u003e (exists m in set s \u0026 true)))","legal function application obligation:(forall s:set of (real) \u0026 ((s \u003c\u003e {}) \u003d\u003e (forall m in set s \u0026 ((not ((card s) \u003d 1)) \u003d\u003e pre_min((s \\ {m}))))))","legal sequence application obligation:(forall continuing:set of (Candidate), stages:seq of (Stage), quota:real \u0026 let continuing_names:set of (Candidate_names) \u003d {(c.name) | c in set continuing} in (forall i in set (inds (hd stages)) \u0026 ((((hd stages)(i).name) in set continuing_names) \u003d\u003e (i in set (inds (hd stages))))))","non-empty sequence obligation:(forall continuing:set of (Candidate), stages:seq of (Stage), quota:real \u0026 let continuing_names:set of (Candidate_names) \u003d {(c.name) | c in set continuing} in (forall i in set (inds (hd stages)) \u0026 ((((hd stages)(i).name) in set continuing_names) \u003d\u003e (stages \u003c\u003e []))))","non-empty sequence obligation:(forall continuing:set of (Candidate), stages:seq of (Stage), quota:real \u0026 let continuing_names:set of (Candidate_names) \u003d {(c.name) | c in set continuing} in (stages \u003c\u003e []))","legal sequence application obligation:(forall continuing:set of (Candidate), stages:seq of (Stage), quota:real \u0026 let continuing_names:set of (Candidate_names) \u003d {(c.name) | c in set continuing} in (forall i in set (inds (hd stages)) \u0026 (i in set (inds (hd stages)))))","non-empty sequence obligation:(forall continuing:set of (Candidate), stages:seq of (Stage), quota:real \u0026 let continuing_names:set of (Candidate_names) \u003d {(c.name) | c in set continuing} in (forall i in set (inds (hd stages)) \u0026 (stages \u003c\u003e [])))","legal sequence application obligation:(forall continuing:set of (Candidate), stages:seq of (Stage), quota:real \u0026 let continuing_names:set of (Candidate_names) \u003d {(c.name) | c in set continuing} in (forall i in set (inds (hd stages)) \u0026 ((((hd stages)(i).count) \u003e quota) \u003d\u003e (i in set (inds (hd stages))))))","non-empty sequence obligation:(forall continuing:set of (Candidate), stages:seq of (Stage), quota:real \u0026 let continuing_names:set of (Candidate_names) \u003d {(c.name) | c in set continuing} in (forall i in set (inds (hd stages)) \u0026 ((((hd stages)(i).count) \u003e quota) \u003d\u003e (stages \u003c\u003e []))))","non-empty sequence obligation:(forall continuing:set of (Candidate), stages:seq of (Stage), quota:real \u0026 let continuing_names:set of (Candidate_names) \u003d {(c.name) | c in set continuing} in (stages \u003c\u003e []))","legal sequence application obligation:(forall continuing:set of (Candidate), stages:seq of (Stage), quota:real \u0026 let continuing_names:set of (Candidate_names) \u003d {(c.name) | c in set continuing} in (forall i in set (inds (hd stages)) \u0026 (i in set (inds (hd stages)))))","non-empty sequence obligation:(forall continuing:set of (Candidate), stages:seq of (Stage), quota:real \u0026 let continuing_names:set of (Candidate_names) \u003d {(c.name) | c in set continuing} in (forall i in set (inds (hd stages)) \u0026 (stages \u003c\u003e [])))","legal sequence application obligation:(forall continuing:set of (Candidate), stages:seq of (Stage), quota:real \u0026 let continuing_names:set of (Candidate_names) \u003d {(c.name) | c in set continuing} in let continuing_scores:seq of (Score) \u003d [(hd stages)(i) | i in set (inds (hd stages)) \u0026 (((hd stages)(i).name) in set continuing_names)], surplus_scores:seq of (Score) \u003d [(hd stages)(i) | i in set (inds (hd stages)) \u0026 (((hd stages)(i).count) \u003e quota)] in (forall i in set (inds continuing_scores) \u0026 (i in set (inds continuing_scores))))","legal sequence application obligation:(forall continuing:set of (Candidate), stages:seq of (Stage), quota:real \u0026 let continuing_names:set of (Candidate_names) \u003d {(c.name) | c in set continuing} in let continuing_scores:seq of (Score) \u003d [(hd stages)(i) | i in set (inds (hd stages)) \u0026 (((hd stages)(i).name) in set continuing_names)], surplus_scores:seq of (Score) \u003d [(hd stages)(i) | i in set (inds (hd stages)) \u0026 (((hd stages)(i).count) \u003e quota)] in (forall i in set (inds continuing_scores) \u0026 (forall j in set ((inds continuing_scores) \\ {i}) \u0026 (j in set (inds continuing_scores)))))","legal sequence application obligation:(forall continuing:set of (Candidate), stages:seq of (Stage), quota:real \u0026 let continuing_names:set of (Candidate_names) \u003d {(c.name) | c in set continuing} in let continuing_scores:seq of (Score) \u003d [(hd stages)(i) | i in set (inds (hd stages)) \u0026 (((hd stages)(i).name) in set continuing_names)], surplus_scores:seq of (Score) \u003d [(hd stages)(i) | i in set (inds (hd stages)) \u0026 (((hd stages)(i).count) \u003e quota)] in (forall i in set (inds continuing_scores) \u0026 (forall j in set (inds surplus_scores) \u0026 (j in set (inds surplus_scores)))))","legal sequence application obligation:(forall stages:seq of (Stage), quota:real, record:seq of (Record_entry), elected:set of (Candidate_names) \u0026 (forall i:nat1 \u0026 ((i + 1) in set (inds stages))))","legal sequence application obligation:(forall stages:seq of (Stage), quota:real, record:seq of (Record_entry), elected:set of (Candidate_names) \u0026 (forall i:nat1 \u0026 (i in set (inds stages))))","unique existence binding obligation:(forall stages:seq of (Stage), quota:real, record:seq of (Record_entry), elected:set of (Candidate_names) \u0026 (forall i:nat1 \u0026 (((len stages((i + 1))) \u003e (len stages(i))) \u003d\u003e (exists1 ex in set Cand_names \u0026 (ex in set {(sc.name) | sc in set (elems stages((i + 1))) \u0026 (forall osc in set (elems stages(i)) \u0026 ((osc.name) \u003c\u003e (sc.name)))})))))","legal sequence application obligation:(forall stages:seq of (Stage), quota:real, record:seq of (Record_entry), elected:set of (Candidate_names) \u0026 (forall i:nat1 \u0026 (((len stages((i + 1))) \u003e (len stages(i))) \u003d\u003e (forall ex in set Cand_names \u0026 ((i + 1) in set (inds stages))))))","legal sequence application obligation:(forall stages:seq of (Stage), quota:real, record:seq of (Record_entry), elected:set of (Candidate_names) \u0026 (forall i:nat1 \u0026 (((len stages((i + 1))) \u003e (len stages(i))) \u003d\u003e (forall ex in set Cand_names \u0026 (forall sc in set (elems stages((i + 1))) \u0026 (i in set (inds stages)))))))","legal sequence application obligation:(forall stages:seq of (Stage), quota:real, record:seq of (Record_entry), elected:set of (Candidate_names) \u0026 (forall i:nat1 \u0026 (((len stages((i + 1))) \u003e (len stages(i))) \u003d\u003e let excluded:(\u003cAdam\u003e | \u003cBill\u003e | \u003cCharlie\u003e | \u003cDonald\u003e | \u003cEdward\u003e | \u003cFrank\u003e | \u003cGeorge\u003e | \u003cHarry\u003e | \u003cIan\u003e | \u003cJohn\u003e) \u003d (iota ex in set Cand_names \u0026 (ex in set {(sc.name) | sc in set (elems stages((i + 1))) \u0026 (forall osc in set (elems stages(i)) \u0026 ((osc.name) \u003c\u003e (sc.name)))})) in ((i + 1) in set (inds record)))))","unique existence binding obligation:(forall stages:seq of (Stage), quota:real, record:seq of (Record_entry), elected:set of (Candidate_names) \u0026 (forall i:nat1 \u0026 ((not ((len stages((i + 1))) \u003e (len stages(i)))) \u003d\u003e (exists1 tf in set Cand_names \u0026 (tf in set {(sc.name) | sc in set (elems stages((i + 1))) \u0026 ((mk_Score((sc.name), quota) in set (elems stages(i))) and ((sc.count) \u003e quota))})))))","legal sequence application obligation:(forall stages:seq of (Stage), quota:real, record:seq of (Record_entry), elected:set of (Candidate_names) \u0026 (forall i:nat1 \u0026 ((not ((len stages((i + 1))) \u003e (len stages(i)))) \u003d\u003e (forall tf in set Cand_names \u0026 ((i + 1) in set (inds stages))))))","legal sequence application obligation:(forall stages:seq of (Stage), quota:real, record:seq of (Record_entry), elected:set of (Candidate_names) \u0026 (forall i:nat1 \u0026 ((not ((len stages((i + 1))) \u003e (len stages(i)))) \u003d\u003e (forall tf in set Cand_names \u0026 (forall sc in set (elems stages((i + 1))) \u0026 (i in set (inds stages)))))))","legal sequence application obligation:(forall stages:seq of (Stage), quota:real, record:seq of (Record_entry), elected:set of (Candidate_names) \u0026 (forall i:nat1 \u0026 ((not ((len stages((i + 1))) \u003e (len stages(i)))) \u003d\u003e let transferred:(\u003cAdam\u003e | \u003cBill\u003e | \u003cCharlie\u003e | \u003cDonald\u003e | \u003cEdward\u003e | \u003cFrank\u003e | \u003cGeorge\u003e | \u003cHarry\u003e | \u003cIan\u003e | \u003cJohn\u003e) \u003d (iota tf in set Cand_names \u0026 (tf in set {(sc.name) | sc in set (elems stages((i + 1))) \u0026 ((mk_Score((sc.name), quota) in set (elems stages(i))) and ((sc.count) \u003e quota))})) in ((i + 1) in set (inds record)))))","type compatibility obligation:(forall stages:seq of (Stage), quota:real, record:seq of (Record_entry), elected:set of (Candidate_names) \u0026 let result: (nat1 -\u003e Result)\n\tresult(i) \u003d\u003d\n(if ((len stages((i + 1))) \u003e (len stages(i)))\nthen let excluded:(\u003cAdam\u003e | \u003cBill\u003e | \u003cCharlie\u003e | \u003cDonald\u003e | \u003cEdward\u003e | \u003cFrank\u003e | \u003cGeorge\u003e | \u003cHarry\u003e | \u003cIan\u003e | \u003cJohn\u003e) \u003d (iota ex in set Cand_names \u0026 (ex in set {(sc.name) | sc in set (elems stages((i + 1))) \u0026 (forall osc in set (elems stages(i)) \u0026 ((osc.name) \u003c\u003e (sc.name)))})) in mk_Result((record((i + 1)).scores), nil, excluded)\nelse let transferred:(\u003cAdam\u003e | \u003cBill\u003e | \u003cCharlie\u003e | \u003cDonald\u003e | \u003cEdward\u003e | \u003cFrank\u003e | \u003cGeorge\u003e | \u003cHarry\u003e | \u003cIan\u003e | \u003cJohn\u003e) \u003d (iota tf in set Cand_names \u0026 (tf in set {(sc.name) | sc in set (elems stages((i + 1))) \u0026 ((mk_Score((sc.name), quota) in set (elems stages(i))) and ((sc.count) \u003e quota))})) in mk_Result((record((i + 1)).scores), transferred, nil)) in (forall j in set {1, ... ,((len record) - 1)} \u0026 (((len record) - j) \u003e 0)))","let be st existence obligation:(forall s:set of (Sub_parcel) \u0026 ((not (s \u003d {})) \u003d\u003e (exists e in set s \u0026 true)))","let be st existence obligation:(forall sps:seq of (Sub_parcel) \u0026 ((not ([] \u003d sps)) \u003d\u003e ((not (exists [e]:seq of (Sub_parcel) \u0026 ([e] \u003d sps))) \u003d\u003e (exists sps1 ^ sps2 in set {sps} \u0026 ((abs ((len sps1) - (len sps2))) \u003c 2)))))","non-empty sequence obligation:(forall sps1:seq of (Sub_parcel), sps2:seq of (Sub_parcel) \u0026 ((not (exists mk_([], sps):(seq of (Sub_parcel) * seq of (Sub_parcel)) \u0026 (mk_([], sps) \u003d mk_(sps1, sps2)))) \u003d\u003e ((not (exists mk_(sps, []):(seq of (Sub_parcel) * seq of (Sub_parcel)) \u0026 (mk_(sps, []) \u003d mk_(sps1, sps2)))) \u003d\u003e (sps1 \u003c\u003e []))))","non-empty sequence obligation:(forall sps1:seq of (Sub_parcel), sps2:seq of (Sub_parcel) \u0026 ((not (exists mk_([], sps):(seq of (Sub_parcel) * seq of (Sub_parcel)) \u0026 (mk_([], sps) \u003d mk_(sps1, sps2)))) \u003d\u003e ((not (exists mk_(sps, []):(seq of (Sub_parcel) * seq of (Sub_parcel)) \u0026 (mk_(sps, []) \u003d mk_(sps1, sps2)))) \u003d\u003e (sps2 \u003c\u003e []))))","non-empty sequence obligation:(forall sps1:seq of (Sub_parcel), sps2:seq of (Sub_parcel) \u0026 ((not (exists mk_([], sps):(seq of (Sub_parcel) * seq of (Sub_parcel)) \u0026 (mk_([], sps) \u003d mk_(sps1, sps2)))) \u003d\u003e ((not (exists mk_(sps, []):(seq of (Sub_parcel) * seq of (Sub_parcel)) \u0026 (mk_(sps, []) \u003d mk_(sps1, sps2)))) \u003d\u003e ((total_value((hd sps1)) \u003e\u003d total_value((hd sps2))) \u003d\u003e (sps1 \u003c\u003e [])))))","non-empty sequence obligation:(forall sps1:seq of (Sub_parcel), sps2:seq of (Sub_parcel) \u0026 ((not (exists mk_([], sps):(seq of (Sub_parcel) * seq of (Sub_parcel)) \u0026 (mk_([], sps) \u003d mk_(sps1, sps2)))) \u003d\u003e ((not (exists mk_(sps, []):(seq of (Sub_parcel) * seq of (Sub_parcel)) \u0026 (mk_(sps, []) \u003d mk_(sps1, sps2)))) \u003d\u003e ((total_value((hd sps1)) \u003e\u003d total_value((hd sps2))) \u003d\u003e (sps1 \u003c\u003e [])))))","non-empty sequence obligation:(forall sps1:seq of (Sub_parcel), sps2:seq of (Sub_parcel) \u0026 ((not (exists mk_([], sps):(seq of (Sub_parcel) * seq of (Sub_parcel)) \u0026 (mk_([], sps) \u003d mk_(sps1, sps2)))) \u003d\u003e ((not (exists mk_(sps, []):(seq of (Sub_parcel) * seq of (Sub_parcel)) \u0026 (mk_(sps, []) \u003d mk_(sps1, sps2)))) \u003d\u003e ((not (total_value((hd sps1)) \u003e\u003d total_value((hd sps2)))) \u003d\u003e (sps2 \u003c\u003e [])))))","non-empty sequence obligation:(forall sps1:seq of (Sub_parcel), sps2:seq of (Sub_parcel) \u0026 ((not (exists mk_([], sps):(seq of (Sub_parcel) * seq of (Sub_parcel)) \u0026 (mk_([], sps) \u003d mk_(sps1, sps2)))) \u003d\u003e ((not (exists mk_(sps, []):(seq of (Sub_parcel) * seq of (Sub_parcel)) \u0026 (mk_(sps, []) \u003d mk_(sps1, sps2)))) \u003d\u003e ((not (total_value((hd sps1)) \u003e\u003d total_value((hd sps2)))) \u003d\u003e (sps2 \u003c\u003e [])))))","non-empty sequence obligation:((stages \u003c\u003e []) \u003d\u003e (stages \u003c\u003e []))","non-empty sequence obligation:((stages \u003c\u003e []) \u003d\u003e (forall score in set (elems (hd stages)) \u0026 (stages \u003c\u003e [])))","non-empty sequence obligation:((stages \u003c\u003e []) \u003d\u003e (forall score in set (elems (hd stages)) \u0026 ((hd stages) \u003c\u003e [])))","unique existence binding obligation:((stages \u003c\u003e []) \u003d\u003e (exists1 name in set leaders \u0026 greatest_value_at_earliest_stage(name, stages)))","non-empty sequence obligation:((stages \u003c\u003e []) \u003d\u003e (stages \u003c\u003e []))","legal function application obligation:((stages \u003c\u003e []) \u003d\u003e (forall score in set (elems (hd stages)) \u0026 pre_stage_bk((hd stages))))","non-empty sequence obligation:((stages \u003c\u003e []) \u003d\u003e (forall score in set (elems (hd stages)) \u0026 (stages \u003c\u003e [])))","type compatibility obligation:((stages \u003c\u003e []) \u003d\u003e (forall n in set lowest \u0026 is_(stages, seq1 of (Stage))))","unique existence binding obligation:((stages \u003c\u003e []) \u003d\u003e (exists1 name in set lowest \u0026 trailing_candidate(name, stages)))","type compatibility obligation:((stages \u003c\u003e []) \u003d\u003e (forall name in set lowest \u0026 is_(stages, seq1 of (Stage))))","non-empty sequence obligation:(forall s:Candnset, oldstate:St \u0026 (next_choice \u003c\u003e []))","state invariant holds obligation:(forall s:Candnset, oldstate:St \u0026 let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","non-empty sequence obligation:(forall s:Candnset, oldstate:St \u0026 (next_choice \u003c\u003e []))","state invariant holds obligation:(forall votes:Parcel, oldstate:St \u0026 let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","state invariant holds obligation:(forall votes:Parcel, oldstate:St \u0026 let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","state invariant holds obligation:(forall votes:Parcel, oldstate:St \u0026 let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","state invariant holds obligation:(forall votes:Parcel, oldstate:St \u0026 let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","state invariant holds obligation:(forall votes:Parcel, oldstate:St \u0026 let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","state invariant holds obligation:(forall votes:Parcel, oldstate:St \u0026 let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","non-zero obligation:(forall votes:Parcel, oldstate:St \u0026 ((Number_of_vacancies + 1) \u003c\u003e 0))","state invariant holds obligation:(forall votes:Parcel, oldstate:St \u0026 let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","non-empty sequence obligation:(forall votes:Parcel, oldstate:St \u0026 ([build_first_stage(curr_cont)] \u003c\u003e []))","operation call obligation:(forall votes:Parcel, oldstate:St \u0026 (number_of_candidates_satisfying_quota(continuing, stages, quota) \u003c\u003d number_of_remaining_vacancies({(e.name) | e in set elected})))","state invariant holds obligation:let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name))))))","state invariant holds obligation:let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name))))))","type compatibility obligation:(forall ex_cand:Candidate, sub_parcels:seq of (Sub_parcel), oldstate:St \u0026 inv_Value(0.0))","non-empty sequence obligation:(forall ex_cand:Candidate, sub_parcels:seq of (Sub_parcel), oldstate:St \u0026 (stages \u003c\u003e []))","while loop termination obligation:...","state invariant holds obligation:(forall ex_cand:Candidate, sub_parcels:seq of (Sub_parcel), oldstate:St \u0026 let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","state invariant holds obligation:(forall ex_cand:Candidate, sub_parcels:seq of (Sub_parcel), oldstate:St \u0026 let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","legal sequence application obligation:(forall ex_cand:Candidate, sub_parcels:seq of (Sub_parcel), oldstate:St \u0026 ((i + 1) in set (inds sub_parcels)))","legal sequence application obligation:(forall ex_cand:Candidate, sub_parcels:seq of (Sub_parcel), oldstate:St \u0026 ((i + 1) in set (inds sub_parcels)))","state invariant holds obligation:(forall ex_cand:Candidate, sub_parcels:seq of (Sub_parcel), oldstate:St \u0026 let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","legal sequence application obligation:(forall ex_cand:Candidate, sub_parcels:seq of (Sub_parcel), oldstate:St \u0026 ((i + 1) in set (inds sub_parcels)))","state invariant holds obligation:(forall ex_cand:Candidate, sub_parcels:seq of (Sub_parcel), oldstate:St \u0026 let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","legal function application obligation:(forall ex_cand:Candidate, sub_parcels:seq of (Sub_parcel), oldstate:St \u0026 pre_redistribute_parcels(new_candidates, bundle))","state invariant holds obligation:(forall ex_cand:Candidate, sub_parcels:seq of (Sub_parcel), oldstate:St \u0026 let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","state invariant holds obligation:(forall ex_cand:Candidate, sub_parcels:seq of (Sub_parcel), oldstate:St \u0026 let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","state invariant holds obligation:(forall ex_cand:Candidate, sub_parcels:seq of (Sub_parcel), oldstate:St \u0026 let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","state invariant holds obligation:(forall ex_cand:Candidate, sub_parcels:seq of (Sub_parcel), oldstate:St \u0026 let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","state invariant holds obligation:(forall ex_cand:Candidate, sub_parcels:seq of (Sub_parcel), oldstate:St \u0026 let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","state invariant holds obligation:(forall ex_cand:Candidate, sub_parcels:seq of (Sub_parcel), oldstate:St \u0026 let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","non-empty sequence obligation:(forall ex_cand:Candidate, sub_parcels:seq of (Sub_parcel), oldstate:St \u0026 (record \u003c\u003e []))","state invariant holds obligation:(forall ex_cand:Candidate, sub_parcels:seq of (Sub_parcel), oldstate:St \u0026 let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","legal sequence application obligation:(forall ex_cand:Candidate, sub_parcels:seq of (Sub_parcel), oldstate:St \u0026 (forall i in set (inds new_stage) \u0026 (((new_stage(i).name) \u003c\u003e (ex_cand.name)) \u003d\u003e (i in set (inds new_stage)))))","legal sequence application obligation:(forall ex_cand:Candidate, sub_parcels:seq of (Sub_parcel), oldstate:St \u0026 (forall i in set (inds new_stage) \u0026 (i in set (inds new_stage))))","type compatibility obligation:(forall ex_cand:Candidate, sub_parcels:seq of (Sub_parcel), oldstate:St \u0026 is_(([[new_stage(i) | i in set (inds new_stage) \u0026 ((new_stage(i).name) \u003c\u003e (ex_cand.name))]] ^ stages), seq of (Stage)))","unique existence binding obligation:(last_vacancy_fillable(continuing, stages, quota) \u003d\u003e (exists1 leader in set continuing \u0026 ((leader.name) \u003d ((hd stages)(Number_of_vacancies).name))))","legal sequence application obligation:(last_vacancy_fillable(continuing, stages, quota) \u003d\u003e (forall leader in set continuing \u0026 (Number_of_vacancies in set (inds (hd stages)))))","non-empty sequence obligation:(last_vacancy_fillable(continuing, stages, quota) \u003d\u003e (forall leader in set continuing \u0026 (stages \u003c\u003e [])))","state invariant holds obligation:(last_vacancy_fillable(continuing, stages, quota) \u003d\u003e let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","state invariant holds obligation:(last_vacancy_fillable(continuing, stages, quota) \u003d\u003e let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","unique existence binding obligation:(exists_non_deferable_surplus(stages, quota) \u003d\u003e (exists1 c in set elected \u0026 ((c.name) \u003d name)))","non-empty sequence obligation:(exists_non_deferable_surplus(stages, quota) \u003d\u003e (stages \u003c\u003e []))","non-empty sequence obligation:(exists_non_deferable_surplus(stages, quota) \u003d\u003e ((hd stages) \u003c\u003e []))","type compatibility obligation:(exists_non_deferable_surplus(stages, quota) \u003d\u003e (surplus_from_original_votes(candidate) \u003d\u003e inv_Value(1.0)))","non-empty sequence obligation:(exists_non_deferable_surplus(stages, quota) \u003d\u003e ((not surplus_from_original_votes(candidate)) \u003d\u003e ((candidate.transferred_votes) \u003c\u003e [])))","type compatibility obligation:(exists_non_deferable_surplus(stages, quota) \u003d\u003e inv_Stage(([mk_Score(name, quota)] ^ [(hd stages)(i) | i in set (inds (hd stages)) \u0026 (((hd stages)(i).name) \u003c\u003e name)])))","legal sequence application obligation:(exists_non_deferable_surplus(stages, quota) \u003d\u003e (forall i in set (inds (hd stages)) \u0026 ((((hd stages)(i).name) \u003c\u003e name) \u003d\u003e (i in set (inds (hd stages))))))","non-empty sequence obligation:(exists_non_deferable_surplus(stages, quota) \u003d\u003e (forall i in set (inds (hd stages)) \u0026 ((((hd stages)(i).name) \u003c\u003e name) \u003d\u003e (stages \u003c\u003e []))))","non-empty sequence obligation:(exists_non_deferable_surplus(stages, quota) \u003d\u003e (stages \u003c\u003e []))","legal sequence application obligation:(exists_non_deferable_surplus(stages, quota) \u003d\u003e (forall i in set (inds (hd stages)) \u0026 (i in set (inds (hd stages)))))","non-empty sequence obligation:(exists_non_deferable_surplus(stages, quota) \u003d\u003e (forall i in set (inds (hd stages)) \u0026 (stages \u003c\u003e [])))","legal function application obligation:(exists_non_deferable_surplus(stages, quota) \u003d\u003e pre_redistribute_parcels((continuing \\ {candidate}), sub_parcel_bundle))","state invariant holds obligation:(exists_non_deferable_surplus(stages, quota) \u003d\u003e let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","state invariant holds obligation:(exists_non_deferable_surplus(stages, quota) \u003d\u003e let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","non-empty sequence obligation:(exists_non_deferable_surplus(stages, quota) \u003d\u003e (record \u003c\u003e []))","state invariant holds obligation:(exists_non_deferable_surplus(stages, quota) \u003d\u003e let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","operation call obligation:(exists_non_deferable_surplus(stages, quota) \u003d\u003e (number_of_candidates_satisfying_quota(continuing, stages, quota) \u003c\u003d number_of_remaining_vacancies({(e.name) | e in set elected})))","unique existence binding obligation:(exists1 c in set continuing \u0026 ((c.name) \u003d name))","type compatibility obligation:inv_Value(1.0)","operation call obligation:(true \u003d\u003e (number_of_candidates_satisfying_quota(continuing, stages, quota) \u003c\u003d number_of_remaining_vacancies({(e.name) | e in set elected})))","operation call obligation:(true \u003d\u003e (true \u003d\u003e last_vacancy_fillable(continuing, stages, quota)))","operation call obligation:(true \u003d\u003e (true \u003d\u003e (true \u003d\u003e exists_non_deferable_surplus(stages, quota))))","while loop termination obligation:...","non-empty sequence obligation:((number_of_candidates_satisfying_quota(continuing, stages, quota) \u003c\u003d number_of_remaining_vacancies({(e.name) | e in set elected})) \u003d\u003e (stages \u003c\u003e []))","state invariant holds obligation:((number_of_candidates_satisfying_quota(continuing, stages, quota) \u003c\u003d number_of_remaining_vacancies({(e.name) | e in set elected})) \u003d\u003e let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))","state invariant holds obligation:((number_of_candidates_satisfying_quota(continuing, stages, quota) \u003c\u003d number_of_remaining_vacancies({(e.name) | e in set elected})) \u003d\u003e let s \u003d St in (({(cand.name) | cand in set (((s.elected) union (s.excluded)) union (s.continuing))} \u003d Cand_names) and (disjoint({(s.elected), (s.excluded), (s.continuing)}) and (forall cand1 in set (((s.elected) union (s.excluded)) union (s.continuing)), cand2 in set (((s.elected) union (s.excluded)) union (s.continuing)) \u0026 ((cand1 \u003d cand2) \u003c\u003d\u003e ((cand1.name) \u003d (cand2.name)))))))"] \ No newline at end of file diff --git a/core/pog/src/test/resources/examples/VDMRT.result b/core/pog/src/test/resources/examples/VDMRT.result index a6463f443e..959f11a4ec 100644 --- a/core/pog/src/test/resources/examples/VDMRT.result +++ b/core/pog/src/test/resources/examples/VDMRT.result @@ -1 +1 @@ -["state invariant initialized obligation:((len []) \u003c\u003d 5)","state invariant satisfiable obligation:(exists vehicles:seq of (Vehicle) \u0026 ((len vehicles) \u003c\u003d 5))","state invariant holds obligation:(forall vehicle:Vehicle \u0026 ((vehicle not in set (elems vehicles)) \u003d\u003e (((len vehicles) \u003c\u003d 5) \u003d\u003e ((len (vehicles ^ [vehicle])) \u003c\u003d 5))))","state invariant holds obligation:(forall vehicle:Vehicle \u0026 ((vehicle not in set (elems vehicles)) \u003d\u003e (((len (vehicles ^ [vehicle])) \u003c\u003d 5) \u003d\u003e ((len ((tl (vehicles ^ [vehicle])) ^ [vehicle])) \u003c\u003d 5))))","non-empty sequence obligation:(forall vehicle:Vehicle \u0026 ((vehicle not in set (elems vehicles)) \u003d\u003e ((vehicles ^ [vehicle]) \u003c\u003e [])))","state invariant holds obligation:(((len vehicles) \u003c\u003d 5) \u003d\u003e ((len vehicles) \u003c\u003d 5))","state invariant holds obligation:(forall vs:set of (Vehicle) \u0026 (((card vs) \u003c\u003e 0) \u003d\u003e (((len vehicles) \u003c\u003d 5) \u003d\u003e ((len vehicles) \u003c\u003d 5))))","non-zero obligation:(forall vs:set of (Vehicle) \u0026 (((card vs) \u003c\u003e 0) \u003d\u003e ((card vs) \u003c\u003e 0)))","type compatibility obligation:(forall vs:set of (Vehicle) \u0026 (((card vs) \u003c\u003e 0) \u003d\u003e is_(RESULT, nat)))","legal sequence application obligation:(1 in set (inds vs))","legal sequence application obligation:(2 in set (inds vs))","legal sequence application obligation:(1 in set (inds vs))","legal sequence application obligation:(2 in set (inds vs))","legal sequence application obligation:(3 in set (inds vs))","cases exhaustive obligation:(forall d:Direction \u0026 ((((d \u003d \u003cNORTH\u003e) or (d \u003d \u003cSOUTH\u003e)) or (d \u003d \u003cEAST\u003e)) or (d \u003d \u003cWEST\u003e)))","legal sequence application obligation:(1 in set (inds vs))","cases exhaustive obligation:(forall d:Direction \u0026 ((((d \u003d \u003cNORTH\u003e) or (d \u003d \u003cSOUTH\u003e)) or (d \u003d \u003cEAST\u003e)) or (d \u003d \u003cWEST\u003e)))","cases exhaustive obligation:(forall i:Indicator \u0026 (((i \u003d \u003cLEFT\u003e) or (i \u003d \u003cRIGHT\u003e)) or (i \u003d \u003cNONE\u003e)))","cases exhaustive obligation:(forall m:MessageType \u0026 ((((m \u003d \u003cLowGrip\u003e) or (m \u003d \u003cCongestion\u003e)) or (m \u003d \u003cLeftTurn\u003e)) or (m \u003d \u003cRedLight\u003e)))","legal function application obligation:(forall filename:seq of (char) \u0026 (forall echo1:bool \u0026 (true \u003d\u003e pre_(((io.freadval))[InputTP]filename))))","type compatibility obligation:(forall filename:seq of (char) \u0026 (forall echo1:bool \u0026 (true \u003d\u003e is_(input, seq of (inline)))))","while loop termination obligation:NotYetImplemented","non-empty sequence obligation:(inlines \u003c\u003e [])","non-empty sequence obligation:(forall echo2:bool \u0026 (true \u003d\u003e (forall echo3:bool \u0026 (true \u003d\u003e (forall echo6:bool \u0026 (true \u003d\u003e (forall echo8:bool \u0026 (true \u003d\u003e (forall echo10:bool \u0026 (true \u003d\u003e (forall echo12:bool \u0026 (true \u003d\u003e (forall echo14:bool \u0026 (true \u003d\u003e (forall echo15:bool \u0026 (true \u003d\u003e (forall echo16:bool \u0026 (true \u003d\u003e (inlines \u003c\u003e [])))))))))))))))))))","state invariant initialized obligation:(((((dom {|-\u003e}) inter (dom {|-\u003e})) \u003d {}) and (forall id in set (dom ctrlUnits) \u0026 ((ctrlUnits(id).GetVehicleID)() \u003d id))) and (forall id in set (dom lights) \u0026 ((lights(id).GetID)() \u003d id)))","state invariant satisfiable obligation:(exists ctrlUnits:inmap (nat) to (Controller), lights:inmap (nat) to (TrafficLight) \u0026 (((dom ctrlUnits) inter (dom lights)) \u003d {}))","state invariant initialized obligation:(((((dom {|-\u003e}) inter (dom {|-\u003e})) \u003d {}) and (forall id in set (dom ctrlUnits) \u0026 ((ctrlUnits(id).GetVehicleID)() \u003d id))) and (forall id in set (dom lights) \u0026 ((lights(id).GetID)() \u003d id)))","state invariant satisfiable obligation:(exists ctrlUnits:inmap (nat) to (Controller), lights:inmap (nat) to (TrafficLight) \u0026 (forall id in set (dom ctrlUnits) \u0026 ((ctrlUnits(id).GetVehicleID)() \u003d id)))","state invariant initialized obligation:(((((dom {|-\u003e}) inter (dom {|-\u003e})) \u003d {}) and (forall id in set (dom ctrlUnits) \u0026 ((ctrlUnits(id).GetVehicleID)() \u003d id))) and (forall id in set (dom lights) \u0026 ((lights(id).GetID)() \u003d id)))","state invariant satisfiable obligation:(exists ctrlUnits:inmap (nat) to (Controller), lights:inmap (nat) to (TrafficLight) \u0026 (forall id in set (dom lights) \u0026 ((lights(id).GetID)() \u003d id)))","state invariant holds obligation:(forall ctrl:Controller \u0026 (((ctrl.GetVehicleID)() not in set ((dom ctrlUnits) union (dom lights))) \u003d\u003e ((((((dom ctrlUnits) inter (dom lights)) \u003d {}) and (forall id in set (dom ctrlUnits) \u0026 ((ctrlUnits(id).GetVehicleID)() \u003d id))) and (forall id in set (dom lights) \u0026 ((lights(id).GetID)() \u003d id))) \u003d\u003e (((((dom (ctrlUnits munion {(ctrl.GetVehicleID)() |-\u003e ctrl})) inter (dom lights)) \u003d {}) and (forall id in set (dom ctrlUnits) \u0026 ((ctrlUnits(id).GetVehicleID)() \u003d id))) and (forall id in set (dom lights) \u0026 ((lights(id).GetID)() \u003d id))))))","map compatible obligation:(forall ctrl:Controller \u0026 (((ctrl.GetVehicleID)() not in set ((dom ctrlUnits) union (dom lights))) \u003d\u003e (forall ldom1 in set (dom ctrlUnits), rdom2 in set (dom {(ctrl.GetVehicleID)() |-\u003e ctrl}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (ctrlUnits(ldom1) \u003d {(ctrl.GetVehicleID)() |-\u003e ctrl}(rdom2))))))","type compatibility obligation:(forall ctrl:Controller \u0026 (((ctrl.GetVehicleID)() not in set ((dom ctrlUnits) union (dom lights))) \u003d\u003e is_((ctrlUnits munion {(ctrl.GetVehicleID)() |-\u003e ctrl}), inmap (nat) to (Controller))))","state invariant holds obligation:(forall light:TrafficLight \u0026 ((((light.GetID)() not in set (dom lights)) and ((light.GetID)() not in set (dom ctrlUnits))) \u003d\u003e ((((((dom ctrlUnits) inter (dom lights)) \u003d {}) and (forall id in set (dom ctrlUnits) \u0026 ((ctrlUnits(id).GetVehicleID)() \u003d id))) and (forall id in set (dom lights) \u0026 ((lights(id).GetID)() \u003d id))) \u003d\u003e (((((dom ctrlUnits) inter (dom (lights munion {(light.GetID)() |-\u003e light}))) \u003d {}) and (forall id in set (dom ctrlUnits) \u0026 ((ctrlUnits(id).GetVehicleID)() \u003d id))) and (forall id in set (dom lights) \u0026 ((lights(id).GetID)() \u003d id))))))","map compatible obligation:(forall light:TrafficLight \u0026 ((((light.GetID)() not in set (dom lights)) and ((light.GetID)() not in set (dom ctrlUnits))) \u003d\u003e (forall ldom1 in set (dom lights), rdom2 in set (dom {(light.GetID)() |-\u003e light}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (lights(ldom1) \u003d {(light.GetID)() |-\u003e light}(rdom2))))))","type compatibility obligation:(forall light:TrafficLight \u0026 ((((light.GetID)() not in set (dom lights)) and ((light.GetID)() not in set (dom ctrlUnits))) \u003d\u003e is_((lights munion {(light.GetID)() |-\u003e light}), inmap (nat) to (TrafficLight))))","legal map application obligation:(forall id:nat \u0026 ((id in set (dom ctrlUnits)) \u003d\u003e (id in set (dom ctrlUnits))))","legal map application obligation:(forall id:nat \u0026 ((id in set (dom lights)) \u003d\u003e (id in set (dom lights))))","cases exhaustive obligation:(forall d:Direction \u0026 ((((d \u003d \u003cNORTH\u003e) or (d \u003d \u003cSOUTH\u003e)) or (d \u003d \u003cEAST\u003e)) or (d \u003d \u003cWEST\u003e)))","state invariant holds obligation:(forall vehicle:Vehicle \u0026 ((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith) \u003c\u003d Config`TrafficDataKeeptNumber)))","state invariant holds obligation:(forall vdmUnitID:nat, data:seq of (TrafficData) \u0026 (((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith) \u003c\u003d Config`TrafficDataKeeptNumber)) \u003d\u003e ((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len (externalTrafficData ^ data)) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith) \u003c\u003d Config`TrafficDataKeeptNumber))))","state invariant holds obligation:(forall vdmUnitID:nat, data:seq of (TrafficData) \u0026 (((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len (externalTrafficData ^ data)) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith) \u003c\u003d Config`TrafficDataKeeptNumber)) \u003d\u003e ((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len ((tl (externalTrafficData ^ data)) ^ data)) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith) \u003c\u003d Config`TrafficDataKeeptNumber))))","non-empty sequence obligation:(forall vdmUnitID:nat, data:seq of (TrafficData) \u0026 ((externalTrafficData ^ data) \u003c\u003e []))","state invariant holds obligation:(forall vdmUnitID:nat, data:seq of (TrafficData) \u0026 (((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len ((tl (externalTrafficData ^ data)) ^ data)) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith) \u003c\u003d Config`TrafficDataKeeptNumber)) \u003d\u003e ((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len ((tl (externalTrafficData ^ data)) ^ data)) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len (communicatedWith ^ [vdmUnitID])) \u003c\u003d Config`TrafficDataKeeptNumber))))","state invariant holds obligation:(forall vdmUnitID:nat, data:seq of (TrafficData) \u0026 (((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len ((tl (externalTrafficData ^ data)) ^ data)) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len (communicatedWith ^ [vdmUnitID])) \u003c\u003d Config`TrafficDataKeeptNumber)) \u003d\u003e ((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len ((tl (externalTrafficData ^ data)) ^ data)) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len ((tl (communicatedWith ^ [vdmUnitID])) ^ [vdmUnitID])) \u003c\u003d Config`TrafficDataKeeptNumber))))","non-empty sequence obligation:(forall vdmUnitID:nat, data:seq of (TrafficData) \u0026 (communicatedWith \u003c\u003e []))","state invariant holds obligation:(forall data:TrafficData \u0026 (((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith) \u003c\u003d Config`TrafficDataKeeptNumber)) \u003d\u003e ((((len (internalTrafficData ^ [data])) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith) \u003c\u003d Config`TrafficDataKeeptNumber))))","state invariant holds obligation:(forall data:TrafficData \u0026 (((((len (internalTrafficData ^ [data])) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith) \u003c\u003d Config`TrafficDataKeeptNumber)) \u003d\u003e ((((len ((tl (internalTrafficData ^ [data])) ^ [data])) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith) \u003c\u003d Config`TrafficDataKeeptNumber))))","non-empty sequence obligation:(forall data:TrafficData \u0026 ((internalTrafficData ^ [data]) \u003c\u003e []))","legal sequence application obligation:(forall i in set (inds internalTrafficData) \u0026 (i in set (inds internalTrafficData)))","legal sequence application obligation:(forall i in set (inds internalTrafficData) \u0026 (i in set (inds internalTrafficData)))","legal sequence application obligation:(forall i in set (inds internalTrafficData) \u0026 (i in set (inds internalTrafficData)))","state invariant holds obligation:(((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith) \u003c\u003d Config`TrafficDataKeeptNumber)) \u003d\u003e ((((len [internalTrafficData(i) | i in set (inds internalTrafficData) \u0026 (internalTrafficData(i) \u003c\u003e td)]) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith) \u003c\u003d Config`TrafficDataKeeptNumber)))","legal sequence application obligation:(forall i in set (inds internalTrafficData) \u0026 ((internalTrafficData(i) \u003c\u003e td) \u003d\u003e (i in set (inds internalTrafficData))))","legal sequence application obligation:(forall i in set (inds internalTrafficData) \u0026 (i in set (inds internalTrafficData)))","legal sequence application obligation:(1 in set (inds vs))","operation call obligation:(forall text:seq of (char) \u0026 ((\"\" \u003d \"\") \u003c\u003d\u003e (\"\" \u003d nil)))"] \ No newline at end of file +["state invariant initialized obligation:((len []) \u003c\u003d 5)","state invariant satisfiable obligation:(exists vehicles:seq of (Vehicle) \u0026 ((len vehicles) \u003c\u003d 5))","state invariant holds obligation:(forall vehicle:Vehicle \u0026 ((vehicle not in set (elems vehicles)) \u003d\u003e (((len vehicles) \u003c\u003d 5) \u003d\u003e ((len (vehicles ^ [vehicle])) \u003c\u003d 5))))","state invariant holds obligation:(forall vehicle:Vehicle \u0026 ((vehicle not in set (elems vehicles)) \u003d\u003e (((len (vehicles ^ [vehicle])) \u003c\u003d 5) \u003d\u003e ((len ((tl (vehicles ^ [vehicle])) ^ [vehicle])) \u003c\u003d 5))))","non-empty sequence obligation:(forall vehicle:Vehicle \u0026 ((vehicle not in set (elems vehicles)) \u003d\u003e ((vehicles ^ [vehicle]) \u003c\u003e [])))","state invariant holds obligation:(((len vehicles) \u003c\u003d 5) \u003d\u003e ((len vehicles) \u003c\u003d 5))","state invariant holds obligation:(forall vs:set of (Vehicle) \u0026 (((card vs) \u003c\u003e 0) \u003d\u003e (((len vehicles) \u003c\u003d 5) \u003d\u003e ((len vehicles) \u003c\u003d 5))))","non-zero obligation:(forall vs:set of (Vehicle) \u0026 (((card vs) \u003c\u003e 0) \u003d\u003e ((card vs) \u003c\u003e 0)))","type compatibility obligation:(forall vs:set of (Vehicle) \u0026 (((card vs) \u003c\u003e 0) \u003d\u003e is_(RESULT, nat)))","legal sequence application obligation:(1 in set (inds vs))","legal sequence application obligation:(2 in set (inds vs))","legal sequence application obligation:(1 in set (inds vs))","legal sequence application obligation:(2 in set (inds vs))","legal sequence application obligation:(3 in set (inds vs))","cases exhaustive obligation:(forall d:Direction \u0026 ((((d \u003d \u003cNORTH\u003e) or (d \u003d \u003cSOUTH\u003e)) or (d \u003d \u003cEAST\u003e)) or (d \u003d \u003cWEST\u003e)))","legal sequence application obligation:(1 in set (inds vs))","cases exhaustive obligation:(forall d:Direction \u0026 ((((d \u003d \u003cNORTH\u003e) or (d \u003d \u003cSOUTH\u003e)) or (d \u003d \u003cEAST\u003e)) or (d \u003d \u003cWEST\u003e)))","cases exhaustive obligation:(forall i:Indicator \u0026 (((i \u003d \u003cLEFT\u003e) or (i \u003d \u003cRIGHT\u003e)) or (i \u003d \u003cNONE\u003e)))","cases exhaustive obligation:(forall m:MessageType \u0026 ((((m \u003d \u003cLowGrip\u003e) or (m \u003d \u003cCongestion\u003e)) or (m \u003d \u003cLeftTurn\u003e)) or (m \u003d \u003cRedLight\u003e)))","legal function application obligation:(forall filename:seq of (char) \u0026 (forall echo1:bool \u0026 (true \u003d\u003e pre_(((io.freadval))[InputTP]filename))))","type compatibility obligation:(forall filename:seq of (char) \u0026 (forall echo1:bool \u0026 (true \u003d\u003e is_(input, seq of (inline)))))","while loop termination obligation:...","non-empty sequence obligation:(inlines \u003c\u003e [])","non-empty sequence obligation:(forall echo2:bool \u0026 (true \u003d\u003e (forall echo3:bool \u0026 (true \u003d\u003e (forall echo6:bool \u0026 (true \u003d\u003e (forall echo8:bool \u0026 (true \u003d\u003e (forall echo10:bool \u0026 (true \u003d\u003e (forall echo12:bool \u0026 (true \u003d\u003e (forall echo14:bool \u0026 (true \u003d\u003e (forall echo15:bool \u0026 (true \u003d\u003e (forall echo16:bool \u0026 (true \u003d\u003e (inlines \u003c\u003e [])))))))))))))))))))","state invariant initialized obligation:(((((dom {|-\u003e}) inter (dom {|-\u003e})) \u003d {}) and (forall id in set (dom ctrlUnits) \u0026 ((ctrlUnits(id).GetVehicleID)() \u003d id))) and (forall id in set (dom lights) \u0026 ((lights(id).GetID)() \u003d id)))","state invariant satisfiable obligation:(exists ctrlUnits:inmap (nat) to (Controller), lights:inmap (nat) to (TrafficLight) \u0026 (((dom ctrlUnits) inter (dom lights)) \u003d {}))","state invariant initialized obligation:(((((dom {|-\u003e}) inter (dom {|-\u003e})) \u003d {}) and (forall id in set (dom ctrlUnits) \u0026 ((ctrlUnits(id).GetVehicleID)() \u003d id))) and (forall id in set (dom lights) \u0026 ((lights(id).GetID)() \u003d id)))","state invariant satisfiable obligation:(exists ctrlUnits:inmap (nat) to (Controller), lights:inmap (nat) to (TrafficLight) \u0026 (forall id in set (dom ctrlUnits) \u0026 ((ctrlUnits(id).GetVehicleID)() \u003d id)))","state invariant initialized obligation:(((((dom {|-\u003e}) inter (dom {|-\u003e})) \u003d {}) and (forall id in set (dom ctrlUnits) \u0026 ((ctrlUnits(id).GetVehicleID)() \u003d id))) and (forall id in set (dom lights) \u0026 ((lights(id).GetID)() \u003d id)))","state invariant satisfiable obligation:(exists ctrlUnits:inmap (nat) to (Controller), lights:inmap (nat) to (TrafficLight) \u0026 (forall id in set (dom lights) \u0026 ((lights(id).GetID)() \u003d id)))","state invariant holds obligation:(forall ctrl:Controller \u0026 (((ctrl.GetVehicleID)() not in set ((dom ctrlUnits) union (dom lights))) \u003d\u003e ((((((dom ctrlUnits) inter (dom lights)) \u003d {}) and (forall id in set (dom ctrlUnits) \u0026 ((ctrlUnits(id).GetVehicleID)() \u003d id))) and (forall id in set (dom lights) \u0026 ((lights(id).GetID)() \u003d id))) \u003d\u003e (((((dom (ctrlUnits munion {(ctrl.GetVehicleID)() |-\u003e ctrl})) inter (dom lights)) \u003d {}) and (forall id in set (dom ctrlUnits) \u0026 ((ctrlUnits(id).GetVehicleID)() \u003d id))) and (forall id in set (dom lights) \u0026 ((lights(id).GetID)() \u003d id))))))","map compatible obligation:(forall ctrl:Controller \u0026 (((ctrl.GetVehicleID)() not in set ((dom ctrlUnits) union (dom lights))) \u003d\u003e (forall ldom1 in set (dom ctrlUnits), rdom2 in set (dom {(ctrl.GetVehicleID)() |-\u003e ctrl}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (ctrlUnits(ldom1) \u003d {(ctrl.GetVehicleID)() |-\u003e ctrl}(rdom2))))))","type compatibility obligation:(forall ctrl:Controller \u0026 (((ctrl.GetVehicleID)() not in set ((dom ctrlUnits) union (dom lights))) \u003d\u003e is_((ctrlUnits munion {(ctrl.GetVehicleID)() |-\u003e ctrl}), inmap (nat) to (Controller))))","state invariant holds obligation:(forall light:TrafficLight \u0026 ((((light.GetID)() not in set (dom lights)) and ((light.GetID)() not in set (dom ctrlUnits))) \u003d\u003e ((((((dom ctrlUnits) inter (dom lights)) \u003d {}) and (forall id in set (dom ctrlUnits) \u0026 ((ctrlUnits(id).GetVehicleID)() \u003d id))) and (forall id in set (dom lights) \u0026 ((lights(id).GetID)() \u003d id))) \u003d\u003e (((((dom ctrlUnits) inter (dom (lights munion {(light.GetID)() |-\u003e light}))) \u003d {}) and (forall id in set (dom ctrlUnits) \u0026 ((ctrlUnits(id).GetVehicleID)() \u003d id))) and (forall id in set (dom lights) \u0026 ((lights(id).GetID)() \u003d id))))))","map compatible obligation:(forall light:TrafficLight \u0026 ((((light.GetID)() not in set (dom lights)) and ((light.GetID)() not in set (dom ctrlUnits))) \u003d\u003e (forall ldom1 in set (dom lights), rdom2 in set (dom {(light.GetID)() |-\u003e light}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (lights(ldom1) \u003d {(light.GetID)() |-\u003e light}(rdom2))))))","type compatibility obligation:(forall light:TrafficLight \u0026 ((((light.GetID)() not in set (dom lights)) and ((light.GetID)() not in set (dom ctrlUnits))) \u003d\u003e is_((lights munion {(light.GetID)() |-\u003e light}), inmap (nat) to (TrafficLight))))","legal map application obligation:(forall id:nat \u0026 ((id in set (dom ctrlUnits)) \u003d\u003e (id in set (dom ctrlUnits))))","legal map application obligation:(forall id:nat \u0026 ((id in set (dom lights)) \u003d\u003e (id in set (dom lights))))","cases exhaustive obligation:(forall d:Direction \u0026 ((((d \u003d \u003cNORTH\u003e) or (d \u003d \u003cSOUTH\u003e)) or (d \u003d \u003cEAST\u003e)) or (d \u003d \u003cWEST\u003e)))","state invariant holds obligation:(forall vehicle:Vehicle \u0026 ((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith) \u003c\u003d Config`TrafficDataKeeptNumber)))","state invariant holds obligation:(forall vdmUnitID:nat, data:seq of (TrafficData) \u0026 (((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith) \u003c\u003d Config`TrafficDataKeeptNumber)) \u003d\u003e ((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len (externalTrafficData ^ data)) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith) \u003c\u003d Config`TrafficDataKeeptNumber))))","state invariant holds obligation:(forall vdmUnitID:nat, data:seq of (TrafficData) \u0026 (((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len (externalTrafficData ^ data)) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith) \u003c\u003d Config`TrafficDataKeeptNumber)) \u003d\u003e ((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len ((tl (externalTrafficData ^ data)) ^ data)) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith) \u003c\u003d Config`TrafficDataKeeptNumber))))","non-empty sequence obligation:(forall vdmUnitID:nat, data:seq of (TrafficData) \u0026 ((externalTrafficData ^ data) \u003c\u003e []))","state invariant holds obligation:(forall vdmUnitID:nat, data:seq of (TrafficData) \u0026 (((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len ((tl (externalTrafficData ^ data)) ^ data)) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith) \u003c\u003d Config`TrafficDataKeeptNumber)) \u003d\u003e ((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len ((tl (externalTrafficData ^ data)) ^ data)) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len (communicatedWith ^ [vdmUnitID])) \u003c\u003d Config`TrafficDataKeeptNumber))))","state invariant holds obligation:(forall vdmUnitID:nat, data:seq of (TrafficData) \u0026 (((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len ((tl (externalTrafficData ^ data)) ^ data)) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len (communicatedWith ^ [vdmUnitID])) \u003c\u003d Config`TrafficDataKeeptNumber)) \u003d\u003e ((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len ((tl (externalTrafficData ^ data)) ^ data)) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len ((tl (communicatedWith ^ [vdmUnitID])) ^ [vdmUnitID])) \u003c\u003d Config`TrafficDataKeeptNumber))))","non-empty sequence obligation:(forall vdmUnitID:nat, data:seq of (TrafficData) \u0026 (communicatedWith \u003c\u003e []))","state invariant holds obligation:(forall data:TrafficData \u0026 (((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith) \u003c\u003d Config`TrafficDataKeeptNumber)) \u003d\u003e ((((len (internalTrafficData ^ [data])) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith) \u003c\u003d Config`TrafficDataKeeptNumber))))","state invariant holds obligation:(forall data:TrafficData \u0026 (((((len (internalTrafficData ^ [data])) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith) \u003c\u003d Config`TrafficDataKeeptNumber)) \u003d\u003e ((((len ((tl (internalTrafficData ^ [data])) ^ [data])) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith) \u003c\u003d Config`TrafficDataKeeptNumber))))","non-empty sequence obligation:(forall data:TrafficData \u0026 ((internalTrafficData ^ [data]) \u003c\u003e []))","legal sequence application obligation:(forall i in set (inds internalTrafficData) \u0026 (i in set (inds internalTrafficData)))","legal sequence application obligation:(forall i in set (inds internalTrafficData) \u0026 (i in set (inds internalTrafficData)))","legal sequence application obligation:(forall i in set (inds internalTrafficData) \u0026 (i in set (inds internalTrafficData)))","state invariant holds obligation:(((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith) \u003c\u003d Config`TrafficDataKeeptNumber)) \u003d\u003e ((((len [internalTrafficData(i) | i in set (inds internalTrafficData) \u0026 (internalTrafficData(i) \u003c\u003e td)]) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith) \u003c\u003d Config`TrafficDataKeeptNumber)))","legal sequence application obligation:(forall i in set (inds internalTrafficData) \u0026 ((internalTrafficData(i) \u003c\u003e td) \u003d\u003e (i in set (inds internalTrafficData))))","legal sequence application obligation:(forall i in set (inds internalTrafficData) \u0026 (i in set (inds internalTrafficData)))","legal sequence application obligation:(1 in set (inds vs))","operation call obligation:(forall text:seq of (char) \u0026 ((\"\" \u003d \"\") \u003c\u003d\u003e (\"\" \u003d nil)))"] \ No newline at end of file diff --git a/core/pog/src/test/resources/examples/VeMoRT.result b/core/pog/src/test/resources/examples/VeMoRT.result index 768b4345e9..fae2ce8e00 100644 --- a/core/pog/src/test/resources/examples/VeMoRT.result +++ b/core/pog/src/test/resources/examples/VeMoRT.result @@ -1 +1 @@ -["legal sequence application obligation:(1 in set (inds vs))","state invariant initialized obligation:((len []) \u003c\u003d 5)","state invariant satisfiable obligation:(exists vehicles:seq of (Vehicle) \u0026 ((len vehicles) \u003c\u003d 5))","state invariant holds obligation:(forall vehicle:Vehicle \u0026 ((vehicle not in set (elems vehicles)) \u003d\u003e (((len vehicles) \u003c\u003d 5) \u003d\u003e ((len (vehicles ^ [vehicle])) \u003c\u003d 5))))","state invariant holds obligation:(forall vehicle:Vehicle \u0026 ((vehicle not in set (elems vehicles)) \u003d\u003e (((len (vehicles ^ [vehicle])) \u003c\u003d 5) \u003d\u003e ((len ((tl (vehicles ^ [vehicle])) ^ [vehicle])) \u003c\u003d 5))))","non-empty sequence obligation:(forall vehicle:Vehicle \u0026 ((vehicle not in set (elems vehicles)) \u003d\u003e ((vehicles ^ [vehicle]) \u003c\u003e [])))","state invariant holds obligation:(((len vehicles) \u003c\u003d 5) \u003d\u003e ((len vehicles) \u003c\u003d 5))","state invariant holds obligation:(forall vs:set of (Vehicle) \u0026 (((card vs) \u003c\u003e 0) \u003d\u003e (((len vehicles) \u003c\u003d 5) \u003d\u003e ((len vehicles) \u003c\u003d 5))))","non-zero obligation:(forall vs:set of (Vehicle) \u0026 (((card vs) \u003c\u003e 0) \u003d\u003e ((card vs) \u003c\u003e 0)))","type compatibility obligation:(forall vs:set of (Vehicle) \u0026 (((card vs) \u003c\u003e 0) \u003d\u003e is_(RESULT, nat)))","legal sequence application obligation:(1 in set (inds vs))","legal sequence application obligation:(2 in set (inds vs))","legal sequence application obligation:(1 in set (inds vs))","legal sequence application obligation:(2 in set (inds vs))","legal sequence application obligation:(3 in set (inds vs))","cases exhaustive obligation:(forall d:Direction \u0026 ((((d \u003d \u003cNORTH\u003e) or (d \u003d \u003cSOUTH\u003e)) or (d \u003d \u003cEAST\u003e)) or (d \u003d \u003cWEST\u003e)))","legal sequence application obligation:(1 in set (inds vs))","cases exhaustive obligation:(forall d:Direction \u0026 ((((d \u003d \u003cNORTH\u003e) or (d \u003d \u003cSOUTH\u003e)) or (d \u003d \u003cEAST\u003e)) or (d \u003d \u003cWEST\u003e)))","cases exhaustive obligation:(forall d:Direction \u0026 ((((d \u003d \u003cNORTH\u003e) or (d \u003d \u003cSOUTH\u003e)) or (d \u003d \u003cEAST\u003e)) or (d \u003d \u003cWEST\u003e)))","cases exhaustive obligation:(forall i:Indicator \u0026 (((i \u003d \u003cLEFT\u003e) or (i \u003d \u003cRIGHT\u003e)) or (i \u003d \u003cNONE\u003e)))","cases exhaustive obligation:(forall m:MessageType \u0026 ((((m \u003d \u003cLowGrip\u003e) or (m \u003d \u003cCongestion\u003e)) or (m \u003d \u003cLeftTurn\u003e)) or (m \u003d \u003cRedLight\u003e)))","legal function application obligation:(forall filename:seq of (char) \u0026 (forall echo1:bool \u0026 (true \u003d\u003e pre_(((io.freadval))[InputTP]filename))))","type compatibility obligation:(forall filename:seq of (char) \u0026 (forall echo1:bool \u0026 (true \u003d\u003e is_(input, seq of (inline)))))","while loop termination obligation:NotYetImplemented","non-empty sequence obligation:(inlines \u003c\u003e [])","non-empty sequence obligation:(forall echo2:bool \u0026 (true \u003d\u003e (forall echo3:bool \u0026 (true \u003d\u003e (forall echo6:bool \u0026 (true \u003d\u003e (forall echo8:bool \u0026 (true \u003d\u003e (forall echo10:bool \u0026 (true \u003d\u003e (forall echo12:bool \u0026 (true \u003d\u003e (forall echo14:bool \u0026 (true \u003d\u003e (forall echo15:bool \u0026 (true \u003d\u003e (forall echo16:bool \u0026 (true \u003d\u003e (inlines \u003c\u003e [])))))))))))))))))))","type compatibility obligation:is_(World`env, Environment)","state invariant holds obligation:(((((dom ctrlUnits) inter (dom lights)) \u003d {}) and (forall id in set (dom ctrlUnits) \u0026 ((ctrlUnits(id).GetVehicleID)() \u003d id))) and (forall id in set (dom lights) \u0026 ((lights(id).GetID)() \u003d id)))","state invariant holds obligation:(forall ctrl:Controller \u0026 (((ctrl.GetVehicleID)() not in set ((dom ctrlUnits) union (dom lights))) \u003d\u003e ((((((dom ctrlUnits) inter (dom lights)) \u003d {}) and (forall id in set (dom ctrlUnits) \u0026 ((ctrlUnits(id).GetVehicleID)() \u003d id))) and (forall id in set (dom lights) \u0026 ((lights(id).GetID)() \u003d id))) \u003d\u003e (((((dom (ctrlUnits munion {(ctrl.GetVehicleID)() |-\u003e ctrl})) inter (dom lights)) \u003d {}) and (forall id in set (dom ctrlUnits) \u0026 ((ctrlUnits(id).GetVehicleID)() \u003d id))) and (forall id in set (dom lights) \u0026 ((lights(id).GetID)() \u003d id))))))","map compatible obligation:(forall ctrl:Controller \u0026 (((ctrl.GetVehicleID)() not in set ((dom ctrlUnits) union (dom lights))) \u003d\u003e (forall ldom1 in set (dom ctrlUnits), rdom2 in set (dom {(ctrl.GetVehicleID)() |-\u003e ctrl}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (ctrlUnits(ldom1) \u003d {(ctrl.GetVehicleID)() |-\u003e ctrl}(rdom2))))))","type compatibility obligation:(forall ctrl:Controller \u0026 (((ctrl.GetVehicleID)() not in set ((dom ctrlUnits) union (dom lights))) \u003d\u003e is_((ctrlUnits munion {(ctrl.GetVehicleID)() |-\u003e ctrl}), inmap (nat) to (Controller))))","type compatibility obligation:(forall ctrl:Controller \u0026 (((ctrl.GetVehicleID)() not in set ((dom ctrlUnits) union (dom lights))) \u003d\u003e (((is_(dir, \u003cEAST\u003e) or is_(dir, \u003cNORTH\u003e)) or is_(dir, \u003cSOUTH\u003e)) or is_(dir, \u003cWEST\u003e))))","state invariant holds obligation:(forall light:TrafficLight \u0026 ((((light.GetID)() not in set (dom lights)) and ((light.GetID)() not in set (dom ctrlUnits))) \u003d\u003e ((((((dom ctrlUnits) inter (dom lights)) \u003d {}) and (forall id in set (dom ctrlUnits) \u0026 ((ctrlUnits(id).GetVehicleID)() \u003d id))) and (forall id in set (dom lights) \u0026 ((lights(id).GetID)() \u003d id))) \u003d\u003e (((((dom ctrlUnits) inter (dom (lights munion {(light.GetID)() |-\u003e light}))) \u003d {}) and (forall id in set (dom ctrlUnits) \u0026 ((ctrlUnits(id).GetVehicleID)() \u003d id))) and (forall id in set (dom lights) \u0026 ((lights(id).GetID)() \u003d id))))))","map compatible obligation:(forall light:TrafficLight \u0026 ((((light.GetID)() not in set (dom lights)) and ((light.GetID)() not in set (dom ctrlUnits))) \u003d\u003e (forall ldom1 in set (dom lights), rdom2 in set (dom {(light.GetID)() |-\u003e light}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (lights(ldom1) \u003d {(light.GetID)() |-\u003e light}(rdom2))))))","type compatibility obligation:(forall light:TrafficLight \u0026 ((((light.GetID)() not in set (dom lights)) and ((light.GetID)() not in set (dom ctrlUnits))) \u003d\u003e is_((lights munion {(light.GetID)() |-\u003e light}), inmap (nat) to (TrafficLight))))","legal map application obligation:(forall id:nat \u0026 ((id in set (dom ctrlUnits)) \u003d\u003e (id in set (dom ctrlUnits))))","legal map application obligation:(forall id:nat \u0026 ((id in set (dom lights)) \u003d\u003e (id in set (dom lights))))","type compatibility obligation:(((is_(dir, \u003cEAST\u003e) or is_(dir, \u003cNORTH\u003e)) or is_(dir, \u003cSOUTH\u003e)) or is_(dir, \u003cWEST\u003e))","cases exhaustive obligation:(forall d:Direction \u0026 ((((d \u003d \u003cNORTH\u003e) or (d \u003d \u003cSOUTH\u003e)) or (d \u003d \u003cEAST\u003e)) or (d \u003d \u003cWEST\u003e)))","type compatibility obligation:(forall u:Controller, us:set of (Controller) \u0026 (((is_((u.GetDirection)(), \u003cEAST\u003e) or is_((u.GetDirection)(), \u003cNORTH\u003e)) or is_((u.GetDirection)(), \u003cSOUTH\u003e)) or is_((u.GetDirection)(), \u003cWEST\u003e)))","legal function application obligation:(forall p:Position, range:int \u0026 pre_sqrt(((xd * xd) + (yd * yd))))","state invariant holds obligation:(forall vehicle:Vehicle \u0026 ((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith) \u003c\u003d Config`TrafficDataKeeptNumber)))","state invariant holds obligation:(forall vemoUnitID:nat, data:seq of (TrafficData) \u0026 (((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith) \u003c\u003d Config`TrafficDataKeeptNumber)) \u003d\u003e ((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len (communicatedWith ^ [vemoUnitID])) \u003c\u003d Config`TrafficDataKeeptNumber))))","state invariant holds obligation:(forall vemoUnitID:nat, data:seq of (TrafficData) \u0026 (((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len (communicatedWith ^ [vemoUnitID])) \u003c\u003d Config`TrafficDataKeeptNumber)) \u003d\u003e ((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len ((tl (communicatedWith ^ [vemoUnitID])) ^ [vemoUnitID])) \u003c\u003d Config`TrafficDataKeeptNumber))))","non-empty sequence obligation:(forall vemoUnitID:nat, data:seq of (TrafficData) \u0026 ((communicatedWith ^ [vemoUnitID]) \u003c\u003e []))","state invariant holds obligation:(forall vemoUnitID:nat, data:seq of (TrafficData) \u0026 (((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len ((tl (communicatedWith ^ [vemoUnitID])) ^ [vemoUnitID])) \u003c\u003d Config`TrafficDataKeeptNumber)) \u003d\u003e ((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len (externalTrafficData ^ data)) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len ((tl (communicatedWith ^ [vemoUnitID])) ^ [vemoUnitID])) \u003c\u003d Config`TrafficDataKeeptNumber))))","state invariant holds obligation:(forall vemoUnitID:nat, data:seq of (TrafficData) \u0026 (((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len (externalTrafficData ^ data)) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len ((tl (communicatedWith ^ [vemoUnitID])) ^ [vemoUnitID])) \u003c\u003d Config`TrafficDataKeeptNumber)) \u003d\u003e ((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len ((tl (externalTrafficData ^ data)) ^ data)) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len ((tl (communicatedWith ^ [vemoUnitID])) ^ [vemoUnitID])) \u003c\u003d Config`TrafficDataKeeptNumber))))","non-empty sequence obligation:(forall vemoUnitID:nat, data:seq of (TrafficData) \u0026 ((externalTrafficData ^ data) \u003c\u003e []))","state invariant holds obligation:(forall data:TrafficData \u0026 (((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith) \u003c\u003d Config`TrafficDataKeeptNumber)) \u003d\u003e ((((len (internalTrafficData ^ [data])) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith) \u003c\u003d Config`TrafficDataKeeptNumber))))","state invariant holds obligation:(forall data:TrafficData \u0026 (((((len (internalTrafficData ^ [data])) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith) \u003c\u003d Config`TrafficDataKeeptNumber)) \u003d\u003e ((((len ((tl (internalTrafficData ^ [data])) ^ [data])) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith) \u003c\u003d Config`TrafficDataKeeptNumber))))","non-empty sequence obligation:(forall data:TrafficData \u0026 ((internalTrafficData ^ [data]) \u003c\u003e []))","legal sequence application obligation:(forall i in set (inds internalTrafficData) \u0026 (i in set (inds internalTrafficData)))","legal sequence application obligation:(forall i in set (inds internalTrafficData) \u0026 (i in set (inds internalTrafficData)))","legal sequence application obligation:(forall i in set (inds internalTrafficData) \u0026 (i in set (inds internalTrafficData)))","state invariant holds obligation:(((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith) \u003c\u003d Config`TrafficDataKeeptNumber)) \u003d\u003e ((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith) \u003c\u003d Config`TrafficDataKeeptNumber)))","state invariant holds obligation:(((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith) \u003c\u003d Config`TrafficDataKeeptNumber)) \u003d\u003e ((((len [internalTrafficData(i) | i in set (inds internalTrafficData) \u0026 (internalTrafficData(i) \u003c\u003e td)]) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith) \u003c\u003d Config`TrafficDataKeeptNumber)))","legal sequence application obligation:(forall i in set (inds internalTrafficData) \u0026 ((internalTrafficData(i) \u003c\u003e td) \u003d\u003e (i in set (inds internalTrafficData))))","legal sequence application obligation:(forall i in set (inds internalTrafficData) \u0026 (i in set (inds internalTrafficData)))","type compatibility obligation:(((vemoVehicle.GetSpeed)() \u003d 0) \u003d\u003e (forall data in set (elems internalTrafficData) \u0026 is_(GetPosition(), Position)))","type compatibility obligation:(forall internalTrafficData25:seq of (TrafficData), externalTrafficData26:seq of (TrafficData), communicatedWith27:seq of (nat), traffic28:Traffic, vemoVehicle29:Vehicle, canRun30:bool \u0026 (((((len internalTrafficData25) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData26) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith27) \u003c\u003d Config`TrafficDataKeeptNumber)) \u003d\u003e (((vemoVehicle.GetSpeed)() \u003d 0) \u003d\u003e (forall data in set (elems internalTrafficData) \u0026 is_(GetPosition(), Position)))))","type compatibility obligation:(forall internalTrafficData25:seq of (TrafficData), externalTrafficData26:seq of (TrafficData), communicatedWith27:seq of (nat), traffic28:Traffic, vemoVehicle29:Vehicle, canRun30:bool \u0026 (((((len internalTrafficData25) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData26) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith27) \u003c\u003d Config`TrafficDataKeeptNumber)) \u003d\u003e (forall internalTrafficData49:seq of (TrafficData), externalTrafficData50:seq of (TrafficData), communicatedWith51:seq of (nat), traffic52:Traffic, vemoVehicle53:Vehicle, canRun54:bool \u0026 (((((len internalTrafficData49) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData50) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith51) \u003c\u003d Config`TrafficDataKeeptNumber)) \u003d\u003e (((vemoVehicle.GetSpeed)() \u003d 0) \u003d\u003e (forall data in set (elems internalTrafficData) \u0026 is_(GetPosition(), Position)))))))","type compatibility obligation:is_(World`env, Environment)","operation call obligation:(forall text:seq of (char) \u0026 ((\"\" \u003d \"\") \u003c\u003d\u003e (\"\" \u003d nil)))","non-zero obligation:(forall a:real \u0026 ((a \u003c\u003e 0) \u003d\u003e (a \u003c\u003e 0)))"] \ No newline at end of file +["legal sequence application obligation:(1 in set (inds vs))","state invariant initialized obligation:((len []) \u003c\u003d 5)","state invariant satisfiable obligation:(exists vehicles:seq of (Vehicle) \u0026 ((len vehicles) \u003c\u003d 5))","state invariant holds obligation:(forall vehicle:Vehicle \u0026 ((vehicle not in set (elems vehicles)) \u003d\u003e (((len vehicles) \u003c\u003d 5) \u003d\u003e ((len (vehicles ^ [vehicle])) \u003c\u003d 5))))","state invariant holds obligation:(forall vehicle:Vehicle \u0026 ((vehicle not in set (elems vehicles)) \u003d\u003e (((len (vehicles ^ [vehicle])) \u003c\u003d 5) \u003d\u003e ((len ((tl (vehicles ^ [vehicle])) ^ [vehicle])) \u003c\u003d 5))))","non-empty sequence obligation:(forall vehicle:Vehicle \u0026 ((vehicle not in set (elems vehicles)) \u003d\u003e ((vehicles ^ [vehicle]) \u003c\u003e [])))","state invariant holds obligation:(((len vehicles) \u003c\u003d 5) \u003d\u003e ((len vehicles) \u003c\u003d 5))","state invariant holds obligation:(forall vs:set of (Vehicle) \u0026 (((card vs) \u003c\u003e 0) \u003d\u003e (((len vehicles) \u003c\u003d 5) \u003d\u003e ((len vehicles) \u003c\u003d 5))))","non-zero obligation:(forall vs:set of (Vehicle) \u0026 (((card vs) \u003c\u003e 0) \u003d\u003e ((card vs) \u003c\u003e 0)))","type compatibility obligation:(forall vs:set of (Vehicle) \u0026 (((card vs) \u003c\u003e 0) \u003d\u003e is_(RESULT, nat)))","legal sequence application obligation:(1 in set (inds vs))","legal sequence application obligation:(2 in set (inds vs))","legal sequence application obligation:(1 in set (inds vs))","legal sequence application obligation:(2 in set (inds vs))","legal sequence application obligation:(3 in set (inds vs))","cases exhaustive obligation:(forall d:Direction \u0026 ((((d \u003d \u003cNORTH\u003e) or (d \u003d \u003cSOUTH\u003e)) or (d \u003d \u003cEAST\u003e)) or (d \u003d \u003cWEST\u003e)))","legal sequence application obligation:(1 in set (inds vs))","cases exhaustive obligation:(forall d:Direction \u0026 ((((d \u003d \u003cNORTH\u003e) or (d \u003d \u003cSOUTH\u003e)) or (d \u003d \u003cEAST\u003e)) or (d \u003d \u003cWEST\u003e)))","cases exhaustive obligation:(forall d:Direction \u0026 ((((d \u003d \u003cNORTH\u003e) or (d \u003d \u003cSOUTH\u003e)) or (d \u003d \u003cEAST\u003e)) or (d \u003d \u003cWEST\u003e)))","cases exhaustive obligation:(forall i:Indicator \u0026 (((i \u003d \u003cLEFT\u003e) or (i \u003d \u003cRIGHT\u003e)) or (i \u003d \u003cNONE\u003e)))","cases exhaustive obligation:(forall m:MessageType \u0026 ((((m \u003d \u003cLowGrip\u003e) or (m \u003d \u003cCongestion\u003e)) or (m \u003d \u003cLeftTurn\u003e)) or (m \u003d \u003cRedLight\u003e)))","legal function application obligation:(forall filename:seq of (char) \u0026 (forall echo1:bool \u0026 (true \u003d\u003e pre_(((io.freadval))[InputTP]filename))))","type compatibility obligation:(forall filename:seq of (char) \u0026 (forall echo1:bool \u0026 (true \u003d\u003e is_(input, seq of (inline)))))","while loop termination obligation:...","non-empty sequence obligation:(inlines \u003c\u003e [])","non-empty sequence obligation:(forall echo2:bool \u0026 (true \u003d\u003e (forall echo3:bool \u0026 (true \u003d\u003e (forall echo6:bool \u0026 (true \u003d\u003e (forall echo8:bool \u0026 (true \u003d\u003e (forall echo10:bool \u0026 (true \u003d\u003e (forall echo12:bool \u0026 (true \u003d\u003e (forall echo14:bool \u0026 (true \u003d\u003e (forall echo15:bool \u0026 (true \u003d\u003e (forall echo16:bool \u0026 (true \u003d\u003e (inlines \u003c\u003e [])))))))))))))))))))","type compatibility obligation:is_(World`env, Environment)","state invariant holds obligation:(((((dom ctrlUnits) inter (dom lights)) \u003d {}) and (forall id in set (dom ctrlUnits) \u0026 ((ctrlUnits(id).GetVehicleID)() \u003d id))) and (forall id in set (dom lights) \u0026 ((lights(id).GetID)() \u003d id)))","state invariant holds obligation:(forall ctrl:Controller \u0026 (((ctrl.GetVehicleID)() not in set ((dom ctrlUnits) union (dom lights))) \u003d\u003e ((((((dom ctrlUnits) inter (dom lights)) \u003d {}) and (forall id in set (dom ctrlUnits) \u0026 ((ctrlUnits(id).GetVehicleID)() \u003d id))) and (forall id in set (dom lights) \u0026 ((lights(id).GetID)() \u003d id))) \u003d\u003e (((((dom (ctrlUnits munion {(ctrl.GetVehicleID)() |-\u003e ctrl})) inter (dom lights)) \u003d {}) and (forall id in set (dom ctrlUnits) \u0026 ((ctrlUnits(id).GetVehicleID)() \u003d id))) and (forall id in set (dom lights) \u0026 ((lights(id).GetID)() \u003d id))))))","map compatible obligation:(forall ctrl:Controller \u0026 (((ctrl.GetVehicleID)() not in set ((dom ctrlUnits) union (dom lights))) \u003d\u003e (forall ldom1 in set (dom ctrlUnits), rdom2 in set (dom {(ctrl.GetVehicleID)() |-\u003e ctrl}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (ctrlUnits(ldom1) \u003d {(ctrl.GetVehicleID)() |-\u003e ctrl}(rdom2))))))","type compatibility obligation:(forall ctrl:Controller \u0026 (((ctrl.GetVehicleID)() not in set ((dom ctrlUnits) union (dom lights))) \u003d\u003e is_((ctrlUnits munion {(ctrl.GetVehicleID)() |-\u003e ctrl}), inmap (nat) to (Controller))))","type compatibility obligation:(forall ctrl:Controller \u0026 (((ctrl.GetVehicleID)() not in set ((dom ctrlUnits) union (dom lights))) \u003d\u003e (((is_(dir, \u003cEAST\u003e) or is_(dir, \u003cNORTH\u003e)) or is_(dir, \u003cSOUTH\u003e)) or is_(dir, \u003cWEST\u003e))))","state invariant holds obligation:(forall light:TrafficLight \u0026 ((((light.GetID)() not in set (dom lights)) and ((light.GetID)() not in set (dom ctrlUnits))) \u003d\u003e ((((((dom ctrlUnits) inter (dom lights)) \u003d {}) and (forall id in set (dom ctrlUnits) \u0026 ((ctrlUnits(id).GetVehicleID)() \u003d id))) and (forall id in set (dom lights) \u0026 ((lights(id).GetID)() \u003d id))) \u003d\u003e (((((dom ctrlUnits) inter (dom (lights munion {(light.GetID)() |-\u003e light}))) \u003d {}) and (forall id in set (dom ctrlUnits) \u0026 ((ctrlUnits(id).GetVehicleID)() \u003d id))) and (forall id in set (dom lights) \u0026 ((lights(id).GetID)() \u003d id))))))","map compatible obligation:(forall light:TrafficLight \u0026 ((((light.GetID)() not in set (dom lights)) and ((light.GetID)() not in set (dom ctrlUnits))) \u003d\u003e (forall ldom1 in set (dom lights), rdom2 in set (dom {(light.GetID)() |-\u003e light}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (lights(ldom1) \u003d {(light.GetID)() |-\u003e light}(rdom2))))))","type compatibility obligation:(forall light:TrafficLight \u0026 ((((light.GetID)() not in set (dom lights)) and ((light.GetID)() not in set (dom ctrlUnits))) \u003d\u003e is_((lights munion {(light.GetID)() |-\u003e light}), inmap (nat) to (TrafficLight))))","legal map application obligation:(forall id:nat \u0026 ((id in set (dom ctrlUnits)) \u003d\u003e (id in set (dom ctrlUnits))))","legal map application obligation:(forall id:nat \u0026 ((id in set (dom lights)) \u003d\u003e (id in set (dom lights))))","type compatibility obligation:(((is_(dir, \u003cEAST\u003e) or is_(dir, \u003cNORTH\u003e)) or is_(dir, \u003cSOUTH\u003e)) or is_(dir, \u003cWEST\u003e))","cases exhaustive obligation:(forall d:Direction \u0026 ((((d \u003d \u003cNORTH\u003e) or (d \u003d \u003cSOUTH\u003e)) or (d \u003d \u003cEAST\u003e)) or (d \u003d \u003cWEST\u003e)))","type compatibility obligation:(forall u:Controller, us:set of (Controller) \u0026 (((is_((u.GetDirection)(), \u003cEAST\u003e) or is_((u.GetDirection)(), \u003cNORTH\u003e)) or is_((u.GetDirection)(), \u003cSOUTH\u003e)) or is_((u.GetDirection)(), \u003cWEST\u003e)))","legal function application obligation:(forall p:Position, range:int \u0026 pre_sqrt(((xd * xd) + (yd * yd))))","state invariant holds obligation:(forall vehicle:Vehicle \u0026 ((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith) \u003c\u003d Config`TrafficDataKeeptNumber)))","state invariant holds obligation:(forall vemoUnitID:nat, data:seq of (TrafficData) \u0026 (((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith) \u003c\u003d Config`TrafficDataKeeptNumber)) \u003d\u003e ((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len (communicatedWith ^ [vemoUnitID])) \u003c\u003d Config`TrafficDataKeeptNumber))))","state invariant holds obligation:(forall vemoUnitID:nat, data:seq of (TrafficData) \u0026 (((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len (communicatedWith ^ [vemoUnitID])) \u003c\u003d Config`TrafficDataKeeptNumber)) \u003d\u003e ((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len ((tl (communicatedWith ^ [vemoUnitID])) ^ [vemoUnitID])) \u003c\u003d Config`TrafficDataKeeptNumber))))","non-empty sequence obligation:(forall vemoUnitID:nat, data:seq of (TrafficData) \u0026 ((communicatedWith ^ [vemoUnitID]) \u003c\u003e []))","state invariant holds obligation:(forall vemoUnitID:nat, data:seq of (TrafficData) \u0026 (((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len ((tl (communicatedWith ^ [vemoUnitID])) ^ [vemoUnitID])) \u003c\u003d Config`TrafficDataKeeptNumber)) \u003d\u003e ((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len (externalTrafficData ^ data)) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len ((tl (communicatedWith ^ [vemoUnitID])) ^ [vemoUnitID])) \u003c\u003d Config`TrafficDataKeeptNumber))))","state invariant holds obligation:(forall vemoUnitID:nat, data:seq of (TrafficData) \u0026 (((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len (externalTrafficData ^ data)) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len ((tl (communicatedWith ^ [vemoUnitID])) ^ [vemoUnitID])) \u003c\u003d Config`TrafficDataKeeptNumber)) \u003d\u003e ((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len ((tl (externalTrafficData ^ data)) ^ data)) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len ((tl (communicatedWith ^ [vemoUnitID])) ^ [vemoUnitID])) \u003c\u003d Config`TrafficDataKeeptNumber))))","non-empty sequence obligation:(forall vemoUnitID:nat, data:seq of (TrafficData) \u0026 ((externalTrafficData ^ data) \u003c\u003e []))","state invariant holds obligation:(forall data:TrafficData \u0026 (((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith) \u003c\u003d Config`TrafficDataKeeptNumber)) \u003d\u003e ((((len (internalTrafficData ^ [data])) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith) \u003c\u003d Config`TrafficDataKeeptNumber))))","state invariant holds obligation:(forall data:TrafficData \u0026 (((((len (internalTrafficData ^ [data])) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith) \u003c\u003d Config`TrafficDataKeeptNumber)) \u003d\u003e ((((len ((tl (internalTrafficData ^ [data])) ^ [data])) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith) \u003c\u003d Config`TrafficDataKeeptNumber))))","non-empty sequence obligation:(forall data:TrafficData \u0026 ((internalTrafficData ^ [data]) \u003c\u003e []))","legal sequence application obligation:(forall i in set (inds internalTrafficData) \u0026 (i in set (inds internalTrafficData)))","legal sequence application obligation:(forall i in set (inds internalTrafficData) \u0026 (i in set (inds internalTrafficData)))","legal sequence application obligation:(forall i in set (inds internalTrafficData) \u0026 (i in set (inds internalTrafficData)))","state invariant holds obligation:(((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith) \u003c\u003d Config`TrafficDataKeeptNumber)) \u003d\u003e ((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith) \u003c\u003d Config`TrafficDataKeeptNumber)))","state invariant holds obligation:(((((len internalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith) \u003c\u003d Config`TrafficDataKeeptNumber)) \u003d\u003e ((((len [internalTrafficData(i) | i in set (inds internalTrafficData) \u0026 (internalTrafficData(i) \u003c\u003e td)]) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith) \u003c\u003d Config`TrafficDataKeeptNumber)))","legal sequence application obligation:(forall i in set (inds internalTrafficData) \u0026 ((internalTrafficData(i) \u003c\u003e td) \u003d\u003e (i in set (inds internalTrafficData))))","legal sequence application obligation:(forall i in set (inds internalTrafficData) \u0026 (i in set (inds internalTrafficData)))","type compatibility obligation:(((vemoVehicle.GetSpeed)() \u003d 0) \u003d\u003e (forall data in set (elems internalTrafficData) \u0026 is_(GetPosition(), Position)))","type compatibility obligation:(forall internalTrafficData25:seq of (TrafficData), externalTrafficData26:seq of (TrafficData), communicatedWith27:seq of (nat), traffic28:Traffic, vemoVehicle29:Vehicle, canRun30:bool \u0026 (((((len internalTrafficData25) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData26) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith27) \u003c\u003d Config`TrafficDataKeeptNumber)) \u003d\u003e (((vemoVehicle.GetSpeed)() \u003d 0) \u003d\u003e (forall data in set (elems internalTrafficData) \u0026 is_(GetPosition(), Position)))))","type compatibility obligation:(forall internalTrafficData25:seq of (TrafficData), externalTrafficData26:seq of (TrafficData), communicatedWith27:seq of (nat), traffic28:Traffic, vemoVehicle29:Vehicle, canRun30:bool \u0026 (((((len internalTrafficData25) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData26) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith27) \u003c\u003d Config`TrafficDataKeeptNumber)) \u003d\u003e (forall internalTrafficData49:seq of (TrafficData), externalTrafficData50:seq of (TrafficData), communicatedWith51:seq of (nat), traffic52:Traffic, vemoVehicle53:Vehicle, canRun54:bool \u0026 (((((len internalTrafficData49) \u003c\u003d Config`TrafficDataKeeptNumber) and ((len externalTrafficData50) \u003c\u003d Config`TrafficDataKeeptNumber)) and ((len communicatedWith51) \u003c\u003d Config`TrafficDataKeeptNumber)) \u003d\u003e (((vemoVehicle.GetSpeed)() \u003d 0) \u003d\u003e (forall data in set (elems internalTrafficData) \u0026 is_(GetPosition(), Position)))))))","type compatibility obligation:is_(World`env, Environment)","operation call obligation:(forall text:seq of (char) \u0026 ((\"\" \u003d \"\") \u003c\u003d\u003e (\"\" \u003d nil)))","non-zero obligation:(forall a:real \u0026 ((a \u003c\u003e 0) \u003d\u003e (a \u003c\u003e 0)))"] \ No newline at end of file diff --git a/core/pog/src/test/resources/examples/librarySL.result b/core/pog/src/test/resources/examples/librarySL.result index 3ac29c63d4..071dcdc2af 100644 --- a/core/pog/src/test/resources/examples/librarySL.result +++ b/core/pog/src/test/resources/examples/librarySL.result @@ -1 +1 @@ -["type invariant satisfiable obligation:(exists e:Edition \u0026 (e in set ({1, ... ,50} union {\u003cnil\u003e})))","type invariant satisfiable obligation:(exists e:Month \u0026 (e in set ({1, ... ,12} union {\u003cnil\u003e})))","type invariant satisfiable obligation:(exists e:Year \u0026 (e in set ({1800, ... ,1998} union {\u003cnil\u003e})))","function establishes postcondition obligation:(forall rt:Recordtype \u0026 post_field(rt, (required(rt) union optional(rt))))","function establishes postcondition obligation:(forall dB:set of (Record), i:Id \u0026 (pre_get(dB, i) \u003d\u003e post_get(dB, i, let record in set dB in (if ((record.id) \u003d i)\nthen record\nelse get((dB \\ {record}), i)))))","let be st existence obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e (exists record in set dB \u0026 true)))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e (forall record in set dB \u0026 ((not ((record.id) \u003d i)) \u003d\u003e pre_get((dB \\ {record}), i)))))","recursive function obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e (forall record in set dB \u0026 ((not ((record.id) \u003d i)) \u003d\u003e (CardDb(dB, i) \u003e CardDb((dB \\ {record}), i))))))","function establishes postcondition obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (pre_getvalue(valuetype, dB, i) \u003d\u003e post_getvalue(valuetype, dB, i, (cases valuetype :\n\u003ctitle\u003e -\u003e (get(dB, i).title),\n\u003cauthor\u003e -\u003e (get(dB, i).author),\n\u003cjournal\u003e -\u003e (get(dB, i).journal),\n\u003cyear\u003e -\u003e (get(dB, i).year),\n\u003cbooktitle\u003e -\u003e (get(dB, i).booktitle),\n\u003cinstitution\u003e -\u003e (get(dB, i).institution),\n\u003cpublisher\u003e -\u003e (get(dB, i).publisher)\n end))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e let RESULT \u003d (cases valuetype :\n\u003ctitle\u003e -\u003e (get(dB, i).title),\n\u003cauthor\u003e -\u003e (get(dB, i).author),\n\u003cjournal\u003e -\u003e (get(dB, i).journal),\n\u003cyear\u003e -\u003e (get(dB, i).year),\n\u003cbooktitle\u003e -\u003e (get(dB, i).booktitle),\n\u003cinstitution\u003e -\u003e (get(dB, i).institution),\n\u003cpublisher\u003e -\u003e (get(dB, i).publisher)\n end) in ((valuetype \u003d \u003ctitle\u003e) \u003d\u003e pre_get(dB, i))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e let RESULT \u003d (cases valuetype :\n\u003ctitle\u003e -\u003e (get(dB, i).title),\n\u003cauthor\u003e -\u003e (get(dB, i).author),\n\u003cjournal\u003e -\u003e (get(dB, i).journal),\n\u003cyear\u003e -\u003e (get(dB, i).year),\n\u003cbooktitle\u003e -\u003e (get(dB, i).booktitle),\n\u003cinstitution\u003e -\u003e (get(dB, i).institution),\n\u003cpublisher\u003e -\u003e (get(dB, i).publisher)\n end) in ((not ((valuetype \u003d \u003ctitle\u003e) and (RESULT \u003d (get(dB, i).title)))) \u003d\u003e ((valuetype \u003d \u003cauthor\u003e) \u003d\u003e pre_get(dB, i)))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e let RESULT \u003d (cases valuetype :\n\u003ctitle\u003e -\u003e (get(dB, i).title),\n\u003cauthor\u003e -\u003e (get(dB, i).author),\n\u003cjournal\u003e -\u003e (get(dB, i).journal),\n\u003cyear\u003e -\u003e (get(dB, i).year),\n\u003cbooktitle\u003e -\u003e (get(dB, i).booktitle),\n\u003cinstitution\u003e -\u003e (get(dB, i).institution),\n\u003cpublisher\u003e -\u003e (get(dB, i).publisher)\n end) in ((not ((valuetype \u003d \u003ctitle\u003e) and (RESULT \u003d (get(dB, i).title)))) \u003d\u003e ((not ((valuetype \u003d \u003cauthor\u003e) and (RESULT \u003d (get(dB, i).author)))) \u003d\u003e ((valuetype \u003d \u003cjournal\u003e) \u003d\u003e pre_get(dB, i))))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e let RESULT \u003d (cases valuetype :\n\u003ctitle\u003e -\u003e (get(dB, i).title),\n\u003cauthor\u003e -\u003e (get(dB, i).author),\n\u003cjournal\u003e -\u003e (get(dB, i).journal),\n\u003cyear\u003e -\u003e (get(dB, i).year),\n\u003cbooktitle\u003e -\u003e (get(dB, i).booktitle),\n\u003cinstitution\u003e -\u003e (get(dB, i).institution),\n\u003cpublisher\u003e -\u003e (get(dB, i).publisher)\n end) in ((not ((valuetype \u003d \u003ctitle\u003e) and (RESULT \u003d (get(dB, i).title)))) \u003d\u003e ((not ((valuetype \u003d \u003cauthor\u003e) and (RESULT \u003d (get(dB, i).author)))) \u003d\u003e ((not ((valuetype \u003d \u003cjournal\u003e) and (RESULT \u003d (get(dB, i).journal)))) \u003d\u003e ((valuetype \u003d \u003cyear\u003e) \u003d\u003e pre_get(dB, i)))))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e let RESULT \u003d (cases valuetype :\n\u003ctitle\u003e -\u003e (get(dB, i).title),\n\u003cauthor\u003e -\u003e (get(dB, i).author),\n\u003cjournal\u003e -\u003e (get(dB, i).journal),\n\u003cyear\u003e -\u003e (get(dB, i).year),\n\u003cbooktitle\u003e -\u003e (get(dB, i).booktitle),\n\u003cinstitution\u003e -\u003e (get(dB, i).institution),\n\u003cpublisher\u003e -\u003e (get(dB, i).publisher)\n end) in ((not ((valuetype \u003d \u003ctitle\u003e) and (RESULT \u003d (get(dB, i).title)))) \u003d\u003e ((not ((valuetype \u003d \u003cauthor\u003e) and (RESULT \u003d (get(dB, i).author)))) \u003d\u003e ((not ((valuetype \u003d \u003cjournal\u003e) and (RESULT \u003d (get(dB, i).journal)))) \u003d\u003e ((not ((valuetype \u003d \u003cyear\u003e) and (RESULT \u003d (get(dB, i).year)))) \u003d\u003e ((valuetype \u003d \u003cbooktitle\u003e) \u003d\u003e pre_get(dB, i))))))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e let RESULT \u003d (cases valuetype :\n\u003ctitle\u003e -\u003e (get(dB, i).title),\n\u003cauthor\u003e -\u003e (get(dB, i).author),\n\u003cjournal\u003e -\u003e (get(dB, i).journal),\n\u003cyear\u003e -\u003e (get(dB, i).year),\n\u003cbooktitle\u003e -\u003e (get(dB, i).booktitle),\n\u003cinstitution\u003e -\u003e (get(dB, i).institution),\n\u003cpublisher\u003e -\u003e (get(dB, i).publisher)\n end) in ((not ((valuetype \u003d \u003ctitle\u003e) and (RESULT \u003d (get(dB, i).title)))) \u003d\u003e ((not ((valuetype \u003d \u003cauthor\u003e) and (RESULT \u003d (get(dB, i).author)))) \u003d\u003e ((not ((valuetype \u003d \u003cjournal\u003e) and (RESULT \u003d (get(dB, i).journal)))) \u003d\u003e ((not ((valuetype \u003d \u003cyear\u003e) and (RESULT \u003d (get(dB, i).year)))) \u003d\u003e ((not ((valuetype \u003d \u003cbooktitle\u003e) and (RESULT \u003d (get(dB, i).booktitle)))) \u003d\u003e ((valuetype \u003d \u003cinstitution\u003e) \u003d\u003e pre_get(dB, i)))))))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e let RESULT \u003d (cases valuetype :\n\u003ctitle\u003e -\u003e (get(dB, i).title),\n\u003cauthor\u003e -\u003e (get(dB, i).author),\n\u003cjournal\u003e -\u003e (get(dB, i).journal),\n\u003cyear\u003e -\u003e (get(dB, i).year),\n\u003cbooktitle\u003e -\u003e (get(dB, i).booktitle),\n\u003cinstitution\u003e -\u003e (get(dB, i).institution),\n\u003cpublisher\u003e -\u003e (get(dB, i).publisher)\n end) in ((not ((valuetype \u003d \u003ctitle\u003e) and (RESULT \u003d (get(dB, i).title)))) \u003d\u003e ((not ((valuetype \u003d \u003cauthor\u003e) and (RESULT \u003d (get(dB, i).author)))) \u003d\u003e ((not ((valuetype \u003d \u003cjournal\u003e) and (RESULT \u003d (get(dB, i).journal)))) \u003d\u003e ((not ((valuetype \u003d \u003cyear\u003e) and (RESULT \u003d (get(dB, i).year)))) \u003d\u003e ((not ((valuetype \u003d \u003cbooktitle\u003e) and (RESULT \u003d (get(dB, i).booktitle)))) \u003d\u003e ((not ((valuetype \u003d \u003cinstitution\u003e) and (RESULT \u003d (get(dB, i).institution)))) \u003d\u003e ((valuetype \u003d \u003cpublisher\u003e) \u003d\u003e pre_get(dB, i))))))))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e ((\u003ctitle\u003e \u003d valuetype) \u003d\u003e pre_get(dB, i))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e ((not (\u003ctitle\u003e \u003d valuetype)) \u003d\u003e ((\u003cauthor\u003e \u003d valuetype) \u003d\u003e pre_get(dB, i)))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e ((not (\u003ctitle\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cauthor\u003e \u003d valuetype)) \u003d\u003e ((\u003cjournal\u003e \u003d valuetype) \u003d\u003e pre_get(dB, i))))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e ((not (\u003ctitle\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cauthor\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cjournal\u003e \u003d valuetype)) \u003d\u003e ((\u003cyear\u003e \u003d valuetype) \u003d\u003e pre_get(dB, i)))))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e ((not (\u003ctitle\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cauthor\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cjournal\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cyear\u003e \u003d valuetype)) \u003d\u003e ((\u003cbooktitle\u003e \u003d valuetype) \u003d\u003e pre_get(dB, i))))))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e ((not (\u003ctitle\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cauthor\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cjournal\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cyear\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cbooktitle\u003e \u003d valuetype)) \u003d\u003e ((\u003cinstitution\u003e \u003d valuetype) \u003d\u003e pre_get(dB, i)))))))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e ((not (\u003ctitle\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cauthor\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cjournal\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cyear\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cbooktitle\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cinstitution\u003e \u003d valuetype)) \u003d\u003e ((\u003cpublisher\u003e \u003d valuetype) \u003d\u003e pre_get(dB, i))))))))))","cases exhaustive obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e (((((((valuetype \u003d \u003ctitle\u003e) or (valuetype \u003d \u003cauthor\u003e)) or (valuetype \u003d \u003cjournal\u003e)) or (valuetype \u003d \u003cyear\u003e)) or (valuetype \u003d \u003cbooktitle\u003e)) or (valuetype \u003d \u003cinstitution\u003e)) or (valuetype \u003d \u003cpublisher\u003e))))","function establishes postcondition obligation:(forall dB:set of (Record), i:Id \u0026 (pre_iscomplete(dB, i) \u003d\u003e post_iscomplete(dB, i, (required(recordtype(dB, i)) \u003d {f | f in set required(recordtype(dB, i)) \u0026 (not isempty(getvalue(f, dB, i)))}))))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e let RESULT \u003d (required(recordtype(dB, i)) \u003d {f | f in set required(recordtype(dB, i)) \u0026 (not isempty(getvalue(f, dB, i)))}) in pre_recordtype(dB, i)))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e let RESULT \u003d (required(recordtype(dB, i)) \u003d {f | f in set required(recordtype(dB, i)) \u0026 (not isempty(getvalue(f, dB, i)))}) in (forall x in set required(recordtype(dB, i)) \u0026 pre_getvalue(x, dB, i))))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e pre_recordtype(dB, i)))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e pre_recordtype(dB, i)))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e (forall f in set required(recordtype(dB, i)) \u0026 pre_getvalue(f, dB, i))))","function establishes postcondition obligation:(forall value:Value \u0026 post_isempty(value, (if (value \u003d \u003cnil\u003e)\nthen true\nelse false)))","function establishes postcondition obligation:(forall dB:set of (Record) \u0026 post_isidentical(dB, (if (dB \u003d {})\nthen false\nelse let record1 in set dB in (if iscomplete(dB, (record1.id))\nthen isidentical2(dB, (dB \\ {record1}), dB, record1)\nelse isidentical((dB \\ {record1}))))))","legal function application obligation:(forall dB:set of (Record) \u0026 let RESULT \u003d (if (dB \u003d {})\nthen false\nelse let record1 in set dB in (if iscomplete(dB, (record1.id))\nthen isidentical2(dB, (dB \\ {record1}), dB, record1)\nelse isidentical((dB \\ {record1})))) in (forall i, j in set usedIds(dB) \u0026 ((i \u003c\u003e j) \u003d\u003e pre_iscomplete(dB, i))))","legal function application obligation:(forall dB:set of (Record) \u0026 let RESULT \u003d (if (dB \u003d {})\nthen false\nelse let record1 in set dB in (if iscomplete(dB, (record1.id))\nthen isidentical2(dB, (dB \\ {record1}), dB, record1)\nelse isidentical((dB \\ {record1})))) in (forall i, j in set usedIds(dB) \u0026 ((i \u003c\u003e j) \u003d\u003e (iscomplete(dB, i) \u003d\u003e pre_iscomplete(dB, j)))))","legal function application obligation:(forall dB:set of (Record) \u0026 let RESULT \u003d (if (dB \u003d {})\nthen false\nelse let record1 in set dB in (if iscomplete(dB, (record1.id))\nthen isidentical2(dB, (dB \\ {record1}), dB, record1)\nelse isidentical((dB \\ {record1})))) in (forall i, j in set usedIds(dB) \u0026 ((i \u003c\u003e j) \u003d\u003e (iscomplete(dB, i) \u003d\u003e (iscomplete(dB, j) \u003d\u003e pre_recordtype(dB, i))))))","legal function application obligation:(forall dB:set of (Record) \u0026 let RESULT \u003d (if (dB \u003d {})\nthen false\nelse let record1 in set dB in (if iscomplete(dB, (record1.id))\nthen isidentical2(dB, (dB \\ {record1}), dB, record1)\nelse isidentical((dB \\ {record1})))) in (forall i, j in set usedIds(dB) \u0026 ((i \u003c\u003e j) \u003d\u003e (iscomplete(dB, i) \u003d\u003e (iscomplete(dB, j) \u003d\u003e pre_recordtype(dB, j))))))","legal function application obligation:(forall dB:set of (Record) \u0026 let RESULT \u003d (if (dB \u003d {})\nthen false\nelse let record1 in set dB in (if iscomplete(dB, (record1.id))\nthen isidentical2(dB, (dB \\ {record1}), dB, record1)\nelse isidentical((dB \\ {record1})))) in (forall i, j in set usedIds(dB) \u0026 ((i \u003c\u003e j) \u003d\u003e (iscomplete(dB, i) \u003d\u003e (iscomplete(dB, j) \u003d\u003e ((recordtype(dB, i) \u003d recordtype(dB, j)) \u003d\u003e pre_recordtype(dB, i)))))))","legal function application obligation:(forall dB:set of (Record) \u0026 let RESULT \u003d (if (dB \u003d {})\nthen false\nelse let record1 in set dB in (if iscomplete(dB, (record1.id))\nthen isidentical2(dB, (dB \\ {record1}), dB, record1)\nelse isidentical((dB \\ {record1})))) in (forall i, j in set usedIds(dB) \u0026 ((i \u003c\u003e j) \u003d\u003e (iscomplete(dB, i) \u003d\u003e (iscomplete(dB, j) \u003d\u003e ((recordtype(dB, i) \u003d recordtype(dB, j)) \u003d\u003e (forall x in set required(recordtype(dB, i)) \u0026 pre_getvalue(x, dB, i))))))))","legal function application obligation:(forall dB:set of (Record) \u0026 let RESULT \u003d (if (dB \u003d {})\nthen false\nelse let record1 in set dB in (if iscomplete(dB, (record1.id))\nthen isidentical2(dB, (dB \\ {record1}), dB, record1)\nelse isidentical((dB \\ {record1})))) in (forall i, j in set usedIds(dB) \u0026 ((i \u003c\u003e j) \u003d\u003e (iscomplete(dB, i) \u003d\u003e (iscomplete(dB, j) \u003d\u003e ((recordtype(dB, i) \u003d recordtype(dB, j)) \u003d\u003e (forall x in set required(recordtype(dB, i)) \u0026 pre_getvalue(x, dB, j))))))))","let be st existence obligation:(forall dB:set of (Record) \u0026 ((not (dB \u003d {})) \u003d\u003e (exists record1 in set dB \u0026 true)))","legal function application obligation:(forall dB:set of (Record) \u0026 ((not (dB \u003d {})) \u003d\u003e (forall record1 in set dB \u0026 pre_iscomplete(dB, (record1.id)))))","let be st existence obligation:(forall dB1:set of (Record), dB2:set of (Record), olddB:set of (Record), record1:Record \u0026 ((not (dB2 \u003d {})) \u003d\u003e (exists record2 in set dB2 \u0026 true)))","legal function application obligation:(forall dB1:set of (Record), dB2:set of (Record), olddB:set of (Record), record1:Record \u0026 ((not (dB2 \u003d {})) \u003d\u003e (forall record2 in set dB2 \u0026 pre_iscomplete(olddB, (record2.id)))))","legal function application obligation:(forall dB1:set of (Record), dB2:set of (Record), olddB:set of (Record), record1:Record \u0026 ((not (dB2 \u003d {})) \u003d\u003e (forall record2 in set dB2 \u0026 (iscomplete(olddB, (record2.id)) \u003d\u003e pre_recordtype(olddB, (record1.id))))))","let be st existence obligation:(forall dB1:set of (Record), dB2:set of (Record), olddB:set of (Record), record1:Record, record2:Record, requiredfields:set of (Valuetype) \u0026 ((not (requiredfields \u003d {})) \u003d\u003e (exists field in set requiredfields \u0026 true)))","legal function application obligation:(forall dB1:set of (Record), dB2:set of (Record), olddB:set of (Record), record1:Record, record2:Record, requiredfields:set of (Valuetype) \u0026 ((not (requiredfields \u003d {})) \u003d\u003e (forall field in set requiredfields \u0026 pre_getvalue(field, olddB, (record1.id)))))","legal function application obligation:(forall dB1:set of (Record), dB2:set of (Record), olddB:set of (Record), record1:Record, record2:Record, requiredfields:set of (Valuetype) \u0026 ((not (requiredfields \u003d {})) \u003d\u003e (forall field in set requiredfields \u0026 pre_getvalue(field, olddB, (record2.id)))))","non-empty sequence obligation:(forall v:Value \u0026 ((not is_(v, real)) \u003d\u003e ((not (v \u003d [])) \u003d\u003e (is_((hd v), char) \u003d\u003e (v \u003c\u003e [])))))","function establishes postcondition obligation:(forall string1:String, string2:String \u0026 post_issubstring(string1, string2, (if (string1 \u003d [])\nthen true\nelseif ((string2 \u003d []) or ((string1 \u003d \u003cnil\u003e) or (string2 \u003d \u003cnil\u003e)))\nthen false\nelseif ((hd string1) \u003d (hd string2))\nthen issubstring2((tl string1), (tl string2), string1)\nelse issubstring(string1, (tl string2)))))","legal function application obligation:(forall string1:String, string2:String \u0026 let RESULT \u003d (if (string1 \u003d [])\nthen true\nelseif ((string2 \u003d []) or ((string1 \u003d \u003cnil\u003e) or (string2 \u003d \u003cnil\u003e)))\nthen false\nelseif ((hd string1) \u003d (hd string2))\nthen issubstring2((tl string1), (tl string2), string1)\nelse issubstring(string1, (tl string2))) in ((not (string2 \u003d \u003cnil\u003e)) \u003d\u003e (forall i, j in set (inds string2) \u0026 pre_substring(string2, i, j))))","non-empty sequence obligation:(forall string1:String, string2:String \u0026 ((not (string1 \u003d [])) \u003d\u003e ((not ((string2 \u003d []) or ((string1 \u003d \u003cnil\u003e) or (string2 \u003d \u003cnil\u003e)))) \u003d\u003e (((hd string1) \u003d (hd string2)) \u003d\u003e (string1 \u003c\u003e [])))))","non-empty sequence obligation:(forall string1:String, string2:String \u0026 ((not (string1 \u003d [])) \u003d\u003e ((not ((string2 \u003d []) or ((string1 \u003d \u003cnil\u003e) or (string2 \u003d \u003cnil\u003e)))) \u003d\u003e (((hd string1) \u003d (hd string2)) \u003d\u003e (string2 \u003c\u003e [])))))","non-empty sequence obligation:(forall string1:String, string2:String \u0026 ((not (string1 \u003d [])) \u003d\u003e ((not ((string2 \u003d []) or ((string1 \u003d \u003cnil\u003e) or (string2 \u003d \u003cnil\u003e)))) \u003d\u003e ((not ((hd string1) \u003d (hd string2))) \u003d\u003e (string2 \u003c\u003e [])))))","non-empty sequence obligation:(forall string1:String, string2:String, oldstring1:String \u0026 ((not (string1 \u003d [])) \u003d\u003e ((not (string2 \u003d [])) \u003d\u003e (((hd string1) \u003d (hd string2)) \u003d\u003e (string1 \u003c\u003e [])))))","non-empty sequence obligation:(forall string1:String, string2:String, oldstring1:String \u0026 ((not (string1 \u003d [])) \u003d\u003e ((not (string2 \u003d [])) \u003d\u003e (((hd string1) \u003d (hd string2)) \u003d\u003e (string2 \u003c\u003e [])))))","function establishes postcondition obligation:(forall v:Value, f:Valuetype \u0026 post_isvalueoffield(v, f, (cases f :\n\u003caddress\u003e -\u003e isstring(v),\n\u003cauthor\u003e -\u003e isstring(v),\n\u003cbooktitle\u003e -\u003e isstring(v),\n\u003cedition\u003e -\u003e isedition(v),\n\u003ceditor\u003e -\u003e isstring(v),\n\u003cinstitution\u003e -\u003e isstring(v),\n\u003cjournal\u003e -\u003e isstring(v),\n\u003cmonth\u003e -\u003e ismonth(v),\n\u003cnote\u003e -\u003e isstring(v),\n\u003cnumber\u003e -\u003e isnumber(v),\n\u003corganization\u003e -\u003e isstring(v),\n\u003cpages\u003e -\u003e ispages(v),\n\u003cpublisher\u003e -\u003e isstring(v),\n\u003ctitle\u003e -\u003e isstring(v),\n\u003ctype\u003e -\u003e isstring(v),\n\u003cvolume\u003e -\u003e isvolume(v),\n\u003cyear\u003e -\u003e isyear(v)\n end)))","cases exhaustive obligation:(forall v:Value, f:Valuetype \u0026 (((((((((((((((((f \u003d \u003caddress\u003e) or (f \u003d \u003cauthor\u003e)) or (f \u003d \u003cbooktitle\u003e)) or (f \u003d \u003cedition\u003e)) or (f \u003d \u003ceditor\u003e)) or (f \u003d \u003cinstitution\u003e)) or (f \u003d \u003cjournal\u003e)) or (f \u003d \u003cmonth\u003e)) or (f \u003d \u003cnote\u003e)) or (f \u003d \u003cnumber\u003e)) or (f \u003d \u003corganization\u003e)) or (f \u003d \u003cpages\u003e)) or (f \u003d \u003cpublisher\u003e)) or (f \u003d \u003ctitle\u003e)) or (f \u003d \u003ctype\u003e)) or (f \u003d \u003cvolume\u003e)) or (f \u003d \u003cyear\u003e)))","function establishes postcondition obligation:(forall rt:Recordtype \u0026 post_optional(rt, (cases rt :\n\u003carticle\u003e -\u003e {\u003cvolume\u003e, \u003cnumber\u003e, \u003cmonth\u003e, \u003cnote\u003e},\n\u003cbook\u003e -\u003e {\u003cvolume\u003e, \u003cseries\u003e, \u003caddress\u003e, \u003cedition\u003e, \u003cmonth\u003e, \u003cnote\u003e, \u003cpublisher\u003e},\n\u003cinproceeding\u003e -\u003e {\u003ceditor\u003e, \u003cpages\u003e, \u003corganization\u003e, \u003cpublisher\u003e, \u003caddress\u003e, \u003cpages\u003e, \u003corganization\u003e},\n\u003cmanual\u003e -\u003e {\u003cedition\u003e, \u003cnote\u003e, \u003corganization\u003e, \u003cmonth\u003e, \u003caddress\u003e, \u003cauthor\u003e, \u003corganization\u003e, \u003cyear\u003e},\n\u003ctechreport\u003e -\u003e {\u003cnumber\u003e, \u003cnote\u003e, \u003ctype\u003e, \u003cmonth\u003e, \u003caddress\u003e}\n end)))","cases exhaustive obligation:(forall rt:Recordtype \u0026 (((((rt \u003d \u003carticle\u003e) or (rt \u003d \u003cbook\u003e)) or (rt \u003d \u003cinproceeding\u003e)) or (rt \u003d \u003cmanual\u003e)) or (rt \u003d \u003ctechreport\u003e)))","function establishes postcondition obligation:(forall dB:set of (Record), i:Id \u0026 (pre_recordtype(dB, i) \u003d\u003e post_recordtype(dB, i, (if is_(get(dB, i), Article)\nthen \u003carticle\u003e\nelseif is_(get(dB, i), Book)\nthen \u003cbook\u003e\nelseif is_(get(dB, i), Inproceeding)\nthen \u003cinproceeding\u003e\nelseif is_(get(dB, i), Manual)\nthen \u003cmanual\u003e\nelse \u003ctechreport\u003e))))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e let RESULT \u003d (if is_(get(dB, i), Article)\nthen \u003carticle\u003e\nelseif is_(get(dB, i), Book)\nthen \u003cbook\u003e\nelseif is_(get(dB, i), Inproceeding)\nthen \u003cinproceeding\u003e\nelseif is_(get(dB, i), Manual)\nthen \u003cmanual\u003e\nelse \u003ctechreport\u003e) in pre_get(dB, i)))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e let RESULT \u003d (if is_(get(dB, i), Article)\nthen \u003carticle\u003e\nelseif is_(get(dB, i), Book)\nthen \u003cbook\u003e\nelseif is_(get(dB, i), Inproceeding)\nthen \u003cinproceeding\u003e\nelseif is_(get(dB, i), Manual)\nthen \u003cmanual\u003e\nelse \u003ctechreport\u003e) in ((not (is_(get(dB, i), Article) and (RESULT \u003d \u003carticle\u003e))) \u003d\u003e pre_get(dB, i))))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e let RESULT \u003d (if is_(get(dB, i), Article)\nthen \u003carticle\u003e\nelseif is_(get(dB, i), Book)\nthen \u003cbook\u003e\nelseif is_(get(dB, i), Inproceeding)\nthen \u003cinproceeding\u003e\nelseif is_(get(dB, i), Manual)\nthen \u003cmanual\u003e\nelse \u003ctechreport\u003e) in ((not (is_(get(dB, i), Article) and (RESULT \u003d \u003carticle\u003e))) \u003d\u003e ((not (is_(get(dB, i), Book) and (RESULT \u003d \u003cbook\u003e))) \u003d\u003e pre_get(dB, i)))))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e let RESULT \u003d (if is_(get(dB, i), Article)\nthen \u003carticle\u003e\nelseif is_(get(dB, i), Book)\nthen \u003cbook\u003e\nelseif is_(get(dB, i), Inproceeding)\nthen \u003cinproceeding\u003e\nelseif is_(get(dB, i), Manual)\nthen \u003cmanual\u003e\nelse \u003ctechreport\u003e) in ((not (is_(get(dB, i), Article) and (RESULT \u003d \u003carticle\u003e))) \u003d\u003e ((not (is_(get(dB, i), Book) and (RESULT \u003d \u003cbook\u003e))) \u003d\u003e ((not (is_(get(dB, i), Inproceeding) and (RESULT \u003d \u003cinproceeding\u003e))) \u003d\u003e pre_get(dB, i))))))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e let RESULT \u003d (if is_(get(dB, i), Article)\nthen \u003carticle\u003e\nelseif is_(get(dB, i), Book)\nthen \u003cbook\u003e\nelseif is_(get(dB, i), Inproceeding)\nthen \u003cinproceeding\u003e\nelseif is_(get(dB, i), Manual)\nthen \u003cmanual\u003e\nelse \u003ctechreport\u003e) in ((not (is_(get(dB, i), Article) and (RESULT \u003d \u003carticle\u003e))) \u003d\u003e ((not (is_(get(dB, i), Book) and (RESULT \u003d \u003cbook\u003e))) \u003d\u003e ((not (is_(get(dB, i), Inproceeding) and (RESULT \u003d \u003cinproceeding\u003e))) \u003d\u003e ((not (is_(get(dB, i), Manual) and (RESULT \u003d \u003cmanual\u003e))) \u003d\u003e pre_get(dB, i)))))))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e pre_get(dB, i)))","function establishes postcondition obligation:(forall rt:Recordtype \u0026 post_required(rt, (cases rt :\n\u003carticle\u003e -\u003e {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e},\n\u003cbook\u003e -\u003e {\u003ctitle\u003e, \u003cauthor\u003e, \u003cpublisher\u003e, \u003cyear\u003e},\n\u003cinproceeding\u003e -\u003e {\u003ctitle\u003e, \u003cauthor\u003e, \u003cbooktitle\u003e, \u003cyear\u003e},\n\u003cmanual\u003e -\u003e {\u003ctitle\u003e},\n\u003ctechreport\u003e -\u003e {\u003ctitle\u003e, \u003cauthor\u003e, \u003cinstitution\u003e, \u003cyear\u003e}\n end)))","cases exhaustive obligation:(forall rt:Recordtype \u0026 (((((rt \u003d \u003carticle\u003e) or (rt \u003d \u003cbook\u003e)) or (rt \u003d \u003cinproceeding\u003e)) or (rt \u003d \u003cmanual\u003e)) or (rt \u003d \u003ctechreport\u003e)))","function postcondition satisfiable obligation:(forall s:String, i:nat1, j:nat1 \u0026 (pre_substring(s, i, j) \u003d\u003e (exists r:String \u0026 post_substring(s, i, j, r))))","function establishes postcondition obligation:(forall dB:set of (Record) \u0026 post_usedIds(dB, idset(dB, {})))","let be st existence obligation:(forall dB:set of (Record), ids:set of (Id) \u0026 ((not (dB \u003d {})) \u003d\u003e (exists record in set dB \u0026 true)))","recursive function obligation:(forall dB:set of (Record), ids:set of (Id) \u0026 ((not (dB \u003d {})) \u003d\u003e (forall record in set dB \u0026 (CardRecords(dB, ids) \u003e CardRecords((dB \\ {record}), (ids union {(record.id)}))))))","while loop termination obligation:NotYetImplemented","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Month(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Year(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Edition(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Month(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Year(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Month(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Year(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Edition(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Month(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Year(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Month(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Year(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((RESULT not in set usedIds(dB~)) \u003d\u003e ((e \u003d \u003carticle\u003e) \u003d\u003e inv_Month(\u003cnil\u003e))))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((RESULT not in set usedIds(dB~)) \u003d\u003e ((e \u003d \u003carticle\u003e) \u003d\u003e inv_Year(\u003cnil\u003e))))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((not ((RESULT not in set usedIds(dB~)) and ((e \u003d \u003carticle\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Article(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))))) \u003d\u003e ((e \u003d \u003cbook\u003e) \u003d\u003e inv_Edition(\u003cnil\u003e))))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((not ((RESULT not in set usedIds(dB~)) and ((e \u003d \u003carticle\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Article(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))))) \u003d\u003e ((e \u003d \u003cbook\u003e) \u003d\u003e inv_Month(\u003cnil\u003e))))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((not ((RESULT not in set usedIds(dB~)) and ((e \u003d \u003carticle\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Article(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))))) \u003d\u003e ((e \u003d \u003cbook\u003e) \u003d\u003e inv_Year(\u003cnil\u003e))))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((not ((RESULT not in set usedIds(dB~)) and ((e \u003d \u003carticle\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Article(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))))) \u003d\u003e ((not ((e \u003d \u003cbook\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Book(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((e \u003d \u003cinproceeding\u003e) \u003d\u003e inv_Month(\u003cnil\u003e)))))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((not ((RESULT not in set usedIds(dB~)) and ((e \u003d \u003carticle\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Article(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))))) \u003d\u003e ((not ((e \u003d \u003cbook\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Book(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((e \u003d \u003cinproceeding\u003e) \u003d\u003e inv_Year(\u003cnil\u003e)))))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((not ((RESULT not in set usedIds(dB~)) and ((e \u003d \u003carticle\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Article(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))))) \u003d\u003e ((not ((e \u003d \u003cbook\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Book(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((not ((e \u003d \u003cinproceeding\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Inproceeding(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((e \u003d \u003cmanual\u003e) \u003d\u003e inv_Edition(\u003cnil\u003e))))))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((not ((RESULT not in set usedIds(dB~)) and ((e \u003d \u003carticle\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Article(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))))) \u003d\u003e ((not ((e \u003d \u003cbook\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Book(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((not ((e \u003d \u003cinproceeding\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Inproceeding(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((e \u003d \u003cmanual\u003e) \u003d\u003e inv_Month(\u003cnil\u003e))))))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((not ((RESULT not in set usedIds(dB~)) and ((e \u003d \u003carticle\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Article(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))))) \u003d\u003e ((not ((e \u003d \u003cbook\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Book(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((not ((e \u003d \u003cinproceeding\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Inproceeding(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((e \u003d \u003cmanual\u003e) \u003d\u003e inv_Year(\u003cnil\u003e))))))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((not ((RESULT not in set usedIds(dB~)) and ((e \u003d \u003carticle\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Article(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))))) \u003d\u003e ((not ((e \u003d \u003cbook\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Book(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((not ((e \u003d \u003cinproceeding\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Inproceeding(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((not ((e \u003d \u003cmanual\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Manual(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((e \u003d \u003ctechreport\u003e) \u003d\u003e inv_Month(\u003cnil\u003e)))))))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((not ((RESULT not in set usedIds(dB~)) and ((e \u003d \u003carticle\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Article(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))))) \u003d\u003e ((not ((e \u003d \u003cbook\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Book(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((not ((e \u003d \u003cinproceeding\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Inproceeding(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((not ((e \u003d \u003cmanual\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Manual(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((e \u003d \u003ctechreport\u003e) \u003d\u003e inv_Year(\u003cnil\u003e)))))))","operation establishes postcondition obligation:(forall e:Recordtype, oldstate:mgd \u0026 (((RESULT not in set usedIds(dB~)) and ((e \u003d \u003carticle\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Article(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) or (((e \u003d \u003cbook\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Book(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))) or (((e \u003d \u003cinproceeding\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Inproceeding(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))) or (((e \u003d \u003cmanual\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Manual(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))) or ((e \u003d \u003ctechreport\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Techreport(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))))))))","legal function application obligation:((i in set usedIds(dB)) \u003d\u003e pre_recordtype(dB, i))","legal function application obligation:((i in set usedIds(dB)) \u003d\u003e ((f in set field(recordtype(dB, i))) \u003d\u003e (isvalueoffield(v, f) \u003d\u003e pre_iscomplete(dB, i))))","legal function application obligation:(((i in set usedIds(dB)) and ((f in set field(recordtype(dB, i))) and (isvalueoffield(v, f) and (not (iscomplete(dB, i) and isidentical(dB)))))) \u003d\u003e pre_getvalue(f, dB, i))","legal function application obligation:(((i in set usedIds(dB)) and ((f in set field(recordtype(dB, i))) and (isvalueoffield(v, f) and (not (iscomplete(dB, i) and isidentical(dB)))))) \u003d\u003e ((getvalue(f, dB, i) \u003d v) \u003d\u003e pre_get(dB, i)))","legal function application obligation:(((i in set usedIds(dB)) and ((f in set field(recordtype(dB, i))) and (isvalueoffield(v, f) and (not (iscomplete(dB, i) and isidentical(dB)))))) \u003d\u003e ((getvalue(f, dB, i) \u003d v) \u003d\u003e pre_get(dB~, i)))","legal function application obligation:(((i in set usedIds(dB)) and ((f in set field(recordtype(dB, i))) and (isvalueoffield(v, f) and (not (iscomplete(dB, i) and isidentical(dB)))))) \u003d\u003e ((getvalue(f, dB, i) \u003d v) \u003d\u003e (((dB \\ {get(dB, i)}) \u003d (dB~ \\ {get(dB~, i)})) \u003d\u003e pre_recordtype(dB, i))))","legal function application obligation:(((i in set usedIds(dB)) and ((f in set field(recordtype(dB, i))) and (isvalueoffield(v, f) and (not (iscomplete(dB, i) and isidentical(dB)))))) \u003d\u003e ((getvalue(f, dB, i) \u003d v) \u003d\u003e (((dB \\ {get(dB, i)}) \u003d (dB~ \\ {get(dB~, i)})) \u003d\u003e (forall x in set (field(recordtype(dB, i)) \\ {f}) \u0026 pre_getvalue(x, dB, i)))))","legal function application obligation:(((i in set usedIds(dB)) and ((f in set field(recordtype(dB, i))) and (isvalueoffield(v, f) and (not (iscomplete(dB, i) and isidentical(dB)))))) \u003d\u003e ((getvalue(f, dB, i) \u003d v) \u003d\u003e (((dB \\ {get(dB, i)}) \u003d (dB~ \\ {get(dB~, i)})) \u003d\u003e (forall x in set (field(recordtype(dB, i)) \\ {f}) \u0026 pre_getvalue(x, dB~, i)))))","legal function application obligation:((i in set usedIds(dB)) \u003d\u003e pre_recordtype(dB, i))","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, seq of (char)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, seq of (char)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, seq of (char)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(inv_Edition(v) and (is_(v, \u003cnil\u003e) or is_(v, nat)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, seq of (char)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, seq of (char)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, seq of (char)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(inv_Month(v) and (is_(v, \u003cnil\u003e) or is_(v, nat)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, seq of (char)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, nat1))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, seq of (char)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, nat1))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, seq of (char)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, seq of (char)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, seq of (char)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, nat1))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(inv_Year(v) and (is_(v, \u003cnil\u003e) or is_(v, nat)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_iscomplete(dB, i)","operation call obligation:(i in set usedIds(dB))","legal function application obligation:(forall i:Id, oldstate:mgd \u0026 ((i in set usedIds(dB)) \u003d\u003e pre_iscomplete(dB, i)))","legal function application obligation:(forall i:Id, oldstate:mgd \u0026 ((i in set usedIds(dB)) \u003d\u003e pre_iscomplete(dB, i)))","operation establishes postcondition obligation:(forall i:Id, oldstate:mgd \u0026 ((i in set usedIds(dB)) \u003d\u003e (iscomplete(dB, i) \u003c\u003d\u003e RESULT)))","legal function application obligation:((i in set usedIds(dB)) \u003d\u003e pre_get(dB~, i))","legal function application obligation:pre_get(dB, i)","legal function application obligation:(forall a:String, oldstate:mgd \u0026 (forall i in set RESULT \u0026 pre_get(dB, i)))","legal function application obligation:(forall a:String, oldstate:mgd \u0026 (forall i in set RESULT \u0026 (issubstring(a, (get(dB, i).author)) \u003d\u003e (forall record in set dB \u0026 (((record.id) not in set RESULT) \u003d\u003e pre_get(dB, i))))))","operation establishes postcondition obligation:(forall a:String, oldstate:mgd \u0026 (forall i in set RESULT \u0026 (issubstring(a, (get(dB, i).author)) and (not (exists record in set dB \u0026 (((record.id) not in set RESULT) and issubstring(a, (get(dB, i).author))))))))","legal function application obligation:(forall i:Id, oldstate:mgd \u0026 ((i in set usedIds(dB)) \u003d\u003e pre_get(dB, i)))","legal function application obligation:(forall i:Id, oldstate:mgd \u0026 ((i in set usedIds(dB)) \u003d\u003e pre_get(dB, i)))","operation establishes postcondition obligation:(forall i:Id, oldstate:mgd \u0026 ((i in set usedIds(dB)) \u003d\u003e (RESULT \u003d get(dB, i))))"] \ No newline at end of file +["type invariant satisfiable obligation:(exists e:Edition \u0026 (e in set ({1, ... ,50} union {\u003cnil\u003e})))","type invariant satisfiable obligation:(exists e:Month \u0026 (e in set ({1, ... ,12} union {\u003cnil\u003e})))","type invariant satisfiable obligation:(exists e:Year \u0026 (e in set ({1800, ... ,1998} union {\u003cnil\u003e})))","function establishes postcondition obligation:(forall rt:Recordtype \u0026 post_field(rt, (required(rt) union optional(rt))))","function establishes postcondition obligation:(forall dB:set of (Record), i:Id \u0026 (pre_get(dB, i) \u003d\u003e post_get(dB, i, let record in set dB in (if ((record.id) \u003d i)\nthen record\nelse get((dB \\ {record}), i)))))","let be st existence obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e (exists record in set dB \u0026 true)))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e (forall record in set dB \u0026 ((not ((record.id) \u003d i)) \u003d\u003e pre_get((dB \\ {record}), i)))))","recursive function obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e (forall record in set dB \u0026 ((not ((record.id) \u003d i)) \u003d\u003e (CardDb(dB, i) \u003e CardDb((dB \\ {record}), i))))))","function establishes postcondition obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (pre_getvalue(valuetype, dB, i) \u003d\u003e post_getvalue(valuetype, dB, i, (cases valuetype :\n\u003ctitle\u003e -\u003e (get(dB, i).title),\n\u003cauthor\u003e -\u003e (get(dB, i).author),\n\u003cjournal\u003e -\u003e (get(dB, i).journal),\n\u003cyear\u003e -\u003e (get(dB, i).year),\n\u003cbooktitle\u003e -\u003e (get(dB, i).booktitle),\n\u003cinstitution\u003e -\u003e (get(dB, i).institution),\n\u003cpublisher\u003e -\u003e (get(dB, i).publisher)\n end))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e let RESULT \u003d (cases valuetype :\n\u003ctitle\u003e -\u003e (get(dB, i).title),\n\u003cauthor\u003e -\u003e (get(dB, i).author),\n\u003cjournal\u003e -\u003e (get(dB, i).journal),\n\u003cyear\u003e -\u003e (get(dB, i).year),\n\u003cbooktitle\u003e -\u003e (get(dB, i).booktitle),\n\u003cinstitution\u003e -\u003e (get(dB, i).institution),\n\u003cpublisher\u003e -\u003e (get(dB, i).publisher)\n end) in ((valuetype \u003d \u003ctitle\u003e) \u003d\u003e pre_get(dB, i))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e let RESULT \u003d (cases valuetype :\n\u003ctitle\u003e -\u003e (get(dB, i).title),\n\u003cauthor\u003e -\u003e (get(dB, i).author),\n\u003cjournal\u003e -\u003e (get(dB, i).journal),\n\u003cyear\u003e -\u003e (get(dB, i).year),\n\u003cbooktitle\u003e -\u003e (get(dB, i).booktitle),\n\u003cinstitution\u003e -\u003e (get(dB, i).institution),\n\u003cpublisher\u003e -\u003e (get(dB, i).publisher)\n end) in ((not ((valuetype \u003d \u003ctitle\u003e) and (RESULT \u003d (get(dB, i).title)))) \u003d\u003e ((valuetype \u003d \u003cauthor\u003e) \u003d\u003e pre_get(dB, i)))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e let RESULT \u003d (cases valuetype :\n\u003ctitle\u003e -\u003e (get(dB, i).title),\n\u003cauthor\u003e -\u003e (get(dB, i).author),\n\u003cjournal\u003e -\u003e (get(dB, i).journal),\n\u003cyear\u003e -\u003e (get(dB, i).year),\n\u003cbooktitle\u003e -\u003e (get(dB, i).booktitle),\n\u003cinstitution\u003e -\u003e (get(dB, i).institution),\n\u003cpublisher\u003e -\u003e (get(dB, i).publisher)\n end) in ((not ((valuetype \u003d \u003ctitle\u003e) and (RESULT \u003d (get(dB, i).title)))) \u003d\u003e ((not ((valuetype \u003d \u003cauthor\u003e) and (RESULT \u003d (get(dB, i).author)))) \u003d\u003e ((valuetype \u003d \u003cjournal\u003e) \u003d\u003e pre_get(dB, i))))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e let RESULT \u003d (cases valuetype :\n\u003ctitle\u003e -\u003e (get(dB, i).title),\n\u003cauthor\u003e -\u003e (get(dB, i).author),\n\u003cjournal\u003e -\u003e (get(dB, i).journal),\n\u003cyear\u003e -\u003e (get(dB, i).year),\n\u003cbooktitle\u003e -\u003e (get(dB, i).booktitle),\n\u003cinstitution\u003e -\u003e (get(dB, i).institution),\n\u003cpublisher\u003e -\u003e (get(dB, i).publisher)\n end) in ((not ((valuetype \u003d \u003ctitle\u003e) and (RESULT \u003d (get(dB, i).title)))) \u003d\u003e ((not ((valuetype \u003d \u003cauthor\u003e) and (RESULT \u003d (get(dB, i).author)))) \u003d\u003e ((not ((valuetype \u003d \u003cjournal\u003e) and (RESULT \u003d (get(dB, i).journal)))) \u003d\u003e ((valuetype \u003d \u003cyear\u003e) \u003d\u003e pre_get(dB, i)))))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e let RESULT \u003d (cases valuetype :\n\u003ctitle\u003e -\u003e (get(dB, i).title),\n\u003cauthor\u003e -\u003e (get(dB, i).author),\n\u003cjournal\u003e -\u003e (get(dB, i).journal),\n\u003cyear\u003e -\u003e (get(dB, i).year),\n\u003cbooktitle\u003e -\u003e (get(dB, i).booktitle),\n\u003cinstitution\u003e -\u003e (get(dB, i).institution),\n\u003cpublisher\u003e -\u003e (get(dB, i).publisher)\n end) in ((not ((valuetype \u003d \u003ctitle\u003e) and (RESULT \u003d (get(dB, i).title)))) \u003d\u003e ((not ((valuetype \u003d \u003cauthor\u003e) and (RESULT \u003d (get(dB, i).author)))) \u003d\u003e ((not ((valuetype \u003d \u003cjournal\u003e) and (RESULT \u003d (get(dB, i).journal)))) \u003d\u003e ((not ((valuetype \u003d \u003cyear\u003e) and (RESULT \u003d (get(dB, i).year)))) \u003d\u003e ((valuetype \u003d \u003cbooktitle\u003e) \u003d\u003e pre_get(dB, i))))))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e let RESULT \u003d (cases valuetype :\n\u003ctitle\u003e -\u003e (get(dB, i).title),\n\u003cauthor\u003e -\u003e (get(dB, i).author),\n\u003cjournal\u003e -\u003e (get(dB, i).journal),\n\u003cyear\u003e -\u003e (get(dB, i).year),\n\u003cbooktitle\u003e -\u003e (get(dB, i).booktitle),\n\u003cinstitution\u003e -\u003e (get(dB, i).institution),\n\u003cpublisher\u003e -\u003e (get(dB, i).publisher)\n end) in ((not ((valuetype \u003d \u003ctitle\u003e) and (RESULT \u003d (get(dB, i).title)))) \u003d\u003e ((not ((valuetype \u003d \u003cauthor\u003e) and (RESULT \u003d (get(dB, i).author)))) \u003d\u003e ((not ((valuetype \u003d \u003cjournal\u003e) and (RESULT \u003d (get(dB, i).journal)))) \u003d\u003e ((not ((valuetype \u003d \u003cyear\u003e) and (RESULT \u003d (get(dB, i).year)))) \u003d\u003e ((not ((valuetype \u003d \u003cbooktitle\u003e) and (RESULT \u003d (get(dB, i).booktitle)))) \u003d\u003e ((valuetype \u003d \u003cinstitution\u003e) \u003d\u003e pre_get(dB, i)))))))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e let RESULT \u003d (cases valuetype :\n\u003ctitle\u003e -\u003e (get(dB, i).title),\n\u003cauthor\u003e -\u003e (get(dB, i).author),\n\u003cjournal\u003e -\u003e (get(dB, i).journal),\n\u003cyear\u003e -\u003e (get(dB, i).year),\n\u003cbooktitle\u003e -\u003e (get(dB, i).booktitle),\n\u003cinstitution\u003e -\u003e (get(dB, i).institution),\n\u003cpublisher\u003e -\u003e (get(dB, i).publisher)\n end) in ((not ((valuetype \u003d \u003ctitle\u003e) and (RESULT \u003d (get(dB, i).title)))) \u003d\u003e ((not ((valuetype \u003d \u003cauthor\u003e) and (RESULT \u003d (get(dB, i).author)))) \u003d\u003e ((not ((valuetype \u003d \u003cjournal\u003e) and (RESULT \u003d (get(dB, i).journal)))) \u003d\u003e ((not ((valuetype \u003d \u003cyear\u003e) and (RESULT \u003d (get(dB, i).year)))) \u003d\u003e ((not ((valuetype \u003d \u003cbooktitle\u003e) and (RESULT \u003d (get(dB, i).booktitle)))) \u003d\u003e ((not ((valuetype \u003d \u003cinstitution\u003e) and (RESULT \u003d (get(dB, i).institution)))) \u003d\u003e ((valuetype \u003d \u003cpublisher\u003e) \u003d\u003e pre_get(dB, i))))))))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e ((\u003ctitle\u003e \u003d valuetype) \u003d\u003e pre_get(dB, i))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e ((not (\u003ctitle\u003e \u003d valuetype)) \u003d\u003e ((\u003cauthor\u003e \u003d valuetype) \u003d\u003e pre_get(dB, i)))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e ((not (\u003ctitle\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cauthor\u003e \u003d valuetype)) \u003d\u003e ((\u003cjournal\u003e \u003d valuetype) \u003d\u003e pre_get(dB, i))))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e ((not (\u003ctitle\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cauthor\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cjournal\u003e \u003d valuetype)) \u003d\u003e ((\u003cyear\u003e \u003d valuetype) \u003d\u003e pre_get(dB, i)))))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e ((not (\u003ctitle\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cauthor\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cjournal\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cyear\u003e \u003d valuetype)) \u003d\u003e ((\u003cbooktitle\u003e \u003d valuetype) \u003d\u003e pre_get(dB, i))))))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e ((not (\u003ctitle\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cauthor\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cjournal\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cyear\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cbooktitle\u003e \u003d valuetype)) \u003d\u003e ((\u003cinstitution\u003e \u003d valuetype) \u003d\u003e pre_get(dB, i)))))))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e ((not (\u003ctitle\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cauthor\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cjournal\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cyear\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cbooktitle\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cinstitution\u003e \u003d valuetype)) \u003d\u003e ((\u003cpublisher\u003e \u003d valuetype) \u003d\u003e pre_get(dB, i))))))))))","cases exhaustive obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e (((((((valuetype \u003d \u003ctitle\u003e) or (valuetype \u003d \u003cauthor\u003e)) or (valuetype \u003d \u003cjournal\u003e)) or (valuetype \u003d \u003cyear\u003e)) or (valuetype \u003d \u003cbooktitle\u003e)) or (valuetype \u003d \u003cinstitution\u003e)) or (valuetype \u003d \u003cpublisher\u003e))))","function establishes postcondition obligation:(forall dB:set of (Record), i:Id \u0026 (pre_iscomplete(dB, i) \u003d\u003e post_iscomplete(dB, i, (required(recordtype(dB, i)) \u003d {f | f in set required(recordtype(dB, i)) \u0026 (not isempty(getvalue(f, dB, i)))}))))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e let RESULT \u003d (required(recordtype(dB, i)) \u003d {f | f in set required(recordtype(dB, i)) \u0026 (not isempty(getvalue(f, dB, i)))}) in pre_recordtype(dB, i)))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e let RESULT \u003d (required(recordtype(dB, i)) \u003d {f | f in set required(recordtype(dB, i)) \u0026 (not isempty(getvalue(f, dB, i)))}) in (forall x in set required(recordtype(dB, i)) \u0026 pre_getvalue(x, dB, i))))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e pre_recordtype(dB, i)))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e pre_recordtype(dB, i)))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e (forall f in set required(recordtype(dB, i)) \u0026 pre_getvalue(f, dB, i))))","function establishes postcondition obligation:(forall value:Value \u0026 post_isempty(value, (if (value \u003d \u003cnil\u003e)\nthen true\nelse false)))","function establishes postcondition obligation:(forall dB:set of (Record) \u0026 post_isidentical(dB, (if (dB \u003d {})\nthen false\nelse let record1 in set dB in (if iscomplete(dB, (record1.id))\nthen isidentical2(dB, (dB \\ {record1}), dB, record1)\nelse isidentical((dB \\ {record1}))))))","legal function application obligation:(forall dB:set of (Record) \u0026 let RESULT \u003d (if (dB \u003d {})\nthen false\nelse let record1 in set dB in (if iscomplete(dB, (record1.id))\nthen isidentical2(dB, (dB \\ {record1}), dB, record1)\nelse isidentical((dB \\ {record1})))) in (forall i, j in set usedIds(dB) \u0026 ((i \u003c\u003e j) \u003d\u003e pre_iscomplete(dB, i))))","legal function application obligation:(forall dB:set of (Record) \u0026 let RESULT \u003d (if (dB \u003d {})\nthen false\nelse let record1 in set dB in (if iscomplete(dB, (record1.id))\nthen isidentical2(dB, (dB \\ {record1}), dB, record1)\nelse isidentical((dB \\ {record1})))) in (forall i, j in set usedIds(dB) \u0026 ((i \u003c\u003e j) \u003d\u003e (iscomplete(dB, i) \u003d\u003e pre_iscomplete(dB, j)))))","legal function application obligation:(forall dB:set of (Record) \u0026 let RESULT \u003d (if (dB \u003d {})\nthen false\nelse let record1 in set dB in (if iscomplete(dB, (record1.id))\nthen isidentical2(dB, (dB \\ {record1}), dB, record1)\nelse isidentical((dB \\ {record1})))) in (forall i, j in set usedIds(dB) \u0026 ((i \u003c\u003e j) \u003d\u003e (iscomplete(dB, i) \u003d\u003e (iscomplete(dB, j) \u003d\u003e pre_recordtype(dB, i))))))","legal function application obligation:(forall dB:set of (Record) \u0026 let RESULT \u003d (if (dB \u003d {})\nthen false\nelse let record1 in set dB in (if iscomplete(dB, (record1.id))\nthen isidentical2(dB, (dB \\ {record1}), dB, record1)\nelse isidentical((dB \\ {record1})))) in (forall i, j in set usedIds(dB) \u0026 ((i \u003c\u003e j) \u003d\u003e (iscomplete(dB, i) \u003d\u003e (iscomplete(dB, j) \u003d\u003e pre_recordtype(dB, j))))))","legal function application obligation:(forall dB:set of (Record) \u0026 let RESULT \u003d (if (dB \u003d {})\nthen false\nelse let record1 in set dB in (if iscomplete(dB, (record1.id))\nthen isidentical2(dB, (dB \\ {record1}), dB, record1)\nelse isidentical((dB \\ {record1})))) in (forall i, j in set usedIds(dB) \u0026 ((i \u003c\u003e j) \u003d\u003e (iscomplete(dB, i) \u003d\u003e (iscomplete(dB, j) \u003d\u003e ((recordtype(dB, i) \u003d recordtype(dB, j)) \u003d\u003e pre_recordtype(dB, i)))))))","legal function application obligation:(forall dB:set of (Record) \u0026 let RESULT \u003d (if (dB \u003d {})\nthen false\nelse let record1 in set dB in (if iscomplete(dB, (record1.id))\nthen isidentical2(dB, (dB \\ {record1}), dB, record1)\nelse isidentical((dB \\ {record1})))) in (forall i, j in set usedIds(dB) \u0026 ((i \u003c\u003e j) \u003d\u003e (iscomplete(dB, i) \u003d\u003e (iscomplete(dB, j) \u003d\u003e ((recordtype(dB, i) \u003d recordtype(dB, j)) \u003d\u003e (forall x in set required(recordtype(dB, i)) \u0026 pre_getvalue(x, dB, i))))))))","legal function application obligation:(forall dB:set of (Record) \u0026 let RESULT \u003d (if (dB \u003d {})\nthen false\nelse let record1 in set dB in (if iscomplete(dB, (record1.id))\nthen isidentical2(dB, (dB \\ {record1}), dB, record1)\nelse isidentical((dB \\ {record1})))) in (forall i, j in set usedIds(dB) \u0026 ((i \u003c\u003e j) \u003d\u003e (iscomplete(dB, i) \u003d\u003e (iscomplete(dB, j) \u003d\u003e ((recordtype(dB, i) \u003d recordtype(dB, j)) \u003d\u003e (forall x in set required(recordtype(dB, i)) \u0026 pre_getvalue(x, dB, j))))))))","let be st existence obligation:(forall dB:set of (Record) \u0026 ((not (dB \u003d {})) \u003d\u003e (exists record1 in set dB \u0026 true)))","legal function application obligation:(forall dB:set of (Record) \u0026 ((not (dB \u003d {})) \u003d\u003e (forall record1 in set dB \u0026 pre_iscomplete(dB, (record1.id)))))","let be st existence obligation:(forall dB1:set of (Record), dB2:set of (Record), olddB:set of (Record), record1:Record \u0026 ((not (dB2 \u003d {})) \u003d\u003e (exists record2 in set dB2 \u0026 true)))","legal function application obligation:(forall dB1:set of (Record), dB2:set of (Record), olddB:set of (Record), record1:Record \u0026 ((not (dB2 \u003d {})) \u003d\u003e (forall record2 in set dB2 \u0026 pre_iscomplete(olddB, (record2.id)))))","legal function application obligation:(forall dB1:set of (Record), dB2:set of (Record), olddB:set of (Record), record1:Record \u0026 ((not (dB2 \u003d {})) \u003d\u003e (forall record2 in set dB2 \u0026 (iscomplete(olddB, (record2.id)) \u003d\u003e pre_recordtype(olddB, (record1.id))))))","let be st existence obligation:(forall dB1:set of (Record), dB2:set of (Record), olddB:set of (Record), record1:Record, record2:Record, requiredfields:set of (Valuetype) \u0026 ((not (requiredfields \u003d {})) \u003d\u003e (exists field in set requiredfields \u0026 true)))","legal function application obligation:(forall dB1:set of (Record), dB2:set of (Record), olddB:set of (Record), record1:Record, record2:Record, requiredfields:set of (Valuetype) \u0026 ((not (requiredfields \u003d {})) \u003d\u003e (forall field in set requiredfields \u0026 pre_getvalue(field, olddB, (record1.id)))))","legal function application obligation:(forall dB1:set of (Record), dB2:set of (Record), olddB:set of (Record), record1:Record, record2:Record, requiredfields:set of (Valuetype) \u0026 ((not (requiredfields \u003d {})) \u003d\u003e (forall field in set requiredfields \u0026 pre_getvalue(field, olddB, (record2.id)))))","non-empty sequence obligation:(forall v:Value \u0026 ((not is_(v, real)) \u003d\u003e ((not (v \u003d [])) \u003d\u003e (is_((hd v), char) \u003d\u003e (v \u003c\u003e [])))))","function establishes postcondition obligation:(forall string1:String, string2:String \u0026 post_issubstring(string1, string2, (if (string1 \u003d [])\nthen true\nelseif ((string2 \u003d []) or ((string1 \u003d \u003cnil\u003e) or (string2 \u003d \u003cnil\u003e)))\nthen false\nelseif ((hd string1) \u003d (hd string2))\nthen issubstring2((tl string1), (tl string2), string1)\nelse issubstring(string1, (tl string2)))))","legal function application obligation:(forall string1:String, string2:String \u0026 let RESULT \u003d (if (string1 \u003d [])\nthen true\nelseif ((string2 \u003d []) or ((string1 \u003d \u003cnil\u003e) or (string2 \u003d \u003cnil\u003e)))\nthen false\nelseif ((hd string1) \u003d (hd string2))\nthen issubstring2((tl string1), (tl string2), string1)\nelse issubstring(string1, (tl string2))) in ((not (string2 \u003d \u003cnil\u003e)) \u003d\u003e (forall i, j in set (inds string2) \u0026 pre_substring(string2, i, j))))","non-empty sequence obligation:(forall string1:String, string2:String \u0026 ((not (string1 \u003d [])) \u003d\u003e ((not ((string2 \u003d []) or ((string1 \u003d \u003cnil\u003e) or (string2 \u003d \u003cnil\u003e)))) \u003d\u003e (((hd string1) \u003d (hd string2)) \u003d\u003e (string1 \u003c\u003e [])))))","non-empty sequence obligation:(forall string1:String, string2:String \u0026 ((not (string1 \u003d [])) \u003d\u003e ((not ((string2 \u003d []) or ((string1 \u003d \u003cnil\u003e) or (string2 \u003d \u003cnil\u003e)))) \u003d\u003e (((hd string1) \u003d (hd string2)) \u003d\u003e (string2 \u003c\u003e [])))))","non-empty sequence obligation:(forall string1:String, string2:String \u0026 ((not (string1 \u003d [])) \u003d\u003e ((not ((string2 \u003d []) or ((string1 \u003d \u003cnil\u003e) or (string2 \u003d \u003cnil\u003e)))) \u003d\u003e ((not ((hd string1) \u003d (hd string2))) \u003d\u003e (string2 \u003c\u003e [])))))","non-empty sequence obligation:(forall string1:String, string2:String, oldstring1:String \u0026 ((not (string1 \u003d [])) \u003d\u003e ((not (string2 \u003d [])) \u003d\u003e (((hd string1) \u003d (hd string2)) \u003d\u003e (string1 \u003c\u003e [])))))","non-empty sequence obligation:(forall string1:String, string2:String, oldstring1:String \u0026 ((not (string1 \u003d [])) \u003d\u003e ((not (string2 \u003d [])) \u003d\u003e (((hd string1) \u003d (hd string2)) \u003d\u003e (string2 \u003c\u003e [])))))","function establishes postcondition obligation:(forall v:Value, f:Valuetype \u0026 post_isvalueoffield(v, f, (cases f :\n\u003caddress\u003e -\u003e isstring(v),\n\u003cauthor\u003e -\u003e isstring(v),\n\u003cbooktitle\u003e -\u003e isstring(v),\n\u003cedition\u003e -\u003e isedition(v),\n\u003ceditor\u003e -\u003e isstring(v),\n\u003cinstitution\u003e -\u003e isstring(v),\n\u003cjournal\u003e -\u003e isstring(v),\n\u003cmonth\u003e -\u003e ismonth(v),\n\u003cnote\u003e -\u003e isstring(v),\n\u003cnumber\u003e -\u003e isnumber(v),\n\u003corganization\u003e -\u003e isstring(v),\n\u003cpages\u003e -\u003e ispages(v),\n\u003cpublisher\u003e -\u003e isstring(v),\n\u003ctitle\u003e -\u003e isstring(v),\n\u003ctype\u003e -\u003e isstring(v),\n\u003cvolume\u003e -\u003e isvolume(v),\n\u003cyear\u003e -\u003e isyear(v)\n end)))","cases exhaustive obligation:(forall v:Value, f:Valuetype \u0026 (((((((((((((((((f \u003d \u003caddress\u003e) or (f \u003d \u003cauthor\u003e)) or (f \u003d \u003cbooktitle\u003e)) or (f \u003d \u003cedition\u003e)) or (f \u003d \u003ceditor\u003e)) or (f \u003d \u003cinstitution\u003e)) or (f \u003d \u003cjournal\u003e)) or (f \u003d \u003cmonth\u003e)) or (f \u003d \u003cnote\u003e)) or (f \u003d \u003cnumber\u003e)) or (f \u003d \u003corganization\u003e)) or (f \u003d \u003cpages\u003e)) or (f \u003d \u003cpublisher\u003e)) or (f \u003d \u003ctitle\u003e)) or (f \u003d \u003ctype\u003e)) or (f \u003d \u003cvolume\u003e)) or (f \u003d \u003cyear\u003e)))","function establishes postcondition obligation:(forall rt:Recordtype \u0026 post_optional(rt, (cases rt :\n\u003carticle\u003e -\u003e {\u003cvolume\u003e, \u003cnumber\u003e, \u003cmonth\u003e, \u003cnote\u003e},\n\u003cbook\u003e -\u003e {\u003cvolume\u003e, \u003cseries\u003e, \u003caddress\u003e, \u003cedition\u003e, \u003cmonth\u003e, \u003cnote\u003e, \u003cpublisher\u003e},\n\u003cinproceeding\u003e -\u003e {\u003ceditor\u003e, \u003cpages\u003e, \u003corganization\u003e, \u003cpublisher\u003e, \u003caddress\u003e, \u003cpages\u003e, \u003corganization\u003e},\n\u003cmanual\u003e -\u003e {\u003cedition\u003e, \u003cnote\u003e, \u003corganization\u003e, \u003cmonth\u003e, \u003caddress\u003e, \u003cauthor\u003e, \u003corganization\u003e, \u003cyear\u003e},\n\u003ctechreport\u003e -\u003e {\u003cnumber\u003e, \u003cnote\u003e, \u003ctype\u003e, \u003cmonth\u003e, \u003caddress\u003e}\n end)))","cases exhaustive obligation:(forall rt:Recordtype \u0026 (((((rt \u003d \u003carticle\u003e) or (rt \u003d \u003cbook\u003e)) or (rt \u003d \u003cinproceeding\u003e)) or (rt \u003d \u003cmanual\u003e)) or (rt \u003d \u003ctechreport\u003e)))","function establishes postcondition obligation:(forall dB:set of (Record), i:Id \u0026 (pre_recordtype(dB, i) \u003d\u003e post_recordtype(dB, i, (if is_(get(dB, i), Article)\nthen \u003carticle\u003e\nelseif is_(get(dB, i), Book)\nthen \u003cbook\u003e\nelseif is_(get(dB, i), Inproceeding)\nthen \u003cinproceeding\u003e\nelseif is_(get(dB, i), Manual)\nthen \u003cmanual\u003e\nelse \u003ctechreport\u003e))))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e let RESULT \u003d (if is_(get(dB, i), Article)\nthen \u003carticle\u003e\nelseif is_(get(dB, i), Book)\nthen \u003cbook\u003e\nelseif is_(get(dB, i), Inproceeding)\nthen \u003cinproceeding\u003e\nelseif is_(get(dB, i), Manual)\nthen \u003cmanual\u003e\nelse \u003ctechreport\u003e) in pre_get(dB, i)))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e let RESULT \u003d (if is_(get(dB, i), Article)\nthen \u003carticle\u003e\nelseif is_(get(dB, i), Book)\nthen \u003cbook\u003e\nelseif is_(get(dB, i), Inproceeding)\nthen \u003cinproceeding\u003e\nelseif is_(get(dB, i), Manual)\nthen \u003cmanual\u003e\nelse \u003ctechreport\u003e) in ((not (is_(get(dB, i), Article) and (RESULT \u003d \u003carticle\u003e))) \u003d\u003e pre_get(dB, i))))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e let RESULT \u003d (if is_(get(dB, i), Article)\nthen \u003carticle\u003e\nelseif is_(get(dB, i), Book)\nthen \u003cbook\u003e\nelseif is_(get(dB, i), Inproceeding)\nthen \u003cinproceeding\u003e\nelseif is_(get(dB, i), Manual)\nthen \u003cmanual\u003e\nelse \u003ctechreport\u003e) in ((not (is_(get(dB, i), Article) and (RESULT \u003d \u003carticle\u003e))) \u003d\u003e ((not (is_(get(dB, i), Book) and (RESULT \u003d \u003cbook\u003e))) \u003d\u003e pre_get(dB, i)))))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e let RESULT \u003d (if is_(get(dB, i), Article)\nthen \u003carticle\u003e\nelseif is_(get(dB, i), Book)\nthen \u003cbook\u003e\nelseif is_(get(dB, i), Inproceeding)\nthen \u003cinproceeding\u003e\nelseif is_(get(dB, i), Manual)\nthen \u003cmanual\u003e\nelse \u003ctechreport\u003e) in ((not (is_(get(dB, i), Article) and (RESULT \u003d \u003carticle\u003e))) \u003d\u003e ((not (is_(get(dB, i), Book) and (RESULT \u003d \u003cbook\u003e))) \u003d\u003e ((not (is_(get(dB, i), Inproceeding) and (RESULT \u003d \u003cinproceeding\u003e))) \u003d\u003e pre_get(dB, i))))))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e let RESULT \u003d (if is_(get(dB, i), Article)\nthen \u003carticle\u003e\nelseif is_(get(dB, i), Book)\nthen \u003cbook\u003e\nelseif is_(get(dB, i), Inproceeding)\nthen \u003cinproceeding\u003e\nelseif is_(get(dB, i), Manual)\nthen \u003cmanual\u003e\nelse \u003ctechreport\u003e) in ((not (is_(get(dB, i), Article) and (RESULT \u003d \u003carticle\u003e))) \u003d\u003e ((not (is_(get(dB, i), Book) and (RESULT \u003d \u003cbook\u003e))) \u003d\u003e ((not (is_(get(dB, i), Inproceeding) and (RESULT \u003d \u003cinproceeding\u003e))) \u003d\u003e ((not (is_(get(dB, i), Manual) and (RESULT \u003d \u003cmanual\u003e))) \u003d\u003e pre_get(dB, i)))))))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e pre_get(dB, i)))","function establishes postcondition obligation:(forall rt:Recordtype \u0026 post_required(rt, (cases rt :\n\u003carticle\u003e -\u003e {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e},\n\u003cbook\u003e -\u003e {\u003ctitle\u003e, \u003cauthor\u003e, \u003cpublisher\u003e, \u003cyear\u003e},\n\u003cinproceeding\u003e -\u003e {\u003ctitle\u003e, \u003cauthor\u003e, \u003cbooktitle\u003e, \u003cyear\u003e},\n\u003cmanual\u003e -\u003e {\u003ctitle\u003e},\n\u003ctechreport\u003e -\u003e {\u003ctitle\u003e, \u003cauthor\u003e, \u003cinstitution\u003e, \u003cyear\u003e}\n end)))","cases exhaustive obligation:(forall rt:Recordtype \u0026 (((((rt \u003d \u003carticle\u003e) or (rt \u003d \u003cbook\u003e)) or (rt \u003d \u003cinproceeding\u003e)) or (rt \u003d \u003cmanual\u003e)) or (rt \u003d \u003ctechreport\u003e)))","function postcondition satisfiable obligation:(forall s:String, i:nat1, j:nat1 \u0026 (pre_substring(s, i, j) \u003d\u003e (exists r:String \u0026 post_substring(s, i, j, r))))","function establishes postcondition obligation:(forall dB:set of (Record) \u0026 post_usedIds(dB, idset(dB, {})))","let be st existence obligation:(forall dB:set of (Record), ids:set of (Id) \u0026 ((not (dB \u003d {})) \u003d\u003e (exists record in set dB \u0026 true)))","recursive function obligation:(forall dB:set of (Record), ids:set of (Id) \u0026 ((not (dB \u003d {})) \u003d\u003e (forall record in set dB \u0026 (CardRecords(dB, ids) \u003e CardRecords((dB \\ {record}), (ids union {(record.id)}))))))","while loop termination obligation:...","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Month(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Year(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Edition(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Month(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Year(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Month(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Year(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Edition(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Month(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Year(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Month(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Year(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((RESULT not in set usedIds(dB~)) \u003d\u003e ((e \u003d \u003carticle\u003e) \u003d\u003e inv_Month(\u003cnil\u003e))))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((RESULT not in set usedIds(dB~)) \u003d\u003e ((e \u003d \u003carticle\u003e) \u003d\u003e inv_Year(\u003cnil\u003e))))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((not ((RESULT not in set usedIds(dB~)) and ((e \u003d \u003carticle\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Article(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))))) \u003d\u003e ((e \u003d \u003cbook\u003e) \u003d\u003e inv_Edition(\u003cnil\u003e))))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((not ((RESULT not in set usedIds(dB~)) and ((e \u003d \u003carticle\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Article(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))))) \u003d\u003e ((e \u003d \u003cbook\u003e) \u003d\u003e inv_Month(\u003cnil\u003e))))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((not ((RESULT not in set usedIds(dB~)) and ((e \u003d \u003carticle\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Article(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))))) \u003d\u003e ((e \u003d \u003cbook\u003e) \u003d\u003e inv_Year(\u003cnil\u003e))))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((not ((RESULT not in set usedIds(dB~)) and ((e \u003d \u003carticle\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Article(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))))) \u003d\u003e ((not ((e \u003d \u003cbook\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Book(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((e \u003d \u003cinproceeding\u003e) \u003d\u003e inv_Month(\u003cnil\u003e)))))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((not ((RESULT not in set usedIds(dB~)) and ((e \u003d \u003carticle\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Article(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))))) \u003d\u003e ((not ((e \u003d \u003cbook\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Book(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((e \u003d \u003cinproceeding\u003e) \u003d\u003e inv_Year(\u003cnil\u003e)))))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((not ((RESULT not in set usedIds(dB~)) and ((e \u003d \u003carticle\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Article(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))))) \u003d\u003e ((not ((e \u003d \u003cbook\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Book(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((not ((e \u003d \u003cinproceeding\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Inproceeding(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((e \u003d \u003cmanual\u003e) \u003d\u003e inv_Edition(\u003cnil\u003e))))))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((not ((RESULT not in set usedIds(dB~)) and ((e \u003d \u003carticle\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Article(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))))) \u003d\u003e ((not ((e \u003d \u003cbook\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Book(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((not ((e \u003d \u003cinproceeding\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Inproceeding(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((e \u003d \u003cmanual\u003e) \u003d\u003e inv_Month(\u003cnil\u003e))))))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((not ((RESULT not in set usedIds(dB~)) and ((e \u003d \u003carticle\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Article(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))))) \u003d\u003e ((not ((e \u003d \u003cbook\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Book(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((not ((e \u003d \u003cinproceeding\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Inproceeding(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((e \u003d \u003cmanual\u003e) \u003d\u003e inv_Year(\u003cnil\u003e))))))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((not ((RESULT not in set usedIds(dB~)) and ((e \u003d \u003carticle\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Article(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))))) \u003d\u003e ((not ((e \u003d \u003cbook\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Book(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((not ((e \u003d \u003cinproceeding\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Inproceeding(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((not ((e \u003d \u003cmanual\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Manual(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((e \u003d \u003ctechreport\u003e) \u003d\u003e inv_Month(\u003cnil\u003e)))))))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((not ((RESULT not in set usedIds(dB~)) and ((e \u003d \u003carticle\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Article(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))))) \u003d\u003e ((not ((e \u003d \u003cbook\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Book(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((not ((e \u003d \u003cinproceeding\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Inproceeding(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((not ((e \u003d \u003cmanual\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Manual(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((e \u003d \u003ctechreport\u003e) \u003d\u003e inv_Year(\u003cnil\u003e)))))))","operation establishes postcondition obligation:(forall e:Recordtype, oldstate:mgd \u0026 (((RESULT not in set usedIds(dB~)) and ((e \u003d \u003carticle\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Article(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) or (((e \u003d \u003cbook\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Book(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))) or (((e \u003d \u003cinproceeding\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Inproceeding(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))) or (((e \u003d \u003cmanual\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Manual(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))) or ((e \u003d \u003ctechreport\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Techreport(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))))))))","legal function application obligation:((i in set usedIds(dB)) \u003d\u003e pre_recordtype(dB, i))","legal function application obligation:((i in set usedIds(dB)) \u003d\u003e ((f in set field(recordtype(dB, i))) \u003d\u003e (isvalueoffield(v, f) \u003d\u003e pre_iscomplete(dB, i))))","legal function application obligation:(((i in set usedIds(dB)) and ((f in set field(recordtype(dB, i))) and (isvalueoffield(v, f) and (not (iscomplete(dB, i) and isidentical(dB)))))) \u003d\u003e pre_getvalue(f, dB, i))","legal function application obligation:(((i in set usedIds(dB)) and ((f in set field(recordtype(dB, i))) and (isvalueoffield(v, f) and (not (iscomplete(dB, i) and isidentical(dB)))))) \u003d\u003e ((getvalue(f, dB, i) \u003d v) \u003d\u003e pre_get(dB, i)))","legal function application obligation:(((i in set usedIds(dB)) and ((f in set field(recordtype(dB, i))) and (isvalueoffield(v, f) and (not (iscomplete(dB, i) and isidentical(dB)))))) \u003d\u003e ((getvalue(f, dB, i) \u003d v) \u003d\u003e pre_get(dB~, i)))","legal function application obligation:(((i in set usedIds(dB)) and ((f in set field(recordtype(dB, i))) and (isvalueoffield(v, f) and (not (iscomplete(dB, i) and isidentical(dB)))))) \u003d\u003e ((getvalue(f, dB, i) \u003d v) \u003d\u003e (((dB \\ {get(dB, i)}) \u003d (dB~ \\ {get(dB~, i)})) \u003d\u003e pre_recordtype(dB, i))))","legal function application obligation:(((i in set usedIds(dB)) and ((f in set field(recordtype(dB, i))) and (isvalueoffield(v, f) and (not (iscomplete(dB, i) and isidentical(dB)))))) \u003d\u003e ((getvalue(f, dB, i) \u003d v) \u003d\u003e (((dB \\ {get(dB, i)}) \u003d (dB~ \\ {get(dB~, i)})) \u003d\u003e (forall x in set (field(recordtype(dB, i)) \\ {f}) \u0026 pre_getvalue(x, dB, i)))))","legal function application obligation:(((i in set usedIds(dB)) and ((f in set field(recordtype(dB, i))) and (isvalueoffield(v, f) and (not (iscomplete(dB, i) and isidentical(dB)))))) \u003d\u003e ((getvalue(f, dB, i) \u003d v) \u003d\u003e (((dB \\ {get(dB, i)}) \u003d (dB~ \\ {get(dB~, i)})) \u003d\u003e (forall x in set (field(recordtype(dB, i)) \\ {f}) \u0026 pre_getvalue(x, dB~, i)))))","legal function application obligation:((i in set usedIds(dB)) \u003d\u003e pre_recordtype(dB, i))","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, seq of (char)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, seq of (char)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, seq of (char)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(inv_Edition(v) and (is_(v, \u003cnil\u003e) or is_(v, nat)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, seq of (char)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, seq of (char)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, seq of (char)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(inv_Month(v) and (is_(v, \u003cnil\u003e) or is_(v, nat)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, seq of (char)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, nat1))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, seq of (char)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, nat1))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, seq of (char)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, seq of (char)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, seq of (char)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, nat1))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(inv_Year(v) and (is_(v, \u003cnil\u003e) or is_(v, nat)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_iscomplete(dB, i)","operation call obligation:(i in set usedIds(dB))","legal function application obligation:(forall i:Id, oldstate:mgd \u0026 ((i in set usedIds(dB)) \u003d\u003e pre_iscomplete(dB, i)))","legal function application obligation:(forall i:Id, oldstate:mgd \u0026 ((i in set usedIds(dB)) \u003d\u003e pre_iscomplete(dB, i)))","operation establishes postcondition obligation:(forall i:Id, oldstate:mgd \u0026 ((i in set usedIds(dB)) \u003d\u003e (iscomplete(dB, i) \u003c\u003d\u003e RESULT)))","legal function application obligation:((i in set usedIds(dB)) \u003d\u003e pre_get(dB~, i))","legal function application obligation:pre_get(dB, i)","legal function application obligation:(forall a:String, oldstate:mgd \u0026 (forall i in set RESULT \u0026 pre_get(dB, i)))","legal function application obligation:(forall a:String, oldstate:mgd \u0026 (forall i in set RESULT \u0026 (issubstring(a, (get(dB, i).author)) \u003d\u003e (forall record in set dB \u0026 (((record.id) not in set RESULT) \u003d\u003e pre_get(dB, i))))))","operation establishes postcondition obligation:(forall a:String, oldstate:mgd \u0026 (forall i in set RESULT \u0026 (issubstring(a, (get(dB, i).author)) and (not (exists record in set dB \u0026 (((record.id) not in set RESULT) and issubstring(a, (get(dB, i).author))))))))","legal function application obligation:(forall i:Id, oldstate:mgd \u0026 ((i in set usedIds(dB)) \u003d\u003e pre_get(dB, i)))","legal function application obligation:(forall i:Id, oldstate:mgd \u0026 ((i in set usedIds(dB)) \u003d\u003e pre_get(dB, i)))","operation establishes postcondition obligation:(forall i:Id, oldstate:mgd \u0026 ((i in set usedIds(dB)) \u003d\u003e (RESULT \u003d get(dB, i))))"] \ No newline at end of file diff --git a/core/pog/src/test/resources/examples/looseSL.result b/core/pog/src/test/resources/examples/looseSL.result index 83d1a22541..8eeb5e89be 100644 --- a/core/pog/src/test/resources/examples/looseSL.result +++ b/core/pog/src/test/resources/examples/looseSL.result @@ -1 +1 @@ -["map compatible obligation:(forall lval:LVAL, bind:Model \u0026 (forall mk_(val, b) in set lval \u0026 ((forall id in set ((dom b) inter (dom bind)) \u0026 (b(id) \u003d bind(id))) \u003d\u003e (forall ldom1 in set (dom b), rdom2 in set (dom bind) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (b(ldom1) \u003d bind(rdom2)))))))","legal map application obligation:(forall lval:LVAL, bind:Model \u0026 (forall mk_(val, b) in set lval \u0026 (forall id in set ((dom b) inter (dom bind)) \u0026 (id in set (dom b)))))","legal map application obligation:(forall lval:LVAL, bind:Model \u0026 (forall mk_(val, b) in set lval \u0026 (forall id in set ((dom b) inter (dom bind)) \u0026 (id in set (dom bind)))))","function establishes postcondition obligation:(forall s:set of (VAL) \u0026 post_SetToSeq(s, (if (s \u003d {})\nthen []\nelse let e in set s in ([e] ^ SetToSeq((s \\ {e}))))))","let be st existence obligation:(forall s:set of (VAL) \u0026 ((not (s \u003d {})) \u003d\u003e (exists e in set s \u0026 true)))","legal sequence application obligation:(forall l:seq of (VAL) \u0026 ((not ([] \u003d l)) \u003d\u003e ((not (exists [-]:seq of (VAL) \u0026 ([any1] \u003d l))) \u003d\u003e (forall i in set (inds l) \u0026 (forall j in set Permute(RestSeq(l, i)) \u0026 (i in set (inds l)))))))","legal sequence application obligation:(forall l:seq of (VAL), i:nat1 \u0026 (forall j in set ((inds l) \\ {i}) \u0026 (j in set (inds l))))","cases exhaustive obligation:(forall pat:Pattern \u0026 ((((exists mk_PatternName(mk_(nm, pos)):Pattern \u0026 (pat \u003d mk_PatternName(mk_(nm, pos)))) or (exists mk_MatchVal(-):Pattern \u0026 (pat \u003d mk_MatchVal(any1)))) or (exists mk_SetEnumPattern(els):Pattern \u0026 (pat \u003d mk_SetEnumPattern(els)))) or (exists mk_SetUnionPattern(lp, rp):Pattern \u0026 (pat \u003d mk_SetUnionPattern(lp, rp)))))","map compatible obligation:(forall mk_LetBeSTExpr(lhs, st_e, in_e):LetBeSTExpr, oldstate:Sigma \u0026 (true \u003d\u003e (forall ldom1 in set (dom m2), rdom2 in set (dom m) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (m2(ldom1) \u003d m(rdom2))))))","while loop termination obligation:NotYetImplemented","non-empty sequence obligation:(forall mk_CasesExpr(sel, altns, Others):CasesExpr, oldstate:Sigma \u0026 (alt_l \u003c\u003e []))","non-empty sequence obligation:(forall mk_CasesExpr(sel, altns, Others):CasesExpr, oldstate:Sigma \u0026 (true \u003d\u003e (true \u003d\u003e (alt_l \u003c\u003e []))))","operation call obligation:(forall mk_BinaryExpr(left_e, opr, right_e):BinaryExpr, oldstate:Sigma \u0026 (forall mk_(v, -) in set (l_lv union r_lv) \u0026 is_(v, SET)))","operation call obligation:(forall mk_BinaryExpr(left_e, opr, right_e):BinaryExpr, oldstate:Sigma \u0026 (true \u003d\u003e (true \u003d\u003e (forall mk_(v, -) in set (l_lv union r_lv) \u0026 is_(v, NUM)))))","map compatible obligation:(forall l_lv:LVAL, r_lv:LVAL, oldstate:Sigma \u0026 ((forall mk_(v, -) in set (l_lv union r_lv) \u0026 is_(v, SET)) \u003d\u003e (forall ldom1 in set (dom rm), rdom2 in set (dom lm) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (rm(ldom1) \u003d lm(rdom2))))))","map compatible obligation:(forall l_lv:LVAL, r_lv:LVAL, oldstate:Sigma \u0026 (forall ldom1 in set (dom rm), rdom2 in set (dom lm) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (rm(ldom1) \u003d lm(rdom2)))))","map compatible obligation:(forall l_lv:LVAL, opr:BinaryOp, r_lv:LVAL, oldstate:Sigma \u0026 ((forall mk_(v, -) in set (l_lv union r_lv) \u0026 is_(v, NUM)) \u003d\u003e (forall ldom1 in set (dom rm), rdom2 in set (dom lm) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (rm(ldom1) \u003d lm(rdom2))))))","map compatible obligation:(forall l_lv:LVAL, opr:BinaryOp, r_lv:LVAL, oldstate:Sigma \u0026 ((forall mk_(v, -) in set (l_lv union r_lv) \u0026 is_(v, NUM)) \u003d\u003e (forall ldom1 in set (dom rm), rdom2 in set (dom lm) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (rm(ldom1) \u003d lm(rdom2))))))","map compatible obligation:(forall l_lv:LVAL, opr:BinaryOp, r_lv:LVAL, oldstate:Sigma \u0026 ((forall mk_(v, -) in set (l_lv union r_lv) \u0026 is_(v, NUM)) \u003d\u003e (forall ldom1 in set (dom rm), rdom2 in set (dom lm) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (rm(ldom1) \u003d lm(rdom2))))))","legal sequence application obligation:(forall mk_SetEnumerationExpr(els):SetEnumerationExpr, oldstate:Sigma \u0026 (1 in set (inds els)))","legal sequence application obligation:(forall mk_SetEnumerationExpr(els):SetEnumerationExpr, oldstate:Sigma \u0026 (index in set (inds els)))","map compatible obligation:(forall mk_SetEnumerationExpr(els):SetEnumerationExpr, oldstate:Sigma \u0026 (forall mk_(s, m) in set sm_s, mk_(e, m2) in set elm_llv \u0026 ((forall id in set ((dom m) inter (dom m2)) \u0026 (m(id) \u003d m2(id))) \u003d\u003e (forall ldom1 in set (dom m), rdom2 in set (dom m2) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (m(ldom1) \u003d m2(rdom2)))))))","legal map application obligation:(forall mk_SetEnumerationExpr(els):SetEnumerationExpr, oldstate:Sigma \u0026 (forall mk_(s, m) in set sm_s, mk_(e, m2) in set elm_llv \u0026 (forall id in set ((dom m) inter (dom m2)) \u0026 (id in set (dom m)))))","legal map application obligation:(forall mk_SetEnumerationExpr(els):SetEnumerationExpr, oldstate:Sigma \u0026 (forall mk_(s, m) in set sm_s, mk_(e, m2) in set elm_llv \u0026 (forall id in set ((dom m) inter (dom m2)) \u0026 (id in set (dom m2)))))","operation call obligation:(forall mk_ApplyExpr(fct_e, arg_e):ApplyExpr, oldstate:Sigma \u0026 (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (curfn \u003c\u003e []))))))","type compatibility obligation:(forall lit:Literal, oldstate:Sigma \u0026 ((not is_(lit, NumLit)) \u003d\u003e is_((lit.val), bool)))","value binding obligation:(forall pat_p:Pattern, val_v:VAL, oldstate:Sigma \u0026 (exists mk_PatternName(id):Pattern \u0026 (mk_PatternName(id) \u003d pat_p)))","type compatibility obligation:(forall pat_p:Pattern, val_v:VAL, oldstate:Sigma \u0026 is_(pat_p, PatternName))","legal sequence application obligation:(forall els_lp:seq of (Pattern), val_lv:seq of (VAL), oldstate:Sigma \u0026 (forall i in set (inds els_lp) \u0026 (i in set (inds els_lp))))","legal sequence application obligation:(forall els_lp:seq of (Pattern), val_lv:seq of (VAL), oldstate:Sigma \u0026 (forall i in set (inds els_lp) \u0026 (i in set (inds val_lv))))","while loop termination obligation:NotYetImplemented","non-empty sequence obligation:(forall blk_l:BlkEnv, oldstate:Sigma \u0026 (tmpblk_l \u003c\u003e []))","non-empty sequence obligation:(forall blk_l:BlkEnv, oldstate:Sigma \u0026 (tmpblk_l \u003c\u003e []))","non-empty sequence obligation:(forall blk_l:BlkEnv, oldstate:Sigma \u0026 (tmpblk_l \u003c\u003e []))","type compatibility obligation:(forall mk_SetBind(pat_p, set_e):SetBind, oldstate:Sigma \u0026 is_(RESULT, set of ((BlkEnv * Model))))","comprehension map injectivity obligation:(forall val_l:seq of (ValueDef), oldstate:Sigma \u0026 (forall m1, m2 in set {{id |-\u003e {mk_(Look(env, id), model) | env in set env_s}} | id in set (dinter {SelDom(env) | env in set env_s})} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4))))))","legal function application obligation:(forall val_l:seq of (ValueDef), oldstate:Sigma \u0026 (forall id in set (dinter {SelDom(env) | env in set env_s}) \u0026 (forall env in set env_s \u0026 pre_Look(env, id))))","non-empty set obligation:(forall val_l:seq of (ValueDef), oldstate:Sigma \u0026 ({SelDom(env) | env in set env_s} \u003c\u003e {}))","comprehension map injectivity obligation:(forall fn_marg:map (Name) to (ExplFnDef), oldstate:Sigma \u0026 (forall m1, m2 in set {{nm |-\u003e mk_((fn_marg(nm).pat), (fn_marg(nm).body))} | nm in set (dom fn_marg)} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4))))))","legal map application obligation:(forall fn_marg:map (Name) to (ExplFnDef), oldstate:Sigma \u0026 (forall nm in set (dom fn_marg) \u0026 (nm in set (dom fn_marg))))","legal map application obligation:(forall fn_marg:map (Name) to (ExplFnDef), oldstate:Sigma \u0026 (forall nm in set (dom fn_marg) \u0026 (nm in set (dom fn_marg))))","non-empty sequence obligation:((curfn \u003c\u003e []) \u003d\u003e (curfn \u003c\u003e []))","non-empty sequence obligation:(env_l \u003c\u003e [])","non-empty sequence obligation:(env_l \u003c\u003e [])","non-empty sequence obligation:(env_l \u003c\u003e [])","non-empty sequence obligation:((hd env_l) \u003c\u003e [])","non-empty sequence obligation:(env_l \u003c\u003e [])","non-empty sequence obligation:(forall benv:BlkEnv, oldstate:Sigma \u0026 (env_l \u003c\u003e []))","non-empty sequence obligation:(forall benv:BlkEnv, oldstate:Sigma \u0026 (env_l \u003c\u003e []))","non-empty sequence obligation:(curfn \u003c\u003e [])","map compatible obligation:(forall nm:Name, oldstate:Sigma \u0026 (forall mk_(v, m) in set val_m(id) \u0026 (forall ldom1 in set (dom m), rdom2 in set (dom {id |-\u003e v}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (m(ldom1) \u003d {id |-\u003e v}(rdom2))))))","legal map application obligation:(forall nm:Name, oldstate:Sigma \u0026 (id in set (dom val_m)))","type compatibility obligation:(forall nm:Name, oldstate:Sigma \u0026 is_(RESULT, set of ((VAL * Model))))","legal map application obligation:(forall nm:Name, oldstate:Sigma \u0026 ((nm in set (dom fn_m)) \u003d\u003e (nm in set (dom fn_m))))","non-empty sequence obligation:(forall env:BlkEnv, id:UniqueId \u0026 ((exists mk_(nm, -) in set (elems env) \u0026 (nm \u003d id)) \u003d\u003e ((not (env \u003d [])) \u003d\u003e (env \u003c\u003e []))))","legal function application obligation:(forall env:BlkEnv, id:UniqueId \u0026 ((exists mk_(nm, -) in set (elems env) \u0026 (nm \u003d id)) \u003d\u003e ((not (env \u003d [])) \u003d\u003e let mk_(nm, val):NameVal \u003d (hd env) in ((not (nm \u003d id)) \u003d\u003e pre_Look((tl env), id)))))","non-empty sequence obligation:(forall env:BlkEnv, id:UniqueId \u0026 ((exists mk_(nm, -) in set (elems env) \u0026 (nm \u003d id)) \u003d\u003e ((not (env \u003d [])) \u003d\u003e let mk_(nm, val):NameVal \u003d (hd env) in ((not (nm \u003d id)) \u003d\u003e (env \u003c\u003e [])))))","comprehension map injectivity obligation:(forall val_m:map (UniqueId) to (LVAL), upd_m:map (UniqueId) to (LVAL) \u0026 (forall m1, m2 in set {{id |-\u003e (if (id in set (dom val_m))\nthen (val_m(id) union upd_m(id))\nelse upd_m(id))} | id in set (dom upd_m)} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4))))))","legal map application obligation:(forall val_m:map (UniqueId) to (LVAL), upd_m:map (UniqueId) to (LVAL) \u0026 (forall id in set (dom upd_m) \u0026 ((id in set (dom val_m)) \u003d\u003e (id in set (dom val_m)))))","legal map application obligation:(forall val_m:map (UniqueId) to (LVAL), upd_m:map (UniqueId) to (LVAL) \u0026 (forall id in set (dom upd_m) \u0026 ((id in set (dom val_m)) \u003d\u003e (id in set (dom upd_m)))))","legal map application obligation:(forall val_m:map (UniqueId) to (LVAL), upd_m:map (UniqueId) to (LVAL) \u0026 (forall id in set (dom upd_m) \u0026 ((not (id in set (dom val_m))) \u003d\u003e (id in set (dom upd_m)))))"] \ No newline at end of file +["map compatible obligation:(forall lval:LVAL, bind:Model \u0026 (forall mk_(val, b) in set lval \u0026 ((forall id in set ((dom b) inter (dom bind)) \u0026 (b(id) \u003d bind(id))) \u003d\u003e (forall ldom1 in set (dom b), rdom2 in set (dom bind) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (b(ldom1) \u003d bind(rdom2)))))))","legal map application obligation:(forall lval:LVAL, bind:Model \u0026 (forall mk_(val, b) in set lval \u0026 (forall id in set ((dom b) inter (dom bind)) \u0026 (id in set (dom b)))))","legal map application obligation:(forall lval:LVAL, bind:Model \u0026 (forall mk_(val, b) in set lval \u0026 (forall id in set ((dom b) inter (dom bind)) \u0026 (id in set (dom bind)))))","function establishes postcondition obligation:(forall s:set of (VAL) \u0026 post_SetToSeq(s, (if (s \u003d {})\nthen []\nelse let e in set s in ([e] ^ SetToSeq((s \\ {e}))))))","let be st existence obligation:(forall s:set of (VAL) \u0026 ((not (s \u003d {})) \u003d\u003e (exists e in set s \u0026 true)))","legal sequence application obligation:(forall l:seq of (VAL) \u0026 ((not ([] \u003d l)) \u003d\u003e ((not (exists [-]:seq of (VAL) \u0026 ([any1] \u003d l))) \u003d\u003e (forall i in set (inds l) \u0026 (forall j in set Permute(RestSeq(l, i)) \u0026 (i in set (inds l)))))))","legal sequence application obligation:(forall l:seq of (VAL), i:nat1 \u0026 (forall j in set ((inds l) \\ {i}) \u0026 (j in set (inds l))))","cases exhaustive obligation:(forall pat:Pattern \u0026 ((((exists mk_PatternName(mk_(nm, pos)):Pattern \u0026 (pat \u003d mk_PatternName(mk_(nm, pos)))) or (exists mk_MatchVal(-):Pattern \u0026 (pat \u003d mk_MatchVal(any1)))) or (exists mk_SetEnumPattern(els):Pattern \u0026 (pat \u003d mk_SetEnumPattern(els)))) or (exists mk_SetUnionPattern(lp, rp):Pattern \u0026 (pat \u003d mk_SetUnionPattern(lp, rp)))))","map compatible obligation:(forall mk_LetBeSTExpr(lhs, st_e, in_e):LetBeSTExpr, oldstate:Sigma \u0026 (true \u003d\u003e (forall ldom1 in set (dom m2), rdom2 in set (dom m) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (m2(ldom1) \u003d m(rdom2))))))","while loop termination obligation:...","non-empty sequence obligation:(forall mk_CasesExpr(sel, altns, Others):CasesExpr, oldstate:Sigma \u0026 (alt_l \u003c\u003e []))","non-empty sequence obligation:(forall mk_CasesExpr(sel, altns, Others):CasesExpr, oldstate:Sigma \u0026 (true \u003d\u003e (true \u003d\u003e (alt_l \u003c\u003e []))))","operation call obligation:(forall mk_BinaryExpr(left_e, opr, right_e):BinaryExpr, oldstate:Sigma \u0026 (forall mk_(v, -) in set (l_lv union r_lv) \u0026 is_(v, SET)))","operation call obligation:(forall mk_BinaryExpr(left_e, opr, right_e):BinaryExpr, oldstate:Sigma \u0026 (true \u003d\u003e (true \u003d\u003e (forall mk_(v, -) in set (l_lv union r_lv) \u0026 is_(v, NUM)))))","map compatible obligation:(forall l_lv:LVAL, r_lv:LVAL, oldstate:Sigma \u0026 ((forall mk_(v, -) in set (l_lv union r_lv) \u0026 is_(v, SET)) \u003d\u003e (forall ldom1 in set (dom rm), rdom2 in set (dom lm) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (rm(ldom1) \u003d lm(rdom2))))))","map compatible obligation:(forall l_lv:LVAL, r_lv:LVAL, oldstate:Sigma \u0026 (forall ldom1 in set (dom rm), rdom2 in set (dom lm) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (rm(ldom1) \u003d lm(rdom2)))))","map compatible obligation:(forall l_lv:LVAL, opr:BinaryOp, r_lv:LVAL, oldstate:Sigma \u0026 ((forall mk_(v, -) in set (l_lv union r_lv) \u0026 is_(v, NUM)) \u003d\u003e (forall ldom1 in set (dom rm), rdom2 in set (dom lm) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (rm(ldom1) \u003d lm(rdom2))))))","map compatible obligation:(forall l_lv:LVAL, opr:BinaryOp, r_lv:LVAL, oldstate:Sigma \u0026 ((forall mk_(v, -) in set (l_lv union r_lv) \u0026 is_(v, NUM)) \u003d\u003e (forall ldom1 in set (dom rm), rdom2 in set (dom lm) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (rm(ldom1) \u003d lm(rdom2))))))","map compatible obligation:(forall l_lv:LVAL, opr:BinaryOp, r_lv:LVAL, oldstate:Sigma \u0026 ((forall mk_(v, -) in set (l_lv union r_lv) \u0026 is_(v, NUM)) \u003d\u003e (forall ldom1 in set (dom rm), rdom2 in set (dom lm) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (rm(ldom1) \u003d lm(rdom2))))))","legal sequence application obligation:(forall mk_SetEnumerationExpr(els):SetEnumerationExpr, oldstate:Sigma \u0026 (1 in set (inds els)))","legal sequence application obligation:(forall mk_SetEnumerationExpr(els):SetEnumerationExpr, oldstate:Sigma \u0026 (index in set (inds els)))","map compatible obligation:(forall mk_SetEnumerationExpr(els):SetEnumerationExpr, oldstate:Sigma \u0026 (forall mk_(s, m) in set sm_s, mk_(e, m2) in set elm_llv \u0026 ((forall id in set ((dom m) inter (dom m2)) \u0026 (m(id) \u003d m2(id))) \u003d\u003e (forall ldom1 in set (dom m), rdom2 in set (dom m2) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (m(ldom1) \u003d m2(rdom2)))))))","legal map application obligation:(forall mk_SetEnumerationExpr(els):SetEnumerationExpr, oldstate:Sigma \u0026 (forall mk_(s, m) in set sm_s, mk_(e, m2) in set elm_llv \u0026 (forall id in set ((dom m) inter (dom m2)) \u0026 (id in set (dom m)))))","legal map application obligation:(forall mk_SetEnumerationExpr(els):SetEnumerationExpr, oldstate:Sigma \u0026 (forall mk_(s, m) in set sm_s, mk_(e, m2) in set elm_llv \u0026 (forall id in set ((dom m) inter (dom m2)) \u0026 (id in set (dom m2)))))","operation call obligation:(forall mk_ApplyExpr(fct_e, arg_e):ApplyExpr, oldstate:Sigma \u0026 (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (curfn \u003c\u003e []))))))","type compatibility obligation:(forall lit:Literal, oldstate:Sigma \u0026 ((not is_(lit, NumLit)) \u003d\u003e is_((lit.val), bool)))","value binding obligation:(forall pat_p:Pattern, val_v:VAL, oldstate:Sigma \u0026 (exists mk_PatternName(id):Pattern \u0026 (mk_PatternName(id) \u003d pat_p)))","type compatibility obligation:(forall pat_p:Pattern, val_v:VAL, oldstate:Sigma \u0026 is_(pat_p, PatternName))","legal sequence application obligation:(forall els_lp:seq of (Pattern), val_lv:seq of (VAL), oldstate:Sigma \u0026 (forall i in set (inds els_lp) \u0026 (i in set (inds els_lp))))","legal sequence application obligation:(forall els_lp:seq of (Pattern), val_lv:seq of (VAL), oldstate:Sigma \u0026 (forall i in set (inds els_lp) \u0026 (i in set (inds val_lv))))","while loop termination obligation:...","non-empty sequence obligation:(forall blk_l:BlkEnv, oldstate:Sigma \u0026 (tmpblk_l \u003c\u003e []))","non-empty sequence obligation:(forall blk_l:BlkEnv, oldstate:Sigma \u0026 (tmpblk_l \u003c\u003e []))","non-empty sequence obligation:(forall blk_l:BlkEnv, oldstate:Sigma \u0026 (tmpblk_l \u003c\u003e []))","type compatibility obligation:(forall mk_SetBind(pat_p, set_e):SetBind, oldstate:Sigma \u0026 is_(RESULT, set of ((BlkEnv * Model))))","comprehension map injectivity obligation:(forall val_l:seq of (ValueDef), oldstate:Sigma \u0026 (forall m1, m2 in set {{id |-\u003e {mk_(Look(env, id), model) | env in set env_s}} | id in set (dinter {SelDom(env) | env in set env_s})} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4))))))","legal function application obligation:(forall val_l:seq of (ValueDef), oldstate:Sigma \u0026 (forall id in set (dinter {SelDom(env) | env in set env_s}) \u0026 (forall env in set env_s \u0026 pre_Look(env, id))))","non-empty set obligation:(forall val_l:seq of (ValueDef), oldstate:Sigma \u0026 ({SelDom(env) | env in set env_s} \u003c\u003e {}))","comprehension map injectivity obligation:(forall fn_marg:map (Name) to (ExplFnDef), oldstate:Sigma \u0026 (forall m1, m2 in set {{nm |-\u003e mk_((fn_marg(nm).pat), (fn_marg(nm).body))} | nm in set (dom fn_marg)} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4))))))","legal map application obligation:(forall fn_marg:map (Name) to (ExplFnDef), oldstate:Sigma \u0026 (forall nm in set (dom fn_marg) \u0026 (nm in set (dom fn_marg))))","legal map application obligation:(forall fn_marg:map (Name) to (ExplFnDef), oldstate:Sigma \u0026 (forall nm in set (dom fn_marg) \u0026 (nm in set (dom fn_marg))))","non-empty sequence obligation:((curfn \u003c\u003e []) \u003d\u003e (curfn \u003c\u003e []))","non-empty sequence obligation:(env_l \u003c\u003e [])","non-empty sequence obligation:(env_l \u003c\u003e [])","non-empty sequence obligation:(env_l \u003c\u003e [])","non-empty sequence obligation:((hd env_l) \u003c\u003e [])","non-empty sequence obligation:(env_l \u003c\u003e [])","non-empty sequence obligation:(forall benv:BlkEnv, oldstate:Sigma \u0026 (env_l \u003c\u003e []))","non-empty sequence obligation:(forall benv:BlkEnv, oldstate:Sigma \u0026 (env_l \u003c\u003e []))","non-empty sequence obligation:(curfn \u003c\u003e [])","map compatible obligation:(forall nm:Name, oldstate:Sigma \u0026 (forall mk_(v, m) in set val_m(id) \u0026 (forall ldom1 in set (dom m), rdom2 in set (dom {id |-\u003e v}) \u0026 ((ldom1 \u003d rdom2) \u003d\u003e (m(ldom1) \u003d {id |-\u003e v}(rdom2))))))","legal map application obligation:(forall nm:Name, oldstate:Sigma \u0026 (id in set (dom val_m)))","type compatibility obligation:(forall nm:Name, oldstate:Sigma \u0026 is_(RESULT, set of ((VAL * Model))))","legal map application obligation:(forall nm:Name, oldstate:Sigma \u0026 ((nm in set (dom fn_m)) \u003d\u003e (nm in set (dom fn_m))))","non-empty sequence obligation:(forall env:BlkEnv, id:UniqueId \u0026 ((exists mk_(nm, -) in set (elems env) \u0026 (nm \u003d id)) \u003d\u003e ((not (env \u003d [])) \u003d\u003e (env \u003c\u003e []))))","legal function application obligation:(forall env:BlkEnv, id:UniqueId \u0026 ((exists mk_(nm, -) in set (elems env) \u0026 (nm \u003d id)) \u003d\u003e ((not (env \u003d [])) \u003d\u003e let mk_(nm, val):NameVal \u003d (hd env) in ((not (nm \u003d id)) \u003d\u003e pre_Look((tl env), id)))))","non-empty sequence obligation:(forall env:BlkEnv, id:UniqueId \u0026 ((exists mk_(nm, -) in set (elems env) \u0026 (nm \u003d id)) \u003d\u003e ((not (env \u003d [])) \u003d\u003e let mk_(nm, val):NameVal \u003d (hd env) in ((not (nm \u003d id)) \u003d\u003e (env \u003c\u003e [])))))","comprehension map injectivity obligation:(forall val_m:map (UniqueId) to (LVAL), upd_m:map (UniqueId) to (LVAL) \u0026 (forall m1, m2 in set {{id |-\u003e (if (id in set (dom val_m))\nthen (val_m(id) union upd_m(id))\nelse upd_m(id))} | id in set (dom upd_m)} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4))))))","legal map application obligation:(forall val_m:map (UniqueId) to (LVAL), upd_m:map (UniqueId) to (LVAL) \u0026 (forall id in set (dom upd_m) \u0026 ((id in set (dom val_m)) \u003d\u003e (id in set (dom val_m)))))","legal map application obligation:(forall val_m:map (UniqueId) to (LVAL), upd_m:map (UniqueId) to (LVAL) \u0026 (forall id in set (dom upd_m) \u0026 ((id in set (dom val_m)) \u003d\u003e (id in set (dom upd_m)))))","legal map application obligation:(forall val_m:map (UniqueId) to (LVAL), upd_m:map (UniqueId) to (LVAL) \u0026 (forall id in set (dom upd_m) \u0026 ((not (id in set (dom val_m))) \u003d\u003e (id in set (dom upd_m)))))"] \ No newline at end of file diff --git a/core/pog/src/test/resources/examples/realmSL.result b/core/pog/src/test/resources/examples/realmSL.result index 227ed88b53..c979d2ace4 100644 --- a/core/pog/src/test/resources/examples/realmSL.result +++ b/core/pog/src/test/resources/examples/realmSL.result @@ -1 +1 @@ -["type invariant satisfiable obligation:(exists n:N \u0026 (n \u003c max))","type invariant satisfiable obligation:(exists mk_NSeg(ps):NSeg \u0026 ((card ps) \u003d 2))","let be st existence obligation:(forall mk_NSeg(pts):NSeg \u0026 (exists p in set pts \u0026 true))","let be st existence obligation:(forall mk_NSeg(pts):NSeg \u0026 (forall p in set pts \u0026 (exists q in set (pts \\ {p}) \u0026 true)))","non-zero obligation:(forall s:NSeg, t:NSeg \u0026 let mk_(mk_NPoint(x11, y11), mk_NPoint(x12, y12)):(NPoint * NPoint) \u003d SelPoints(s), mk_(mk_NPoint(x21, y21), mk_NPoint(x22, y22)):(NPoint * NPoint) \u003d SelPoints(t) in let a11:int \u003d (x11 - x12), a12:int \u003d (x22 - x21), a21:int \u003d (y11 - y12), a22:int \u003d (y22 - y21), b1:int \u003d (x11 - x21), b2:int \u003d (y11 - y21) in let d1:int \u003d ((b1 * a22) - (b2 * a12)), d2:int \u003d ((b2 * a11) - (b1 * a21)), d:int \u003d ((a11 * a22) - (a12 * a21)) in ((d \u003c\u003e 0) \u003d\u003e (d \u003c\u003e 0)))","non-zero obligation:(forall s:NSeg, t:NSeg \u0026 let mk_(mk_NPoint(x11, y11), mk_NPoint(x12, y12)):(NPoint * NPoint) \u003d SelPoints(s), mk_(mk_NPoint(x21, y21), mk_NPoint(x22, y22)):(NPoint * NPoint) \u003d SelPoints(t) in let a11:int \u003d (x11 - x12), a12:int \u003d (x22 - x21), a21:int \u003d (y11 - y12), a22:int \u003d (y22 - y21), b1:int \u003d (x11 - x21), b2:int \u003d (y11 - y21) in let d1:int \u003d ((b1 * a22) - (b2 * a12)), d2:int \u003d ((b2 * a11) - (b1 * a21)), d:int \u003d ((a11 * a22) - (a12 * a21)) in ((d \u003c\u003e 0) \u003d\u003e (d \u003c\u003e 0)))","type compatibility obligation:(forall s:NSeg, t:NSeg \u0026 (Intersect(s, t) \u003d\u003e let mk_(mk_NPoint(x11, y11), mk_NPoint(x12, y12)):(NPoint * NPoint) \u003d SelPoints(s), mk_(mk_NPoint(x21, y21), mk_NPoint(x22, y22)):(NPoint * NPoint) \u003d SelPoints(t) in let a11:int \u003d (x11 - x12), a12:int \u003d (x22 - x21), a21:int \u003d (y11 - y12), a22:int \u003d (y22 - y21), b1:int \u003d (x11 - x21), b2:int \u003d (y11 - y21) in let d1:int \u003d ((b1 * a22) - (b2 * a12)), d:int \u003d ((a11 * a22) - (a12 * a21)) in ((d \u003c\u003e 0) \u003d\u003e let x0:int \u003d ((x11 * d) + (d1 * (x12 - x11))), y0:int \u003d ((y11 * d) + (d1 * (y12 - y11))) in inv_N(RoundToN((abs x0), (abs d))))))","type compatibility obligation:(forall s:NSeg, t:NSeg \u0026 (Intersect(s, t) \u003d\u003e let mk_(mk_NPoint(x11, y11), mk_NPoint(x12, y12)):(NPoint * NPoint) \u003d SelPoints(s), mk_(mk_NPoint(x21, y21), mk_NPoint(x22, y22)):(NPoint * NPoint) \u003d SelPoints(t) in let a11:int \u003d (x11 - x12), a12:int \u003d (x22 - x21), a21:int \u003d (y11 - y12), a22:int \u003d (y22 - y21), b1:int \u003d (x11 - x21), b2:int \u003d (y11 - y21) in let d1:int \u003d ((b1 * a22) - (b2 * a12)), d:int \u003d ((a11 * a22) - (a12 * a21)) in ((d \u003c\u003e 0) \u003d\u003e let x0:int \u003d ((x11 * d) + (d1 * (x12 - x11))), y0:int \u003d ((y11 * d) + (d1 * (y12 - y11))) in inv_N(RoundToN((abs y0), (abs d))))))","non-zero obligation:(forall a:nat, b:nat \u0026 ((a \u003e\u003d b) \u003d\u003e (b \u003c\u003e 0)))","type compatibility obligation:(forall a:nat, b:nat \u0026 (let mk_(z, aa):((int * int) | (nat * nat)) \u003d (if (a \u003e\u003d b)\nthen mk_((a div b), (a mod b))\nelse mk_(0, a)) in (if ((aa \u003d 0) or ((2 * aa) \u003c\u003d b))\nthen z\nelse (z + 1)) \u003e\u003d 0))","type invariant satisfiable obligation:(exists mk_Realm(ps, ss):Realm \u0026 ((forall mk_NSeg(pts) in set ss \u0026 (pts subset ps)) and ((forall s in set ss, p in set ps \u0026 (not In(p, s))) and (forall s1, s2 in set ss \u0026 ((s1 \u003c\u003e s2) \u003d\u003e ((not Intersect(s1, s2)) and (not Overlap(s1, s2))))))))","type compatibility obligation:(forall mk_Realm(ps, ss):Realm, p:NPoint \u0026 ((not (exists s in set ss \u0026 In(p, s))) \u003d\u003e ((p in set ps) \u003d\u003e inv_Realm(mk_Realm(ps, ss)))))","type compatibility obligation:(forall mk_Realm(ps, ss):Realm, p:NPoint \u0026 ((not (exists s in set ss \u0026 In(p, s))) \u003d\u003e ((not (p in set ps)) \u003d\u003e ((forall s in set ss \u0026 (p not in set E(s))) \u003d\u003e inv_Realm(mk_Realm((ps union {p}), ss))))))","type compatibility obligation:(forall mk_Realm(ps, ss):Realm, p:NPoint \u0026 ((not (exists s in set ss \u0026 In(p, s))) \u003d\u003e ((not (p in set ps)) \u003d\u003e ((not (forall s in set ss \u0026 (p not in set E(s)))) \u003d\u003e let s_env:set of (NSeg) \u003d {s | s in set ss \u0026 (p in set E(s))} in (forall mk_NSeg({p1, p2}) in set s_env \u0026 ((p not in set {p1, p2}) \u003d\u003e inv_NSeg(mk_NSeg({p1, p}))))))))","type compatibility obligation:(forall mk_Realm(ps, ss):Realm, p:NPoint \u0026 ((not (exists s in set ss \u0026 In(p, s))) \u003d\u003e ((not (p in set ps)) \u003d\u003e ((not (forall s in set ss \u0026 (p not in set E(s)))) \u003d\u003e let s_env:set of (NSeg) \u003d {s | s in set ss \u0026 (p in set E(s))} in (forall mk_NSeg({p1, p2}) in set s_env \u0026 ((p not in set {p1, p2}) \u003d\u003e inv_NSeg(mk_NSeg({p, p2}))))))))","type compatibility obligation:(forall mk_Realm(ps, ss):Realm, p:NPoint \u0026 ((not (exists s in set ss \u0026 In(p, s))) \u003d\u003e ((not (p in set ps)) \u003d\u003e ((not (forall s in set ss \u0026 (p not in set E(s)))) \u003d\u003e let s_env:set of (NSeg) \u003d {s | s in set ss \u0026 (p in set E(s))} in let ss1:set of (NSeg) \u003d (dunion {{mk_NSeg({p1, p}), mk_NSeg({p, p2})} | mk_NSeg({p1, p2}) in set s_env \u0026 (p not in set {p1, p2})}) in inv_Realm(mk_Realm((ps union {p}), ((ss union ss1) \\ s_env)))))))","type compatibility obligation:(forall mk_Realm(ps, ss):Realm, s:NSeg \u0026 (((s.pts) subset ps) \u003d\u003e ((s in set ss) \u003d\u003e inv_Realm(mk_Realm(ps, ss)))))","type compatibility obligation:(forall mk_Realm(ps, ss):Realm, s:NSeg \u0026 (((s.pts) subset ps) \u003d\u003e ((not (s in set ss)) \u003d\u003e (((forall p in set ps \u0026 (p not in set (E(s) \\ EndPoints(ss)))) and (forall t in set ss \u0026 ((not Intersect(s, t)) and (not Overlap(s, t))))) \u003d\u003e inv_Realm(mk_Realm(ps, (ss union {s})))))))","legal function application obligation:(forall mk_Realm(ps, ss):Realm, s:NSeg \u0026 (((s.pts) subset ps) \u003d\u003e ((not (s in set ss)) \u003d\u003e ((not ((forall p in set ps \u0026 (p not in set (E(s) \\ EndPoints(ss)))) and (forall t in set ss \u0026 ((not Intersect(s, t)) and (not Overlap(s, t)))))) \u003d\u003e let p_env:set of (NPoint) \u003d ({p | p in set (ps inter E(s))} \\ EndPoints(ss)), s_inter:set of (NSeg) \u003d {t | t in set ss \u0026 Intersect(s, t)} in pre_ChopNPoints(p_env, {s})))))","type compatibility obligation:(forall mk_Realm(ps, ss):Realm, s:NSeg \u0026 (((s.pts) subset ps) \u003d\u003e ((not (s in set ss)) \u003d\u003e ((not ((forall p in set ps \u0026 (p not in set (E(s) \\ EndPoints(ss)))) and (forall t in set ss \u0026 ((not Intersect(s, t)) and (not Overlap(s, t)))))) \u003d\u003e let p_env:set of (NPoint) \u003d ({p | p in set (ps inter E(s))} \\ EndPoints(ss)), s_inter:set of (NSeg) \u003d {t | t in set ss \u0026 Intersect(s, t)} in let ss1:set of (NSeg) \u003d ChopNPoints(p_env, {s}) in let mk_(new_ps, new_ss):(set of (NPoint) * set of (NSeg)) \u003d ChopNSegs(ss, s_inter, ss1, {}) in inv_Realm(mk_Realm((ps union new_ps), new_ss))))))","let be st existence obligation:(forall ps:set of (NPoint), ss:set of (NSeg) \u0026 ((forall p in set ps \u0026 (exists s in set ss \u0026 ((p in set E(s)) and (p not in set (s.pts))))) \u003d\u003e ((not (ps \u003d {})) \u003d\u003e (exists p in set ps \u0026 true))))","let be st existence obligation:(forall ps:set of (NPoint), ss:set of (NSeg) \u0026 ((forall p in set ps \u0026 (exists s in set ss \u0026 ((p in set E(s)) and (p not in set (s.pts))))) \u003d\u003e ((not (ps \u003d {})) \u003d\u003e (forall p in set ps \u0026 let s_env:set of (NSeg) \u003d {s | s in set ss \u0026 ((p in set E(s)) and (p not in set (s.pts)))} in (exists s in set s_env \u0026 true)))))","legal function application obligation:(forall ps:set of (NPoint), ss:set of (NSeg) \u0026 ((forall p in set ps \u0026 (exists s in set ss \u0026 ((p in set E(s)) and (p not in set (s.pts))))) \u003d\u003e ((not (ps \u003d {})) \u003d\u003e (forall p in set ps \u0026 let s_env:set of (NSeg) \u003d {s | s in set ss \u0026 ((p in set E(s)) and (p not in set (s.pts)))} in (forall s in set s_env \u0026 let mk_(p1, p2):(NPoint * NPoint) \u003d SelPoints(s) in pre_ChopNPoints((ps \\ {p}), ((ss \\ {s}) union {mk_NSeg({p1, p}), mk_NSeg({p2, p})})))))))","type compatibility obligation:(forall ps:set of (NPoint), ss:set of (NSeg) \u0026 ((forall p in set ps \u0026 (exists s in set ss \u0026 ((p in set E(s)) and (p not in set (s.pts))))) \u003d\u003e ((not (ps \u003d {})) \u003d\u003e (forall p in set ps \u0026 let s_env:set of (NSeg) \u003d {s | s in set ss \u0026 ((p in set E(s)) and (p not in set (s.pts)))} in (forall s in set s_env \u0026 let mk_(p1, p2):(NPoint * NPoint) \u003d SelPoints(s) in inv_NSeg(mk_NSeg({p1, p})))))))","type compatibility obligation:(forall ps:set of (NPoint), ss:set of (NSeg) \u0026 ((forall p in set ps \u0026 (exists s in set ss \u0026 ((p in set E(s)) and (p not in set (s.pts))))) \u003d\u003e ((not (ps \u003d {})) \u003d\u003e (forall p in set ps \u0026 let s_env:set of (NSeg) \u003d {s | s in set ss \u0026 ((p in set E(s)) and (p not in set (s.pts)))} in (forall s in set s_env \u0026 let mk_(p1, p2):(NPoint * NPoint) \u003d SelPoints(s) in inv_NSeg(mk_NSeg({p2, p})))))))","let be st existence obligation:(forall ss:set of (NSeg), s_inter:set of (NSeg), newss:set of (NSeg), ps:set of (NPoint) \u0026 ((not (s_inter \u003d {})) \u003d\u003e (exists t in set s_inter \u0026 true)))","legal function application obligation:(forall ss:set of (NSeg), s_inter:set of (NSeg), newss:set of (NSeg), ps:set of (NPoint) \u0026 ((not (s_inter \u003d {})) \u003d\u003e (forall t in set s_inter \u0026 let {s}:set of (NSeg) \u003d {s | s in set newss \u0026 Intersect(s, t)} in pre_Intersection(t, s))))","type compatibility obligation:(forall ss:set of (NSeg), s_inter:set of (NSeg), newss:set of (NSeg), ps:set of (NPoint) \u0026 ((not (s_inter \u003d {})) \u003d\u003e (forall t in set s_inter \u0026 let {s}:set of (NSeg) \u003d {s | s in set newss \u0026 Intersect(s, t)} in let p:NPoint \u003d Intersection(t, s) in (forall sp in set (s.pts) \u0026 ((p \u003c\u003e sp) \u003d\u003e inv_NSeg(mk_NSeg({p, sp})))))))","type compatibility obligation:(forall ss:set of (NSeg), s_inter:set of (NSeg), newss:set of (NSeg), ps:set of (NPoint) \u0026 ((not (s_inter \u003d {})) \u003d\u003e (forall t in set s_inter \u0026 let {s}:set of (NSeg) \u003d {s | s in set newss \u0026 Intersect(s, t)} in let p:NPoint \u003d Intersection(t, s) in (forall tp in set (t.pts) \u0026 ((p \u003c\u003e tp) \u003d\u003e inv_NSeg(mk_NSeg({p, tp})))))))","type compatibility obligation:(forall s:NSeg \u0026 let mk_(p1, p2):(NPoint * NPoint) \u003d SelPoints(s) in (forall x in set DiffX(p1, p2), y in set DiffY(p1, p2) \u0026 ((0 \u003c y) \u003d\u003e ((y \u003c (max - 1)) \u003d\u003e (inv_N((y - 1)) and is_((y - 1), nat))))))","type compatibility obligation:(forall s:NSeg \u0026 let mk_(p1, p2):(NPoint * NPoint) \u003d SelPoints(s) in (forall x in set DiffX(p1, p2), y in set DiffY(p1, p2) \u0026 ((0 \u003c y) \u003d\u003e ((y \u003c (max - 1)) \u003d\u003e inv_N((y + 1))))))","type compatibility obligation:(forall s:NSeg \u0026 let mk_(p1, p2):(NPoint * NPoint) \u003d SelPoints(s) in (forall x in set DiffX(p1, p2), y in set DiffY(p1, p2) \u0026 ((0 \u003c y) \u003d\u003e ((y \u003c (max - 1)) \u003d\u003e inv_NSeg(mk_NSeg({mk_NPoint(x, (y - 1)), mk_NPoint(x, (y + 1))}))))))","type compatibility obligation:(forall s:NSeg \u0026 let mk_(p1, p2):(NPoint * NPoint) \u003d SelPoints(s) in (forall x in set DiffX(p1, p2), y in set DiffY(p1, p2) \u0026 ((not ((0 \u003c y) and ((y \u003c (max - 1)) and Intersect(mk_NSeg({mk_NPoint(x, (y - 1)), mk_NPoint(x, (y + 1))}), s)))) \u003d\u003e ((0 \u003c x) \u003d\u003e ((x \u003c (max - 1)) \u003d\u003e (inv_N((x - 1)) and is_((x - 1), nat)))))))","type compatibility obligation:(forall s:NSeg \u0026 let mk_(p1, p2):(NPoint * NPoint) \u003d SelPoints(s) in (forall x in set DiffX(p1, p2), y in set DiffY(p1, p2) \u0026 ((not ((0 \u003c y) and ((y \u003c (max - 1)) and Intersect(mk_NSeg({mk_NPoint(x, (y - 1)), mk_NPoint(x, (y + 1))}), s)))) \u003d\u003e ((0 \u003c x) \u003d\u003e ((x \u003c (max - 1)) \u003d\u003e inv_N((x + 1)))))))","type compatibility obligation:(forall s:NSeg \u0026 let mk_(p1, p2):(NPoint * NPoint) \u003d SelPoints(s) in (forall x in set DiffX(p1, p2), y in set DiffY(p1, p2) \u0026 ((not ((0 \u003c y) and ((y \u003c (max - 1)) and Intersect(mk_NSeg({mk_NPoint(x, (y - 1)), mk_NPoint(x, (y + 1))}), s)))) \u003d\u003e ((0 \u003c x) \u003d\u003e ((x \u003c (max - 1)) \u003d\u003e inv_NSeg(mk_NSeg({mk_NPoint((x - 1), y), mk_NPoint((x + 1), y)})))))))","legal sequence application obligation:(forall ss:set of (NSeg) \u0026 (forall sl in set AllLists(ss) \u0026 (forall i in set (inds sl) \u0026 (i in set (inds sl)))))","legal sequence application obligation:(forall ss:set of (NSeg) \u0026 (forall sl in set AllLists(ss) \u0026 (forall i in set (inds sl) \u0026 ((if (i \u003d (len sl))\nthen 1\nelse (i + 1)) in set (inds sl)))))","legal sequence application obligation:(forall ss:set of (NSeg) \u0026 (forall sl in set AllLists(ss) \u0026 (forall i in set (inds sl) \u0026 (Meet(sl(i), sl((if (i \u003d (len sl))\nthen 1\nelse (i + 1)))) \u003d\u003e (forall j in set ((inds sl) \\ {(if (i \u003d 1)\nthen (len sl)\nelse (i - 1)), i, (if (i \u003d (len sl))\nthen 1\nelse (i + 1))}) \u0026 (i in set (inds sl)))))))","legal sequence application obligation:(forall ss:set of (NSeg) \u0026 (forall sl in set AllLists(ss) \u0026 (forall i in set (inds sl) \u0026 (Meet(sl(i), sl((if (i \u003d (len sl))\nthen 1\nelse (i + 1)))) \u003d\u003e (forall j in set ((inds sl) \\ {(if (i \u003d 1)\nthen (len sl)\nelse (i - 1)), i, (if (i \u003d (len sl))\nthen 1\nelse (i + 1))}) \u0026 (j in set (inds sl)))))))","type invariant satisfiable obligation:(exists ss:Cycle \u0026 CycleCheck(ss))","legal function application obligation:(forall p:NPoint, c:Cycle \u0026 ((not OnCycle(p, c)) \u003d\u003e pre_SR(p, c)))","legal function application obligation:(forall p:NPoint, ss:Cycle \u0026 (CycleCheck(ss) \u003d\u003e (forall s in set ss \u0026 let mk_(p1, p2):(NPoint * NPoint) \u003d SelPoints(s) in (((p.y) \u003c (max - 1)) \u003d\u003e pre_SP(p)))))","legal function application obligation:(forall p:NPoint, ss:Cycle \u0026 (CycleCheck(ss) \u003d\u003e (forall s in set ss \u0026 let mk_(p1, p2):(NPoint * NPoint) \u003d SelPoints(s) in (((p.y) \u003c (max - 1)) \u003d\u003e ((not On(p1, SP(p))) \u003d\u003e pre_SP(p))))))","legal function application obligation:(forall p:NPoint, ss:Cycle \u0026 (CycleCheck(ss) \u003d\u003e (forall s in set ss \u0026 let mk_(p1, p2):(NPoint * NPoint) \u003d SelPoints(s) in ((not (((p.y) \u003c (max - 1)) and ((not On(p1, SP(p))) and On(p2, SP(p))))) \u003d\u003e (((p.y) \u003c (max - 1)) \u003d\u003e pre_SP(p))))))","legal function application obligation:(forall p:NPoint, ss:Cycle \u0026 (CycleCheck(ss) \u003d\u003e (forall s in set ss \u0026 let mk_(p1, p2):(NPoint * NPoint) \u003d SelPoints(s) in ((not (((p.y) \u003c (max - 1)) and ((not On(p1, SP(p))) and On(p2, SP(p))))) \u003d\u003e (((p.y) \u003c (max - 1)) \u003d\u003e ((not On(p2, SP(p))) \u003d\u003e pre_SP(p)))))))","legal function application obligation:(forall p:NPoint, ss:Cycle \u0026 (forall s in set ss \u0026 (((p.y) \u003c (max - 1)) \u003d\u003e pre_SP(p))))","type compatibility obligation:(forall mk_NPoint(x, y):NPoint \u0026 ((y \u003c (max - 1)) \u003d\u003e (inv_N((max - 1)) and is_((max - 1), nat))))","type compatibility obligation:(forall mk_NPoint(x, y):NPoint \u0026 ((y \u003c (max - 1)) \u003d\u003e inv_NSeg(mk_NSeg({mk_NPoint(x, y), mk_NPoint(x, (max - 1))}))))","type compatibility obligation:(forall pred:(NPoint * set of (NSeg) -\u003e bool), ss:Cycle \u0026 (forall x in set {0, ... ,(max - 1)}, y in set {0, ... ,(max - 1)} \u0026 (pred(mk_NPoint(x, y), ss) \u003d\u003e inv_N(x))))","type compatibility obligation:(forall pred:(NPoint * set of (NSeg) -\u003e bool), ss:Cycle \u0026 (forall x in set {0, ... ,(max - 1)}, y in set {0, ... ,(max - 1)} \u0026 (pred(mk_NPoint(x, y), ss) \u003d\u003e inv_N(y))))","legal function application obligation:(forall pred:(NPoint * set of (NSeg) -\u003e bool), ss:Cycle \u0026 (forall x in set {0, ... ,(max - 1)}, y in set {0, ... ,(max - 1)} \u0026 pre_(predmk_NPoint(x, y), ss)))","type compatibility obligation:(forall pred:(NPoint * set of (NSeg) -\u003e bool), ss:Cycle \u0026 (forall x in set {0, ... ,(max - 1)}, y in set {0, ... ,(max - 1)} \u0026 inv_N(x)))","type compatibility obligation:(forall pred:(NPoint * set of (NSeg) -\u003e bool), ss:Cycle \u0026 (forall x in set {0, ... ,(max - 1)}, y in set {0, ... ,(max - 1)} \u0026 inv_N(y)))","type invariant satisfiable obligation:(exists mk_Face(c, hs):Face \u0026 ((forall h in set hs \u0026 EdgeInside(h, c)) and ((forall h1, h2 in set hs \u0026 ((h1 \u003c\u003e h2) \u003d\u003e EdgeDisjoint(h1, h2))) and (forall ss in set (power (c union (dunion hs))) \u0026 (CycleCheck(ss) \u003d\u003e (ss in set (hs union {c})))))))","type compatibility obligation:inv_N(1)","type compatibility obligation:inv_N(1)","type compatibility obligation:inv_N(5)","type compatibility obligation:inv_N(3)","type compatibility obligation:inv_N(1)","type compatibility obligation:inv_N(9)","type compatibility obligation:inv_N(2)","type compatibility obligation:inv_N(3)","type compatibility obligation:inv_N(9)","type compatibility obligation:inv_N(5)","type compatibility obligation:inv_N(6)","type compatibility obligation:inv_N(9)","type compatibility obligation:inv_N(4)","type compatibility obligation:inv_N(5)","type compatibility obligation:inv_N(4)","type compatibility obligation:inv_N(6)","type compatibility obligation:inv_N(1)","type compatibility obligation:inv_N(6)","type compatibility obligation:inv_N(5)","type compatibility obligation:inv_N(0)","type compatibility obligation:inv_N(5)","type compatibility obligation:inv_N(1)","type compatibility obligation:inv_N(6)","type compatibility obligation:inv_N(0)","type compatibility obligation:inv_N(6)","type compatibility obligation:inv_N(1)","type compatibility obligation:inv_NSeg(mk_REALM`NSeg({p1, p2}))","type compatibility obligation:inv_NSeg(mk_REALM`NSeg({p1, p3}))","type compatibility obligation:inv_NSeg(mk_REALM`NSeg({p2, p4}))","type compatibility obligation:inv_NSeg(mk_REALM`NSeg({p4, p3}))","type compatibility obligation:inv_NSeg(mk_REALM`NSeg({p3, p2}))","type compatibility obligation:inv_NSeg(mk_REALM`NSeg({p5, p4}))","type compatibility obligation:inv_NSeg(mk_REALM`NSeg({p6, p1}))","type compatibility obligation:inv_NSeg(mk_REALM`NSeg({p5, p3}))","type compatibility obligation:inv_NSeg(mk_REALM`NSeg({p5, p7}))","type compatibility obligation:inv_NSeg(mk_REALM`NSeg({p9, p3}))","type compatibility obligation:inv_NSeg(mk_REALM`NSeg({p10, p8}))","type compatibility obligation:inv_NSeg(mk_REALM`NSeg({p1, p5}))","type compatibility obligation:inv_NSeg(mk_REALM`NSeg({p10, p13}))","type compatibility obligation:inv_NSeg(mk_REALM`NSeg({p11, p12}))","type compatibility obligation:inv_Realm(mk_REALM`Realm({p1, p2}, {s1}))","type compatibility obligation:inv_Realm(mk_REALM`Realm({p5, p4}, {s6}))","type compatibility obligation:inv_Realm(mk_REALM`Realm({p5, p4, p3}, {s6, s8}))","type compatibility obligation:inv_Realm(mk_REALM`Realm({p1, p3, p4, p5, p6, p7, p8}, {s6, s8}))","type compatibility obligation:inv_Realm(mk_REALM`Realm({p10, p13}, {s13}))"] \ No newline at end of file +["type compatibility obligation:inv_N(1)","type compatibility obligation:inv_N(1)","type compatibility obligation:inv_N(5)","type compatibility obligation:inv_N(3)","type compatibility obligation:inv_N(1)","type compatibility obligation:inv_N(9)","type compatibility obligation:inv_N(2)","type compatibility obligation:inv_N(3)","type compatibility obligation:inv_N(9)","type compatibility obligation:inv_N(5)","type compatibility obligation:inv_N(6)","type compatibility obligation:inv_N(9)","type compatibility obligation:inv_N(4)","type compatibility obligation:inv_N(5)","type compatibility obligation:inv_N(4)","type compatibility obligation:inv_N(6)","type compatibility obligation:inv_N(1)","type compatibility obligation:inv_N(6)","type compatibility obligation:inv_N(5)","type compatibility obligation:inv_N(0)","type compatibility obligation:inv_N(5)","type compatibility obligation:inv_N(1)","type compatibility obligation:inv_N(6)","type compatibility obligation:inv_N(0)","type compatibility obligation:inv_N(6)","type compatibility obligation:inv_N(1)","type compatibility obligation:inv_NSeg(mk_REALM`NSeg({p1, p2}))","type compatibility obligation:inv_NSeg(mk_REALM`NSeg({p1, p3}))","type compatibility obligation:inv_NSeg(mk_REALM`NSeg({p2, p4}))","type compatibility obligation:inv_NSeg(mk_REALM`NSeg({p4, p3}))","type compatibility obligation:inv_NSeg(mk_REALM`NSeg({p3, p2}))","type compatibility obligation:inv_NSeg(mk_REALM`NSeg({p5, p4}))","type compatibility obligation:inv_NSeg(mk_REALM`NSeg({p6, p1}))","type compatibility obligation:inv_NSeg(mk_REALM`NSeg({p5, p3}))","type compatibility obligation:inv_NSeg(mk_REALM`NSeg({p5, p7}))","type compatibility obligation:inv_NSeg(mk_REALM`NSeg({p9, p3}))","type compatibility obligation:inv_NSeg(mk_REALM`NSeg({p10, p8}))","type compatibility obligation:inv_NSeg(mk_REALM`NSeg({p1, p5}))","type compatibility obligation:inv_NSeg(mk_REALM`NSeg({p10, p13}))","type compatibility obligation:inv_NSeg(mk_REALM`NSeg({p11, p12}))","type compatibility obligation:inv_Realm(mk_REALM`Realm({p1, p2}, {s1}))","type compatibility obligation:inv_Realm(mk_REALM`Realm({p5, p4}, {s6}))","type compatibility obligation:inv_Realm(mk_REALM`Realm({p5, p4, p3}, {s6, s8}))","type compatibility obligation:inv_Realm(mk_REALM`Realm({p1, p3, p4, p5, p6, p7, p8}, {s6, s8}))","type compatibility obligation:inv_Realm(mk_REALM`Realm({p10, p13}, {s13}))","type invariant satisfiable obligation:(exists n:N \u0026 (n \u003c max))","type invariant satisfiable obligation:(exists mk_NSeg(ps):NSeg \u0026 ((card ps) \u003d 2))","let be st existence obligation:(forall mk_NSeg(pts):NSeg \u0026 (exists p in set pts \u0026 true))","let be st existence obligation:(forall mk_NSeg(pts):NSeg \u0026 (forall p in set pts \u0026 (exists q in set (pts \\ {p}) \u0026 true)))","non-zero obligation:(forall s:NSeg, t:NSeg \u0026 let mk_(mk_NPoint(x11, y11), mk_NPoint(x12, y12)):(NPoint * NPoint) \u003d SelPoints(s), mk_(mk_NPoint(x21, y21), mk_NPoint(x22, y22)):(NPoint * NPoint) \u003d SelPoints(t) in let a11:int \u003d (x11 - x12), a12:int \u003d (x22 - x21), a21:int \u003d (y11 - y12), a22:int \u003d (y22 - y21), b1:int \u003d (x11 - x21), b2:int \u003d (y11 - y21) in let d1:int \u003d ((b1 * a22) - (b2 * a12)), d2:int \u003d ((b2 * a11) - (b1 * a21)), d:int \u003d ((a11 * a22) - (a12 * a21)) in ((d \u003c\u003e 0) \u003d\u003e (d \u003c\u003e 0)))","non-zero obligation:(forall s:NSeg, t:NSeg \u0026 let mk_(mk_NPoint(x11, y11), mk_NPoint(x12, y12)):(NPoint * NPoint) \u003d SelPoints(s), mk_(mk_NPoint(x21, y21), mk_NPoint(x22, y22)):(NPoint * NPoint) \u003d SelPoints(t) in let a11:int \u003d (x11 - x12), a12:int \u003d (x22 - x21), a21:int \u003d (y11 - y12), a22:int \u003d (y22 - y21), b1:int \u003d (x11 - x21), b2:int \u003d (y11 - y21) in let d1:int \u003d ((b1 * a22) - (b2 * a12)), d2:int \u003d ((b2 * a11) - (b1 * a21)), d:int \u003d ((a11 * a22) - (a12 * a21)) in ((d \u003c\u003e 0) \u003d\u003e (d \u003c\u003e 0)))","type compatibility obligation:(forall s:NSeg, t:NSeg \u0026 (Intersect(s, t) \u003d\u003e let mk_(mk_NPoint(x11, y11), mk_NPoint(x12, y12)):(NPoint * NPoint) \u003d SelPoints(s), mk_(mk_NPoint(x21, y21), mk_NPoint(x22, y22)):(NPoint * NPoint) \u003d SelPoints(t) in let a11:int \u003d (x11 - x12), a12:int \u003d (x22 - x21), a21:int \u003d (y11 - y12), a22:int \u003d (y22 - y21), b1:int \u003d (x11 - x21), b2:int \u003d (y11 - y21) in let d1:int \u003d ((b1 * a22) - (b2 * a12)), d:int \u003d ((a11 * a22) - (a12 * a21)) in ((d \u003c\u003e 0) \u003d\u003e let x0:int \u003d ((x11 * d) + (d1 * (x12 - x11))), y0:int \u003d ((y11 * d) + (d1 * (y12 - y11))) in inv_N(RoundToN((abs x0), (abs d))))))","type compatibility obligation:(forall s:NSeg, t:NSeg \u0026 (Intersect(s, t) \u003d\u003e let mk_(mk_NPoint(x11, y11), mk_NPoint(x12, y12)):(NPoint * NPoint) \u003d SelPoints(s), mk_(mk_NPoint(x21, y21), mk_NPoint(x22, y22)):(NPoint * NPoint) \u003d SelPoints(t) in let a11:int \u003d (x11 - x12), a12:int \u003d (x22 - x21), a21:int \u003d (y11 - y12), a22:int \u003d (y22 - y21), b1:int \u003d (x11 - x21), b2:int \u003d (y11 - y21) in let d1:int \u003d ((b1 * a22) - (b2 * a12)), d:int \u003d ((a11 * a22) - (a12 * a21)) in ((d \u003c\u003e 0) \u003d\u003e let x0:int \u003d ((x11 * d) + (d1 * (x12 - x11))), y0:int \u003d ((y11 * d) + (d1 * (y12 - y11))) in inv_N(RoundToN((abs y0), (abs d))))))","non-zero obligation:(forall a:nat, b:nat \u0026 ((a \u003e\u003d b) \u003d\u003e (b \u003c\u003e 0)))","type compatibility obligation:(forall a:nat, b:nat \u0026 (let mk_(z, aa):((int * int) | (nat * nat)) \u003d (if (a \u003e\u003d b)\nthen mk_((a div b), (a mod b))\nelse mk_(0, a)) in (if ((aa \u003d 0) or ((2 * aa) \u003c\u003d b))\nthen z\nelse (z + 1)) \u003e\u003d 0))","type invariant satisfiable obligation:(exists mk_Realm(ps, ss):Realm \u0026 ((forall mk_NSeg(pts) in set ss \u0026 (pts subset ps)) and ((forall s in set ss, p in set ps \u0026 (not In(p, s))) and (forall s1, s2 in set ss \u0026 ((s1 \u003c\u003e s2) \u003d\u003e ((not Intersect(s1, s2)) and (not Overlap(s1, s2))))))))","type compatibility obligation:(forall mk_Realm(ps, ss):Realm, p:NPoint \u0026 ((not (exists s in set ss \u0026 In(p, s))) \u003d\u003e ((p in set ps) \u003d\u003e inv_Realm(mk_Realm(ps, ss)))))","type compatibility obligation:(forall mk_Realm(ps, ss):Realm, p:NPoint \u0026 ((not (exists s in set ss \u0026 In(p, s))) \u003d\u003e ((not (p in set ps)) \u003d\u003e ((forall s in set ss \u0026 (p not in set E(s))) \u003d\u003e inv_Realm(mk_Realm((ps union {p}), ss))))))","type compatibility obligation:(forall mk_Realm(ps, ss):Realm, p:NPoint \u0026 ((not (exists s in set ss \u0026 In(p, s))) \u003d\u003e ((not (p in set ps)) \u003d\u003e ((not (forall s in set ss \u0026 (p not in set E(s)))) \u003d\u003e let s_env:set of (NSeg) \u003d {s | s in set ss \u0026 (p in set E(s))} in (forall mk_NSeg({p1, p2}) in set s_env \u0026 ((p not in set {p1, p2}) \u003d\u003e inv_NSeg(mk_NSeg({p1, p}))))))))","type compatibility obligation:(forall mk_Realm(ps, ss):Realm, p:NPoint \u0026 ((not (exists s in set ss \u0026 In(p, s))) \u003d\u003e ((not (p in set ps)) \u003d\u003e ((not (forall s in set ss \u0026 (p not in set E(s)))) \u003d\u003e let s_env:set of (NSeg) \u003d {s | s in set ss \u0026 (p in set E(s))} in (forall mk_NSeg({p1, p2}) in set s_env \u0026 ((p not in set {p1, p2}) \u003d\u003e inv_NSeg(mk_NSeg({p, p2}))))))))","type compatibility obligation:(forall mk_Realm(ps, ss):Realm, p:NPoint \u0026 ((not (exists s in set ss \u0026 In(p, s))) \u003d\u003e ((not (p in set ps)) \u003d\u003e ((not (forall s in set ss \u0026 (p not in set E(s)))) \u003d\u003e let s_env:set of (NSeg) \u003d {s | s in set ss \u0026 (p in set E(s))} in let ss1:set of (NSeg) \u003d (dunion {{mk_NSeg({p1, p}), mk_NSeg({p, p2})} | mk_NSeg({p1, p2}) in set s_env \u0026 (p not in set {p1, p2})}) in inv_Realm(mk_Realm((ps union {p}), ((ss union ss1) \\ s_env)))))))","type compatibility obligation:(forall mk_Realm(ps, ss):Realm, s:NSeg \u0026 (((s.pts) subset ps) \u003d\u003e ((s in set ss) \u003d\u003e inv_Realm(mk_Realm(ps, ss)))))","type compatibility obligation:(forall mk_Realm(ps, ss):Realm, s:NSeg \u0026 (((s.pts) subset ps) \u003d\u003e ((not (s in set ss)) \u003d\u003e (((forall p in set ps \u0026 (p not in set (E(s) \\ EndPoints(ss)))) and (forall t in set ss \u0026 ((not Intersect(s, t)) and (not Overlap(s, t))))) \u003d\u003e inv_Realm(mk_Realm(ps, (ss union {s})))))))","legal function application obligation:(forall mk_Realm(ps, ss):Realm, s:NSeg \u0026 (((s.pts) subset ps) \u003d\u003e ((not (s in set ss)) \u003d\u003e ((not ((forall p in set ps \u0026 (p not in set (E(s) \\ EndPoints(ss)))) and (forall t in set ss \u0026 ((not Intersect(s, t)) and (not Overlap(s, t)))))) \u003d\u003e let p_env:set of (NPoint) \u003d ({p | p in set (ps inter E(s))} \\ EndPoints(ss)), s_inter:set of (NSeg) \u003d {t | t in set ss \u0026 Intersect(s, t)} in pre_ChopNPoints(p_env, {s})))))","type compatibility obligation:(forall mk_Realm(ps, ss):Realm, s:NSeg \u0026 (((s.pts) subset ps) \u003d\u003e ((not (s in set ss)) \u003d\u003e ((not ((forall p in set ps \u0026 (p not in set (E(s) \\ EndPoints(ss)))) and (forall t in set ss \u0026 ((not Intersect(s, t)) and (not Overlap(s, t)))))) \u003d\u003e let p_env:set of (NPoint) \u003d ({p | p in set (ps inter E(s))} \\ EndPoints(ss)), s_inter:set of (NSeg) \u003d {t | t in set ss \u0026 Intersect(s, t)} in let ss1:set of (NSeg) \u003d ChopNPoints(p_env, {s}) in let mk_(new_ps, new_ss):(set of (NPoint) * set of (NSeg)) \u003d ChopNSegs(ss, s_inter, ss1, {}) in inv_Realm(mk_Realm((ps union new_ps), new_ss))))))","let be st existence obligation:(forall ps:set of (NPoint), ss:set of (NSeg) \u0026 ((forall p in set ps \u0026 (exists s in set ss \u0026 ((p in set E(s)) and (p not in set (s.pts))))) \u003d\u003e ((not (ps \u003d {})) \u003d\u003e (exists p in set ps \u0026 true))))","let be st existence obligation:(forall ps:set of (NPoint), ss:set of (NSeg) \u0026 ((forall p in set ps \u0026 (exists s in set ss \u0026 ((p in set E(s)) and (p not in set (s.pts))))) \u003d\u003e ((not (ps \u003d {})) \u003d\u003e (forall p in set ps \u0026 let s_env:set of (NSeg) \u003d {s | s in set ss \u0026 ((p in set E(s)) and (p not in set (s.pts)))} in (exists s in set s_env \u0026 true)))))","legal function application obligation:(forall ps:set of (NPoint), ss:set of (NSeg) \u0026 ((forall p in set ps \u0026 (exists s in set ss \u0026 ((p in set E(s)) and (p not in set (s.pts))))) \u003d\u003e ((not (ps \u003d {})) \u003d\u003e (forall p in set ps \u0026 let s_env:set of (NSeg) \u003d {s | s in set ss \u0026 ((p in set E(s)) and (p not in set (s.pts)))} in (forall s in set s_env \u0026 let mk_(p1, p2):(NPoint * NPoint) \u003d SelPoints(s) in pre_ChopNPoints((ps \\ {p}), ((ss \\ {s}) union {mk_NSeg({p1, p}), mk_NSeg({p2, p})})))))))","type compatibility obligation:(forall ps:set of (NPoint), ss:set of (NSeg) \u0026 ((forall p in set ps \u0026 (exists s in set ss \u0026 ((p in set E(s)) and (p not in set (s.pts))))) \u003d\u003e ((not (ps \u003d {})) \u003d\u003e (forall p in set ps \u0026 let s_env:set of (NSeg) \u003d {s | s in set ss \u0026 ((p in set E(s)) and (p not in set (s.pts)))} in (forall s in set s_env \u0026 let mk_(p1, p2):(NPoint * NPoint) \u003d SelPoints(s) in inv_NSeg(mk_NSeg({p1, p})))))))","type compatibility obligation:(forall ps:set of (NPoint), ss:set of (NSeg) \u0026 ((forall p in set ps \u0026 (exists s in set ss \u0026 ((p in set E(s)) and (p not in set (s.pts))))) \u003d\u003e ((not (ps \u003d {})) \u003d\u003e (forall p in set ps \u0026 let s_env:set of (NSeg) \u003d {s | s in set ss \u0026 ((p in set E(s)) and (p not in set (s.pts)))} in (forall s in set s_env \u0026 let mk_(p1, p2):(NPoint * NPoint) \u003d SelPoints(s) in inv_NSeg(mk_NSeg({p2, p})))))))","let be st existence obligation:(forall ss:set of (NSeg), s_inter:set of (NSeg), newss:set of (NSeg), ps:set of (NPoint) \u0026 ((not (s_inter \u003d {})) \u003d\u003e (exists t in set s_inter \u0026 true)))","legal function application obligation:(forall ss:set of (NSeg), s_inter:set of (NSeg), newss:set of (NSeg), ps:set of (NPoint) \u0026 ((not (s_inter \u003d {})) \u003d\u003e (forall t in set s_inter \u0026 let {s}:set of (NSeg) \u003d {s | s in set newss \u0026 Intersect(s, t)} in pre_Intersection(t, s))))","type compatibility obligation:(forall ss:set of (NSeg), s_inter:set of (NSeg), newss:set of (NSeg), ps:set of (NPoint) \u0026 ((not (s_inter \u003d {})) \u003d\u003e (forall t in set s_inter \u0026 let {s}:set of (NSeg) \u003d {s | s in set newss \u0026 Intersect(s, t)} in let p:NPoint \u003d Intersection(t, s) in (forall sp in set (s.pts) \u0026 ((p \u003c\u003e sp) \u003d\u003e inv_NSeg(mk_NSeg({p, sp})))))))","type compatibility obligation:(forall ss:set of (NSeg), s_inter:set of (NSeg), newss:set of (NSeg), ps:set of (NPoint) \u0026 ((not (s_inter \u003d {})) \u003d\u003e (forall t in set s_inter \u0026 let {s}:set of (NSeg) \u003d {s | s in set newss \u0026 Intersect(s, t)} in let p:NPoint \u003d Intersection(t, s) in (forall tp in set (t.pts) \u0026 ((p \u003c\u003e tp) \u003d\u003e inv_NSeg(mk_NSeg({p, tp})))))))","type compatibility obligation:(forall s:NSeg \u0026 let mk_(p1, p2):(NPoint * NPoint) \u003d SelPoints(s) in (forall x in set DiffX(p1, p2), y in set DiffY(p1, p2) \u0026 ((0 \u003c y) \u003d\u003e ((y \u003c (max - 1)) \u003d\u003e (inv_N((y - 1)) and is_((y - 1), nat))))))","type compatibility obligation:(forall s:NSeg \u0026 let mk_(p1, p2):(NPoint * NPoint) \u003d SelPoints(s) in (forall x in set DiffX(p1, p2), y in set DiffY(p1, p2) \u0026 ((0 \u003c y) \u003d\u003e ((y \u003c (max - 1)) \u003d\u003e inv_N((y + 1))))))","type compatibility obligation:(forall s:NSeg \u0026 let mk_(p1, p2):(NPoint * NPoint) \u003d SelPoints(s) in (forall x in set DiffX(p1, p2), y in set DiffY(p1, p2) \u0026 ((0 \u003c y) \u003d\u003e ((y \u003c (max - 1)) \u003d\u003e inv_NSeg(mk_NSeg({mk_NPoint(x, (y - 1)), mk_NPoint(x, (y + 1))}))))))","type compatibility obligation:(forall s:NSeg \u0026 let mk_(p1, p2):(NPoint * NPoint) \u003d SelPoints(s) in (forall x in set DiffX(p1, p2), y in set DiffY(p1, p2) \u0026 ((not ((0 \u003c y) and ((y \u003c (max - 1)) and Intersect(mk_NSeg({mk_NPoint(x, (y - 1)), mk_NPoint(x, (y + 1))}), s)))) \u003d\u003e ((0 \u003c x) \u003d\u003e ((x \u003c (max - 1)) \u003d\u003e (inv_N((x - 1)) and is_((x - 1), nat)))))))","type compatibility obligation:(forall s:NSeg \u0026 let mk_(p1, p2):(NPoint * NPoint) \u003d SelPoints(s) in (forall x in set DiffX(p1, p2), y in set DiffY(p1, p2) \u0026 ((not ((0 \u003c y) and ((y \u003c (max - 1)) and Intersect(mk_NSeg({mk_NPoint(x, (y - 1)), mk_NPoint(x, (y + 1))}), s)))) \u003d\u003e ((0 \u003c x) \u003d\u003e ((x \u003c (max - 1)) \u003d\u003e inv_N((x + 1)))))))","type compatibility obligation:(forall s:NSeg \u0026 let mk_(p1, p2):(NPoint * NPoint) \u003d SelPoints(s) in (forall x in set DiffX(p1, p2), y in set DiffY(p1, p2) \u0026 ((not ((0 \u003c y) and ((y \u003c (max - 1)) and Intersect(mk_NSeg({mk_NPoint(x, (y - 1)), mk_NPoint(x, (y + 1))}), s)))) \u003d\u003e ((0 \u003c x) \u003d\u003e ((x \u003c (max - 1)) \u003d\u003e inv_NSeg(mk_NSeg({mk_NPoint((x - 1), y), mk_NPoint((x + 1), y)})))))))","legal sequence application obligation:(forall ss:set of (NSeg) \u0026 (forall sl in set AllLists(ss) \u0026 (forall i in set (inds sl) \u0026 (i in set (inds sl)))))","legal sequence application obligation:(forall ss:set of (NSeg) \u0026 (forall sl in set AllLists(ss) \u0026 (forall i in set (inds sl) \u0026 ((if (i \u003d (len sl))\nthen 1\nelse (i + 1)) in set (inds sl)))))","legal sequence application obligation:(forall ss:set of (NSeg) \u0026 (forall sl in set AllLists(ss) \u0026 (forall i in set (inds sl) \u0026 (Meet(sl(i), sl((if (i \u003d (len sl))\nthen 1\nelse (i + 1)))) \u003d\u003e (forall j in set ((inds sl) \\ {(if (i \u003d 1)\nthen (len sl)\nelse (i - 1)), i, (if (i \u003d (len sl))\nthen 1\nelse (i + 1))}) \u0026 (i in set (inds sl)))))))","legal sequence application obligation:(forall ss:set of (NSeg) \u0026 (forall sl in set AllLists(ss) \u0026 (forall i in set (inds sl) \u0026 (Meet(sl(i), sl((if (i \u003d (len sl))\nthen 1\nelse (i + 1)))) \u003d\u003e (forall j in set ((inds sl) \\ {(if (i \u003d 1)\nthen (len sl)\nelse (i - 1)), i, (if (i \u003d (len sl))\nthen 1\nelse (i + 1))}) \u0026 (j in set (inds sl)))))))","type invariant satisfiable obligation:(exists ss:Cycle \u0026 CycleCheck(ss))","legal function application obligation:(forall p:NPoint, c:Cycle \u0026 ((not OnCycle(p, c)) \u003d\u003e pre_SR(p, c)))","legal function application obligation:(forall p:NPoint, ss:Cycle \u0026 (CycleCheck(ss) \u003d\u003e (forall s in set ss \u0026 let mk_(p1, p2):(NPoint * NPoint) \u003d SelPoints(s) in (((p.y) \u003c (max - 1)) \u003d\u003e pre_SP(p)))))","legal function application obligation:(forall p:NPoint, ss:Cycle \u0026 (CycleCheck(ss) \u003d\u003e (forall s in set ss \u0026 let mk_(p1, p2):(NPoint * NPoint) \u003d SelPoints(s) in (((p.y) \u003c (max - 1)) \u003d\u003e ((not On(p1, SP(p))) \u003d\u003e pre_SP(p))))))","legal function application obligation:(forall p:NPoint, ss:Cycle \u0026 (CycleCheck(ss) \u003d\u003e (forall s in set ss \u0026 let mk_(p1, p2):(NPoint * NPoint) \u003d SelPoints(s) in ((not (((p.y) \u003c (max - 1)) and ((not On(p1, SP(p))) and On(p2, SP(p))))) \u003d\u003e (((p.y) \u003c (max - 1)) \u003d\u003e pre_SP(p))))))","legal function application obligation:(forall p:NPoint, ss:Cycle \u0026 (CycleCheck(ss) \u003d\u003e (forall s in set ss \u0026 let mk_(p1, p2):(NPoint * NPoint) \u003d SelPoints(s) in ((not (((p.y) \u003c (max - 1)) and ((not On(p1, SP(p))) and On(p2, SP(p))))) \u003d\u003e (((p.y) \u003c (max - 1)) \u003d\u003e ((not On(p2, SP(p))) \u003d\u003e pre_SP(p)))))))","legal function application obligation:(forall p:NPoint, ss:Cycle \u0026 (forall s in set ss \u0026 (((p.y) \u003c (max - 1)) \u003d\u003e pre_SP(p))))","type compatibility obligation:(forall mk_NPoint(x, y):NPoint \u0026 ((y \u003c (max - 1)) \u003d\u003e (inv_N((max - 1)) and is_((max - 1), nat))))","type compatibility obligation:(forall mk_NPoint(x, y):NPoint \u0026 ((y \u003c (max - 1)) \u003d\u003e inv_NSeg(mk_NSeg({mk_NPoint(x, y), mk_NPoint(x, (max - 1))}))))","type compatibility obligation:(forall pred:(NPoint * set of (NSeg) -\u003e bool), ss:Cycle \u0026 (forall x in set {0, ... ,(max - 1)}, y in set {0, ... ,(max - 1)} \u0026 (pred(mk_NPoint(x, y), ss) \u003d\u003e inv_N(x))))","type compatibility obligation:(forall pred:(NPoint * set of (NSeg) -\u003e bool), ss:Cycle \u0026 (forall x in set {0, ... ,(max - 1)}, y in set {0, ... ,(max - 1)} \u0026 (pred(mk_NPoint(x, y), ss) \u003d\u003e inv_N(y))))","legal function application obligation:(forall pred:(NPoint * set of (NSeg) -\u003e bool), ss:Cycle \u0026 (forall x in set {0, ... ,(max - 1)}, y in set {0, ... ,(max - 1)} \u0026 pre_(predmk_NPoint(x, y), ss)))","type compatibility obligation:(forall pred:(NPoint * set of (NSeg) -\u003e bool), ss:Cycle \u0026 (forall x in set {0, ... ,(max - 1)}, y in set {0, ... ,(max - 1)} \u0026 inv_N(x)))","type compatibility obligation:(forall pred:(NPoint * set of (NSeg) -\u003e bool), ss:Cycle \u0026 (forall x in set {0, ... ,(max - 1)}, y in set {0, ... ,(max - 1)} \u0026 inv_N(y)))","type invariant satisfiable obligation:(exists mk_Face(c, hs):Face \u0026 ((forall h in set hs \u0026 EdgeInside(h, c)) and ((forall h1, h2 in set hs \u0026 ((h1 \u003c\u003e h2) \u003d\u003e EdgeDisjoint(h1, h2))) and (forall ss in set (power (c union (dunion hs))) \u0026 (CycleCheck(ss) \u003d\u003e (ss in set (hs union {c})))))))"] \ No newline at end of file diff --git a/core/pog/src/test/resources/examples/shmemSL.result b/core/pog/src/test/resources/examples/shmemSL.result index cb92ccb379..7bca5e0b8e 100644 --- a/core/pog/src/test/resources/examples/shmemSL.result +++ b/core/pog/src/test/resources/examples/shmemSL.result @@ -1 +1 @@ -["type invariant satisfiable obligation:(exists mk_M(-, a, b):M \u0026 (b \u003e\u003d a))","type compatibility obligation:(forall m:M \u0026 ((((m.stop) - (m.start)) + 1) \u003e 0))","recursive function obligation:(forall size:nat1, Q:Quadrant \u0026 ((not ([] \u003d Q)) \u003d\u003e (exists [h] ^ tail:Quadrant \u0026 ((([h] ^ tail) \u003d Q) \u003d\u003e let [h] ^ tail \u003d Q in ((not (((h.type) \u003d \u003cFREE\u003e) and (sizeof(h) \u003e\u003d size))) \u003d\u003e (QuadrantLen(size, Q) \u003e QuadrantLen(size, tail)))))))","cases exhaustive obligation:(forall size:nat1, Q:Quadrant \u0026 ((Q \u003d []) or (exists [h] ^ tail:Quadrant \u0026 (Q \u003d ([h] ^ tail)))))","recursive function obligation:(forall size:nat1, Q:Quadrant \u0026 ((not ([] \u003d Q)) \u003d\u003e (exists [h] ^ tail:Quadrant \u0026 ((([h] ^ tail) \u003d Q) \u003d\u003e let [h] ^ tail \u003d Q in ((((h.type) \u003d \u003cFREE\u003e) and (sizeof(h) \u003e\u003d size)) \u003d\u003e (QuadrantLen(size, Q) \u003e QuadrantLen(size, tail)))))))","recursive function obligation:(forall size:nat1, Q:Quadrant \u0026 ((not ([] \u003d Q)) \u003d\u003e (exists [h] ^ tail:Quadrant \u0026 ((([h] ^ tail) \u003d Q) \u003d\u003e let [h] ^ tail \u003d Q in ((not (((h.type) \u003d \u003cFREE\u003e) and (sizeof(h) \u003e\u003d size))) \u003d\u003e (QuadrantLen(size, Q) \u003e QuadrantLen(size, tail)))))))","cases exhaustive obligation:(forall size:nat1, Q:Quadrant \u0026 ((Q \u003d []) or (exists [h] ^ tail:Quadrant \u0026 (Q \u003d ([h] ^ tail)))))","type compatibility obligation:(forall size:nat1, hole:nat1, Q:Quadrant \u0026 ((hole \u003e\u003d size) \u003d\u003e (exists [h] ^ tail:Quadrant \u0026 ((([h] ^ tail) \u003d Q) \u003d\u003e let [h] ^ tail \u003d Q in ((((h.type) \u003d \u003cFREE\u003e) and (sizeof(h) \u003d hole)) \u003d\u003e ((hole \u003d size) \u003d\u003e inv_M(mk_M(\u003cUSED\u003e, (h.start), (h.stop)))))))))","type compatibility obligation:(forall size:nat1, hole:nat1, Q:Quadrant \u0026 ((hole \u003e\u003d size) \u003d\u003e (exists [h] ^ tail:Quadrant \u0026 ((([h] ^ tail) \u003d Q) \u003d\u003e let [h] ^ tail \u003d Q in ((((h.type) \u003d \u003cFREE\u003e) and (sizeof(h) \u003d hole)) \u003d\u003e ((not (hole \u003d size)) \u003d\u003e ((((h.start) + size) - 1) \u003e\u003d 0)))))))","type compatibility obligation:(forall size:nat1, hole:nat1, Q:Quadrant \u0026 ((hole \u003e\u003d size) \u003d\u003e (exists [h] ^ tail:Quadrant \u0026 ((([h] ^ tail) \u003d Q) \u003d\u003e let [h] ^ tail \u003d Q in ((((h.type) \u003d \u003cFREE\u003e) and (sizeof(h) \u003d hole)) \u003d\u003e ((not (hole \u003d size)) \u003d\u003e (inv_M(mk_M(\u003cUSED\u003e, (h.start), (((h.start) + size) - 1))) and ((((h.start) + size) - 1) \u003e\u003d 0))))))))","type compatibility obligation:(forall size:nat1, hole:nat1, Q:Quadrant \u0026 ((hole \u003e\u003d size) \u003d\u003e (exists [h] ^ tail:Quadrant \u0026 ((([h] ^ tail) \u003d Q) \u003d\u003e let [h] ^ tail \u003d Q in ((((h.type) \u003d \u003cFREE\u003e) and (sizeof(h) \u003d hole)) \u003d\u003e ((not (hole \u003d size)) \u003d\u003e inv_M(mk_M(\u003cFREE\u003e, ((h.start) + size), (h.stop)))))))))","legal function application obligation:(forall size:nat1, hole:nat1, Q:Quadrant \u0026 ((hole \u003e\u003d size) \u003d\u003e (exists [h] ^ tail:Quadrant \u0026 ((([h] ^ tail) \u003d Q) \u003d\u003e let [h] ^ tail \u003d Q in ((not (((h.type) \u003d \u003cFREE\u003e) and (sizeof(h) \u003d hole))) \u003d\u003e pre_add(size, hole, tail))))))","recursive function obligation:(forall size:nat1, hole:nat1, Q:Quadrant \u0026 ((hole \u003e\u003d size) \u003d\u003e (exists [h] ^ tail:Quadrant \u0026 ((([h] ^ tail) \u003d Q) \u003d\u003e let [h] ^ tail \u003d Q in ((not (((h.type) \u003d \u003cFREE\u003e) and (sizeof(h) \u003d hole))) \u003d\u003e (QuadrantLen2(size, hole, Q) \u003e QuadrantLen2(size, hole, tail)))))))","recursive function obligation:(forall Q:Quadrant \u0026 (exists [h1, h2] ^ tail:Quadrant \u0026 ((([h1, h2] ^ tail) \u003d Q) \u003d\u003e let [h1, h2] ^ tail \u003d Q in ((((h1.type) \u003d \u003cFREE\u003e) and ((h2.type) \u003d \u003cFREE\u003e)) \u003d\u003e (QuadrantLen0(Q) \u003e QuadrantLen0(([mk_M(\u003cFREE\u003e, (h1.start), (h2.stop))] ^ tail)))))))","type compatibility obligation:(forall Q:Quadrant \u0026 (exists [h1, h2] ^ tail:Quadrant \u0026 ((([h1, h2] ^ tail) \u003d Q) \u003d\u003e let [h1, h2] ^ tail \u003d Q in ((((h1.type) \u003d \u003cFREE\u003e) and ((h2.type) \u003d \u003cFREE\u003e)) \u003d\u003e inv_M(mk_M(\u003cFREE\u003e, (h1.start), (h2.stop)))))))","recursive function obligation:(forall Q:Quadrant \u0026 (exists [h1, h2] ^ tail:Quadrant \u0026 ((([h1, h2] ^ tail) \u003d Q) \u003d\u003e let [h1, h2] ^ tail \u003d Q in ((not (((h1.type) \u003d \u003cFREE\u003e) and ((h2.type) \u003d \u003cFREE\u003e))) \u003d\u003e (QuadrantLen0(Q) \u003e QuadrantLen0((tl Q)))))))","non-empty sequence obligation:(forall Q:Quadrant \u0026 (exists [h1, h2] ^ tail:Quadrant \u0026 ((([h1, h2] ^ tail) \u003d Q) \u003d\u003e let [h1, h2] ^ tail \u003d Q in ((not (((h1.type) \u003d \u003cFREE\u003e) and ((h2.type) \u003d \u003cFREE\u003e))) \u003d\u003e (Q \u003c\u003e [])))))","non-empty sequence obligation:(forall item:M, Q:Quadrant \u0026 (Q \u003c\u003e []))","type compatibility obligation:(forall item:M, Q:Quadrant \u0026 (((hd Q) \u003d item) \u003d\u003e inv_M(mk_M(\u003cFREE\u003e, (item.start), (item.stop)))))","non-empty sequence obligation:(forall item:M, Q:Quadrant \u0026 (((hd Q) \u003d item) \u003d\u003e (Q \u003c\u003e [])))","non-empty sequence obligation:(forall item:M, Q:Quadrant \u0026 ((not ((hd Q) \u003d item)) \u003d\u003e (Q \u003c\u003e [])))","recursive function obligation:(forall item:M, Q:Quadrant \u0026 ((not ((hd Q) \u003d item)) \u003d\u003e (MQuadrantLen(item, Q) \u003e MQuadrantLen(item, (tl Q)))))","non-empty sequence obligation:(forall item:M, Q:Quadrant \u0026 ((not ((hd Q) \u003d item)) \u003d\u003e (Q \u003c\u003e [])))","type compatibility obligation:(forall Q:Quadrant \u0026 (((card {x | x in set (elems Q) \u0026 ((x.type) \u003d \u003cFREE\u003e)}) - 1) \u003e\u003d 0))","state invariant holds obligation:(forall n:nat1, oldstate:Memory \u0026 let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0)))","state invariant holds obligation:let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0))","type compatibility obligation:((((rseed * 69069) + 5) mod 4294967296) \u003e\u003d 0)","type compatibility obligation:(forall n:nat1, oldstate:Memory \u0026 (true \u003d\u003e (RESULT \u003e 0)))","state invariant holds obligation:(forall size:nat1, oldstate:Memory \u0026 let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0)))","legal function application obligation:(forall size:nat1, oldstate:Memory \u0026 pre_add(size, q4, Q4))","state invariant holds obligation:(forall size:nat1, oldstate:Memory \u0026 let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0)))","legal function application obligation:(forall size:nat1, oldstate:Memory \u0026 pre_add(size, q3, Q3))","state invariant holds obligation:(forall size:nat1, oldstate:Memory \u0026 let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0)))","legal function application obligation:(forall size:nat1, oldstate:Memory \u0026 pre_add(size, q4, Q4))","state invariant holds obligation:(forall size:nat1, oldstate:Memory \u0026 let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0)))","legal function application obligation:(forall size:nat1, oldstate:Memory \u0026 pre_add(size, q3, Q3))","state invariant holds obligation:let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0))","type compatibility obligation:((MAXMEM - 1) \u003e\u003d 0)","type compatibility obligation:(inv_M(mk_M(\u003cFREE\u003e, 0, (MAXMEM - 1))) and ((MAXMEM - 1) \u003e\u003d 0))","state invariant holds obligation:let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0))","type compatibility obligation:((MAXMEM - 1) \u003e\u003d 0)","type compatibility obligation:(inv_M(mk_M(\u003cFREE\u003e, 0, (MAXMEM - 1))) and ((MAXMEM - 1) \u003e\u003d 0))","legal sequence application obligation:(((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e))) \u003d\u003e (i in set (inds Q3)))","state invariant holds obligation:(((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e))) \u003d\u003e let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0)))","legal sequence application obligation:(((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e))) \u003d\u003e (i in set (inds Q3)))","operation call obligation:(((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e))) \u003d\u003e ((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e))))","legal sequence application obligation:(((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e))) \u003d\u003e (true \u003d\u003e (i in set (inds Q4))))","state invariant holds obligation:(((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e))) \u003d\u003e (true \u003d\u003e let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0))))","legal sequence application obligation:(((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e))) \u003d\u003e (true \u003d\u003e (i in set (inds Q4))))","operation call obligation:(((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e))) \u003d\u003e (true \u003d\u003e ((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e)))))","while loop termination obligation:NotYetImplemented","operation call obligation:(forall loops:nat, oldstate:Memory \u0026 ((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e))))","state invariant holds obligation:(forall loops:nat, oldstate:Memory \u0026 (true \u003d\u003e let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0))))","while loop termination obligation:NotYetImplemented","operation call obligation:(forall loops:nat, oldstate:Memory \u0026 ((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e))))","state invariant holds obligation:(forall loops:nat, oldstate:Memory \u0026 (true \u003d\u003e let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0))))","state invariant holds obligation:(forall tries:nat1, loops:nat1, oldstate:Memory \u0026 (true \u003d\u003e (true \u003d\u003e let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0)))))","state invariant holds obligation:(forall tries:nat1, loops:nat1, oldstate:Memory \u0026 (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0)))))))","state invariant holds obligation:(forall tries:nat1, loops:nat1, oldstate:Memory \u0026 (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0)))))))","state invariant holds obligation:(forall tries:nat1, loops:nat1, oldstate:Memory \u0026 (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0)))))))","state invariant holds obligation:(forall tries:nat1, loops:nat1, oldstate:Memory \u0026 (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0)))))))"] \ No newline at end of file +["type invariant satisfiable obligation:(exists mk_M(-, a, b):M \u0026 (b \u003e\u003d a))","type compatibility obligation:(forall m:M \u0026 ((((m.stop) - (m.start)) + 1) \u003e 0))","recursive function obligation:(forall size:nat1, Q:Quadrant \u0026 ((not ([] \u003d Q)) \u003d\u003e (exists [h] ^ tail:Quadrant \u0026 ((([h] ^ tail) \u003d Q) \u003d\u003e let [h] ^ tail \u003d Q in ((not (((h.type) \u003d \u003cFREE\u003e) and (sizeof(h) \u003e\u003d size))) \u003d\u003e (QuadrantLen(size, Q) \u003e QuadrantLen(size, tail)))))))","cases exhaustive obligation:(forall size:nat1, Q:Quadrant \u0026 ((Q \u003d []) or (exists [h] ^ tail:Quadrant \u0026 (Q \u003d ([h] ^ tail)))))","recursive function obligation:(forall size:nat1, Q:Quadrant \u0026 ((not ([] \u003d Q)) \u003d\u003e (exists [h] ^ tail:Quadrant \u0026 ((([h] ^ tail) \u003d Q) \u003d\u003e let [h] ^ tail \u003d Q in ((((h.type) \u003d \u003cFREE\u003e) and (sizeof(h) \u003e\u003d size)) \u003d\u003e (QuadrantLen(size, Q) \u003e QuadrantLen(size, tail)))))))","recursive function obligation:(forall size:nat1, Q:Quadrant \u0026 ((not ([] \u003d Q)) \u003d\u003e (exists [h] ^ tail:Quadrant \u0026 ((([h] ^ tail) \u003d Q) \u003d\u003e let [h] ^ tail \u003d Q in ((not (((h.type) \u003d \u003cFREE\u003e) and (sizeof(h) \u003e\u003d size))) \u003d\u003e (QuadrantLen(size, Q) \u003e QuadrantLen(size, tail)))))))","cases exhaustive obligation:(forall size:nat1, Q:Quadrant \u0026 ((Q \u003d []) or (exists [h] ^ tail:Quadrant \u0026 (Q \u003d ([h] ^ tail)))))","type compatibility obligation:(forall size:nat1, hole:nat1, Q:Quadrant \u0026 ((hole \u003e\u003d size) \u003d\u003e (exists [h] ^ tail:Quadrant \u0026 ((([h] ^ tail) \u003d Q) \u003d\u003e let [h] ^ tail \u003d Q in ((((h.type) \u003d \u003cFREE\u003e) and (sizeof(h) \u003d hole)) \u003d\u003e ((hole \u003d size) \u003d\u003e inv_M(mk_M(\u003cUSED\u003e, (h.start), (h.stop)))))))))","type compatibility obligation:(forall size:nat1, hole:nat1, Q:Quadrant \u0026 ((hole \u003e\u003d size) \u003d\u003e (exists [h] ^ tail:Quadrant \u0026 ((([h] ^ tail) \u003d Q) \u003d\u003e let [h] ^ tail \u003d Q in ((((h.type) \u003d \u003cFREE\u003e) and (sizeof(h) \u003d hole)) \u003d\u003e ((not (hole \u003d size)) \u003d\u003e ((((h.start) + size) - 1) \u003e\u003d 0)))))))","type compatibility obligation:(forall size:nat1, hole:nat1, Q:Quadrant \u0026 ((hole \u003e\u003d size) \u003d\u003e (exists [h] ^ tail:Quadrant \u0026 ((([h] ^ tail) \u003d Q) \u003d\u003e let [h] ^ tail \u003d Q in ((((h.type) \u003d \u003cFREE\u003e) and (sizeof(h) \u003d hole)) \u003d\u003e ((not (hole \u003d size)) \u003d\u003e (inv_M(mk_M(\u003cUSED\u003e, (h.start), (((h.start) + size) - 1))) and ((((h.start) + size) - 1) \u003e\u003d 0))))))))","type compatibility obligation:(forall size:nat1, hole:nat1, Q:Quadrant \u0026 ((hole \u003e\u003d size) \u003d\u003e (exists [h] ^ tail:Quadrant \u0026 ((([h] ^ tail) \u003d Q) \u003d\u003e let [h] ^ tail \u003d Q in ((((h.type) \u003d \u003cFREE\u003e) and (sizeof(h) \u003d hole)) \u003d\u003e ((not (hole \u003d size)) \u003d\u003e inv_M(mk_M(\u003cFREE\u003e, ((h.start) + size), (h.stop)))))))))","legal function application obligation:(forall size:nat1, hole:nat1, Q:Quadrant \u0026 ((hole \u003e\u003d size) \u003d\u003e (exists [h] ^ tail:Quadrant \u0026 ((([h] ^ tail) \u003d Q) \u003d\u003e let [h] ^ tail \u003d Q in ((not (((h.type) \u003d \u003cFREE\u003e) and (sizeof(h) \u003d hole))) \u003d\u003e pre_add(size, hole, tail))))))","recursive function obligation:(forall size:nat1, hole:nat1, Q:Quadrant \u0026 ((hole \u003e\u003d size) \u003d\u003e (exists [h] ^ tail:Quadrant \u0026 ((([h] ^ tail) \u003d Q) \u003d\u003e let [h] ^ tail \u003d Q in ((not (((h.type) \u003d \u003cFREE\u003e) and (sizeof(h) \u003d hole))) \u003d\u003e (QuadrantLen2(size, hole, Q) \u003e QuadrantLen2(size, hole, tail)))))))","recursive function obligation:(forall Q:Quadrant \u0026 (exists [h1, h2] ^ tail:Quadrant \u0026 ((([h1, h2] ^ tail) \u003d Q) \u003d\u003e let [h1, h2] ^ tail \u003d Q in ((((h1.type) \u003d \u003cFREE\u003e) and ((h2.type) \u003d \u003cFREE\u003e)) \u003d\u003e (QuadrantLen0(Q) \u003e QuadrantLen0(([mk_M(\u003cFREE\u003e, (h1.start), (h2.stop))] ^ tail)))))))","type compatibility obligation:(forall Q:Quadrant \u0026 (exists [h1, h2] ^ tail:Quadrant \u0026 ((([h1, h2] ^ tail) \u003d Q) \u003d\u003e let [h1, h2] ^ tail \u003d Q in ((((h1.type) \u003d \u003cFREE\u003e) and ((h2.type) \u003d \u003cFREE\u003e)) \u003d\u003e inv_M(mk_M(\u003cFREE\u003e, (h1.start), (h2.stop)))))))","recursive function obligation:(forall Q:Quadrant \u0026 (exists [h1, h2] ^ tail:Quadrant \u0026 ((([h1, h2] ^ tail) \u003d Q) \u003d\u003e let [h1, h2] ^ tail \u003d Q in ((not (((h1.type) \u003d \u003cFREE\u003e) and ((h2.type) \u003d \u003cFREE\u003e))) \u003d\u003e (QuadrantLen0(Q) \u003e QuadrantLen0((tl Q)))))))","non-empty sequence obligation:(forall Q:Quadrant \u0026 (exists [h1, h2] ^ tail:Quadrant \u0026 ((([h1, h2] ^ tail) \u003d Q) \u003d\u003e let [h1, h2] ^ tail \u003d Q in ((not (((h1.type) \u003d \u003cFREE\u003e) and ((h2.type) \u003d \u003cFREE\u003e))) \u003d\u003e (Q \u003c\u003e [])))))","non-empty sequence obligation:(forall item:M, Q:Quadrant \u0026 (Q \u003c\u003e []))","type compatibility obligation:(forall item:M, Q:Quadrant \u0026 (((hd Q) \u003d item) \u003d\u003e inv_M(mk_M(\u003cFREE\u003e, (item.start), (item.stop)))))","non-empty sequence obligation:(forall item:M, Q:Quadrant \u0026 (((hd Q) \u003d item) \u003d\u003e (Q \u003c\u003e [])))","non-empty sequence obligation:(forall item:M, Q:Quadrant \u0026 ((not ((hd Q) \u003d item)) \u003d\u003e (Q \u003c\u003e [])))","recursive function obligation:(forall item:M, Q:Quadrant \u0026 ((not ((hd Q) \u003d item)) \u003d\u003e (MQuadrantLen(item, Q) \u003e MQuadrantLen(item, (tl Q)))))","non-empty sequence obligation:(forall item:M, Q:Quadrant \u0026 ((not ((hd Q) \u003d item)) \u003d\u003e (Q \u003c\u003e [])))","type compatibility obligation:(forall Q:Quadrant \u0026 (((card {x | x in set (elems Q) \u0026 ((x.type) \u003d \u003cFREE\u003e)}) - 1) \u003e\u003d 0))","state invariant holds obligation:(forall n:nat1, oldstate:Memory \u0026 let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0)))","state invariant holds obligation:let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0))","type compatibility obligation:((((rseed * 69069) + 5) mod 4294967296) \u003e\u003d 0)","type compatibility obligation:(forall n:nat1, oldstate:Memory \u0026 (true \u003d\u003e (RESULT \u003e 0)))","state invariant holds obligation:(forall size:nat1, oldstate:Memory \u0026 let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0)))","legal function application obligation:(forall size:nat1, oldstate:Memory \u0026 pre_add(size, q4, Q4))","state invariant holds obligation:(forall size:nat1, oldstate:Memory \u0026 let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0)))","legal function application obligation:(forall size:nat1, oldstate:Memory \u0026 pre_add(size, q3, Q3))","state invariant holds obligation:(forall size:nat1, oldstate:Memory \u0026 let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0)))","legal function application obligation:(forall size:nat1, oldstate:Memory \u0026 pre_add(size, q4, Q4))","state invariant holds obligation:(forall size:nat1, oldstate:Memory \u0026 let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0)))","legal function application obligation:(forall size:nat1, oldstate:Memory \u0026 pre_add(size, q3, Q3))","state invariant holds obligation:let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0))","type compatibility obligation:((MAXMEM - 1) \u003e\u003d 0)","type compatibility obligation:(inv_M(mk_M(\u003cFREE\u003e, 0, (MAXMEM - 1))) and ((MAXMEM - 1) \u003e\u003d 0))","state invariant holds obligation:let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0))","type compatibility obligation:((MAXMEM - 1) \u003e\u003d 0)","type compatibility obligation:(inv_M(mk_M(\u003cFREE\u003e, 0, (MAXMEM - 1))) and ((MAXMEM - 1) \u003e\u003d 0))","legal sequence application obligation:(((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e))) \u003d\u003e (i in set (inds Q3)))","state invariant holds obligation:(((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e))) \u003d\u003e let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0)))","legal sequence application obligation:(((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e))) \u003d\u003e (i in set (inds Q3)))","operation call obligation:(((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e))) \u003d\u003e ((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e))))","legal sequence application obligation:(((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e))) \u003d\u003e (true \u003d\u003e (i in set (inds Q4))))","state invariant holds obligation:(((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e))) \u003d\u003e (true \u003d\u003e let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0))))","legal sequence application obligation:(((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e))) \u003d\u003e (true \u003d\u003e (i in set (inds Q4))))","operation call obligation:(((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e))) \u003d\u003e (true \u003d\u003e ((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e)))))","while loop termination obligation:...","operation call obligation:(forall loops:nat, oldstate:Memory \u0026 ((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e))))","state invariant holds obligation:(forall loops:nat, oldstate:Memory \u0026 (true \u003d\u003e let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0))))","while loop termination obligation:...","operation call obligation:(forall loops:nat, oldstate:Memory \u0026 ((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e))))","state invariant holds obligation:(forall loops:nat, oldstate:Memory \u0026 (true \u003d\u003e let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0))))","state invariant holds obligation:(forall tries:nat1, loops:nat1, oldstate:Memory \u0026 (true \u003d\u003e (true \u003d\u003e let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0)))))","state invariant holds obligation:(forall tries:nat1, loops:nat1, oldstate:Memory \u0026 (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0)))))))","state invariant holds obligation:(forall tries:nat1, loops:nat1, oldstate:Memory \u0026 (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0)))))))","state invariant holds obligation:(forall tries:nat1, loops:nat1, oldstate:Memory \u0026 (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0)))))))","state invariant holds obligation:(forall tries:nat1, loops:nat1, oldstate:Memory \u0026 (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0)))))))"] \ No newline at end of file diff --git a/core/pog/src/test/resources/examples/simulatorSL.result b/core/pog/src/test/resources/examples/simulatorSL.result index 7a97706d88..ac28fd699f 100644 --- a/core/pog/src/test/resources/examples/simulatorSL.result +++ b/core/pog/src/test/resources/examples/simulatorSL.result @@ -1 +1 @@ -["type invariant satisfiable obligation:(exists mk_PortType(label, cardinality, portlist):PortType \u0026 (cardinality \u003d (card (elems portlist))))","type invariant satisfiable obligation:(exists mk_Event(label, type, porttype):Event \u0026 (((type \u003d \u003cINTERNAL\u003e) and ((porttype.label) \u003d \"NULLPORT\")) or (((type \u003d \u003cINPUT\u003e) and ((porttype.label) \u003c\u003e \"NULLPORT\")) or ((type \u003d \u003cOUTPUT\u003e) and ((porttype.label) \u003c\u003e \"NULLPORT\")))))","type invariant satisfiable obligation:(exists mk_State(label, type, isinitial, substates):State \u0026 let exists_entry_state: (set of (State) +\u003e bool)\n\texists_entry_state(substates) \u003d\u003d\n((exists1 s in set substates \u0026 ((s.isinitial) \u003d true)) and (forall s in set substates \u0026 ((((s.type) \u003d \u003cSIMPLE\u003e) and ((s.substates) \u003d {})) or (((s.type) \u003d \u003cCOMPLEX\u003e) and exists_entry_state((s.substates)))))) in (((type \u003d \u003cSIMPLE\u003e) and (substates \u003d {})) or ((type \u003d \u003cCOMPLEX\u003e) and exists_entry_state(substates))))","type invariant satisfiable obligation:(exists mk_TimeConstraint(label, transition, cevent, tbounds, dstates, rwindows):TimeConstraint \u0026 ((((cevent.type) \u003d \u003cINTERNAL\u003e) or ((cevent.type) \u003d \u003cOUTPUT\u003e)) and (forall rw in set rwindows \u0026 (((rw.uppertimebound) - (rw.lowertimebound)) \u003d ((tbounds.uppertimebound) - (tbounds.lowertimebound))))))","type invariant satisfiable obligation:(exists mk_ReactionWindow(lowertimebound, uppertimebound):ReactionWindow \u0026 (lowertimebound \u003c\u003d uppertimebound))","type invariant satisfiable obligation:(exists mk_PortLink(tromporttuple1, tromporttuple2):PortLink \u0026 ((tromporttuple1.tromlabel) \u003c\u003e (tromporttuple2.tromlabel)))","legal function application obligation:(forall mk_Trom(label, tromclass, porttypes, events, states, attributes, lsltraits, attrfunctions, transitionspecs, timeconstraints, currentstate, assignmentvector):Trom \u0026 ((forall pt1, pt2 in set porttypes \u0026 (((pt1.label) \u003d (pt2.label)) \u003d\u003e (pt1 \u003d pt2))) \u003d\u003e ((forall e1, e2 in set events \u0026 (((e1.label) \u003d (e2.label)) \u003d\u003e (e1 \u003d e2))) \u003d\u003e ((forall s1, s2 in set states \u0026 (((s1.label) \u003d (s2.label)) \u003d\u003e (s1 \u003d s2))) \u003d\u003e ((forall a1, a2 in set attributes \u0026 (((a1.label) \u003d (a2.label)) \u003d\u003e (a1 \u003d a2))) \u003d\u003e ((forall tr1, tr2 in set lsltraits \u0026 (((tr1.traittype) \u003d (tr2.traittype)) \u003d\u003e (tr1 \u003d tr2))) \u003d\u003e ((forall af1, af2 in set attrfunctions \u0026 (((af1.stat) \u003d (af2.stat)) \u003d\u003e (af1 \u003d af2))) \u003d\u003e ((forall ts1, ts2 in set transitionspecs \u0026 (((ts1.label) \u003d (ts2.label)) \u003d\u003e (ts1 \u003d ts2))) \u003d\u003e ((forall tc1, tc2 in set timeconstraints \u0026 (((tc1.label) \u003d (tc2.label)) \u003d\u003e (tc1 \u003d tc2))) \u003d\u003e ((forall e in set events \u0026 (exists pt in set porttypes \u0026 (pt \u003d (e.porttype)))) \u003d\u003e ((exists1 s in set states \u0026 ((s.isinitial) \u003d true)) \u003d\u003e (forall s in set states \u0026 ((not (currentstate \u003d s)) \u003d\u003e pre_substate_of(currentstate, s))))))))))))))","legal function application obligation:(forall mk_Trom(label, tromclass, porttypes, events, states, attributes, lsltraits, attrfunctions, transitionspecs, timeconstraints, currentstate, assignmentvector):Trom \u0026 ((forall pt1, pt2 in set porttypes \u0026 (((pt1.label) \u003d (pt2.label)) \u003d\u003e (pt1 \u003d pt2))) \u003d\u003e ((forall e1, e2 in set events \u0026 (((e1.label) \u003d (e2.label)) \u003d\u003e (e1 \u003d e2))) \u003d\u003e ((forall s1, s2 in set states \u0026 (((s1.label) \u003d (s2.label)) \u003d\u003e (s1 \u003d s2))) \u003d\u003e ((forall a1, a2 in set attributes \u0026 (((a1.label) \u003d (a2.label)) \u003d\u003e (a1 \u003d a2))) \u003d\u003e ((forall tr1, tr2 in set lsltraits \u0026 (((tr1.traittype) \u003d (tr2.traittype)) \u003d\u003e (tr1 \u003d tr2))) \u003d\u003e ((forall af1, af2 in set attrfunctions \u0026 (((af1.stat) \u003d (af2.stat)) \u003d\u003e (af1 \u003d af2))) \u003d\u003e ((forall ts1, ts2 in set transitionspecs \u0026 (((ts1.label) \u003d (ts2.label)) \u003d\u003e (ts1 \u003d ts2))) \u003d\u003e ((forall tc1, tc2 in set timeconstraints \u0026 (((tc1.label) \u003d (tc2.label)) \u003d\u003e (tc1 \u003d tc2))) \u003d\u003e ((forall e in set events \u0026 (exists pt in set porttypes \u0026 (pt \u003d (e.porttype)))) \u003d\u003e ((exists1 s in set states \u0026 ((s.isinitial) \u003d true)) \u003d\u003e ((exists1 s in set states \u0026 ((currentstate \u003d s) or substate_of(currentstate, s))) \u003d\u003e ((forall a in set attributes \u0026 ((exists1 pt in set porttypes \u0026 ((pt.label) \u003d (a.type))) or (exists1 tr in set lsltraits \u0026 ((tr.traittype) \u003d (a.type))))) \u003d\u003e ((forall tr in set lsltraits \u0026 (forall el in set (elems (tr.elementtypes)) \u0026 ((exists1 pt in set porttypes \u0026 ((pt.label) \u003d el)) or (exists1 tr2 in set lsltraits \u0026 ((tr2.traittype) \u003d el))))) \u003d\u003e (forall af in set attrfunctions \u0026 (forall s in set states \u0026 ((not (s \u003d (af.stat))) \u003d\u003e pre_substate_of((af.stat), s))))))))))))))))))","legal function application obligation:(forall mk_Trom(label, tromclass, porttypes, events, states, attributes, lsltraits, attrfunctions, transitionspecs, timeconstraints, currentstate, assignmentvector):Trom \u0026 ((forall pt1, pt2 in set porttypes \u0026 (((pt1.label) \u003d (pt2.label)) \u003d\u003e (pt1 \u003d pt2))) \u003d\u003e ((forall e1, e2 in set events \u0026 (((e1.label) \u003d (e2.label)) \u003d\u003e (e1 \u003d e2))) \u003d\u003e ((forall s1, s2 in set states \u0026 (((s1.label) \u003d (s2.label)) \u003d\u003e (s1 \u003d s2))) \u003d\u003e ((forall a1, a2 in set attributes \u0026 (((a1.label) \u003d (a2.label)) \u003d\u003e (a1 \u003d a2))) \u003d\u003e ((forall tr1, tr2 in set lsltraits \u0026 (((tr1.traittype) \u003d (tr2.traittype)) \u003d\u003e (tr1 \u003d tr2))) \u003d\u003e ((forall af1, af2 in set attrfunctions \u0026 (((af1.stat) \u003d (af2.stat)) \u003d\u003e (af1 \u003d af2))) \u003d\u003e ((forall ts1, ts2 in set transitionspecs \u0026 (((ts1.label) \u003d (ts2.label)) \u003d\u003e (ts1 \u003d ts2))) \u003d\u003e ((forall tc1, tc2 in set timeconstraints \u0026 (((tc1.label) \u003d (tc2.label)) \u003d\u003e (tc1 \u003d tc2))) \u003d\u003e ((forall e in set events \u0026 (exists pt in set porttypes \u0026 (pt \u003d (e.porttype)))) \u003d\u003e ((exists1 s in set states \u0026 ((s.isinitial) \u003d true)) \u003d\u003e ((exists1 s in set states \u0026 ((currentstate \u003d s) or substate_of(currentstate, s))) \u003d\u003e ((forall a in set attributes \u0026 ((exists1 pt in set porttypes \u0026 ((pt.label) \u003d (a.type))) or (exists1 tr in set lsltraits \u0026 ((tr.traittype) \u003d (a.type))))) \u003d\u003e ((forall tr in set lsltraits \u0026 (forall el in set (elems (tr.elementtypes)) \u0026 ((exists1 pt in set porttypes \u0026 ((pt.label) \u003d el)) or (exists1 tr2 in set lsltraits \u0026 ((tr2.traittype) \u003d el))))) \u003d\u003e ((forall af in set attrfunctions \u0026 ((exists1 s in set states \u0026 ((s \u003d (af.stat)) or substate_of((af.stat), s))) and (forall afa in set (af.attributes) \u0026 (exists1 a in set attributes \u0026 (a \u003d afa))))) \u003d\u003e (forall ts in set transitionspecs \u0026 (forall s in set states \u0026 ((not (s \u003d (ts.sourcestate))) \u003d\u003e pre_substate_of((ts.sourcestate), s)))))))))))))))))))","legal function application obligation:(forall mk_Trom(label, tromclass, porttypes, events, states, attributes, lsltraits, attrfunctions, transitionspecs, timeconstraints, currentstate, assignmentvector):Trom \u0026 ((forall pt1, pt2 in set porttypes \u0026 (((pt1.label) \u003d (pt2.label)) \u003d\u003e (pt1 \u003d pt2))) \u003d\u003e ((forall e1, e2 in set events \u0026 (((e1.label) \u003d (e2.label)) \u003d\u003e (e1 \u003d e2))) \u003d\u003e ((forall s1, s2 in set states \u0026 (((s1.label) \u003d (s2.label)) \u003d\u003e (s1 \u003d s2))) \u003d\u003e ((forall a1, a2 in set attributes \u0026 (((a1.label) \u003d (a2.label)) \u003d\u003e (a1 \u003d a2))) \u003d\u003e ((forall tr1, tr2 in set lsltraits \u0026 (((tr1.traittype) \u003d (tr2.traittype)) \u003d\u003e (tr1 \u003d tr2))) \u003d\u003e ((forall af1, af2 in set attrfunctions \u0026 (((af1.stat) \u003d (af2.stat)) \u003d\u003e (af1 \u003d af2))) \u003d\u003e ((forall ts1, ts2 in set transitionspecs \u0026 (((ts1.label) \u003d (ts2.label)) \u003d\u003e (ts1 \u003d ts2))) \u003d\u003e ((forall tc1, tc2 in set timeconstraints \u0026 (((tc1.label) \u003d (tc2.label)) \u003d\u003e (tc1 \u003d tc2))) \u003d\u003e ((forall e in set events \u0026 (exists pt in set porttypes \u0026 (pt \u003d (e.porttype)))) \u003d\u003e ((exists1 s in set states \u0026 ((s.isinitial) \u003d true)) \u003d\u003e ((exists1 s in set states \u0026 ((currentstate \u003d s) or substate_of(currentstate, s))) \u003d\u003e ((forall a in set attributes \u0026 ((exists1 pt in set porttypes \u0026 ((pt.label) \u003d (a.type))) or (exists1 tr in set lsltraits \u0026 ((tr.traittype) \u003d (a.type))))) \u003d\u003e ((forall tr in set lsltraits \u0026 (forall el in set (elems (tr.elementtypes)) \u0026 ((exists1 pt in set porttypes \u0026 ((pt.label) \u003d el)) or (exists1 tr2 in set lsltraits \u0026 ((tr2.traittype) \u003d el))))) \u003d\u003e ((forall af in set attrfunctions \u0026 ((exists1 s in set states \u0026 ((s \u003d (af.stat)) or substate_of((af.stat), s))) and (forall afa in set (af.attributes) \u0026 (exists1 a in set attributes \u0026 (a \u003d afa))))) \u003d\u003e (forall ts in set transitionspecs \u0026 ((exists1 s in set states \u0026 ((s \u003d (ts.sourcestate)) or substate_of((ts.sourcestate), s))) \u003d\u003e (forall d in set states \u0026 ((not (d \u003d (ts.destinstate))) \u003d\u003e pre_substate_of((ts.destinstate), d))))))))))))))))))))","legal function application obligation:(forall mk_Trom(label, tromclass, porttypes, events, states, attributes, lsltraits, attrfunctions, transitionspecs, timeconstraints, currentstate, assignmentvector):Trom \u0026 ((forall pt1, pt2 in set porttypes \u0026 (((pt1.label) \u003d (pt2.label)) \u003d\u003e (pt1 \u003d pt2))) \u003d\u003e ((forall e1, e2 in set events \u0026 (((e1.label) \u003d (e2.label)) \u003d\u003e (e1 \u003d e2))) \u003d\u003e ((forall s1, s2 in set states \u0026 (((s1.label) \u003d (s2.label)) \u003d\u003e (s1 \u003d s2))) \u003d\u003e ((forall a1, a2 in set attributes \u0026 (((a1.label) \u003d (a2.label)) \u003d\u003e (a1 \u003d a2))) \u003d\u003e ((forall tr1, tr2 in set lsltraits \u0026 (((tr1.traittype) \u003d (tr2.traittype)) \u003d\u003e (tr1 \u003d tr2))) \u003d\u003e ((forall af1, af2 in set attrfunctions \u0026 (((af1.stat) \u003d (af2.stat)) \u003d\u003e (af1 \u003d af2))) \u003d\u003e ((forall ts1, ts2 in set transitionspecs \u0026 (((ts1.label) \u003d (ts2.label)) \u003d\u003e (ts1 \u003d ts2))) \u003d\u003e ((forall tc1, tc2 in set timeconstraints \u0026 (((tc1.label) \u003d (tc2.label)) \u003d\u003e (tc1 \u003d tc2))) \u003d\u003e ((forall e in set events \u0026 (exists pt in set porttypes \u0026 (pt \u003d (e.porttype)))) \u003d\u003e ((exists1 s in set states \u0026 ((s.isinitial) \u003d true)) \u003d\u003e ((exists1 s in set states \u0026 ((currentstate \u003d s) or substate_of(currentstate, s))) \u003d\u003e ((forall a in set attributes \u0026 ((exists1 pt in set porttypes \u0026 ((pt.label) \u003d (a.type))) or (exists1 tr in set lsltraits \u0026 ((tr.traittype) \u003d (a.type))))) \u003d\u003e ((forall tr in set lsltraits \u0026 (forall el in set (elems (tr.elementtypes)) \u0026 ((exists1 pt in set porttypes \u0026 ((pt.label) \u003d el)) or (exists1 tr2 in set lsltraits \u0026 ((tr2.traittype) \u003d el))))) \u003d\u003e ((forall af in set attrfunctions \u0026 ((exists1 s in set states \u0026 ((s \u003d (af.stat)) or substate_of((af.stat), s))) and (forall afa in set (af.attributes) \u0026 (exists1 a in set attributes \u0026 (a \u003d afa))))) \u003d\u003e ((forall ts in set transitionspecs \u0026 ((exists1 s in set states \u0026 ((s \u003d (ts.sourcestate)) or substate_of((ts.sourcestate), s))) and ((exists1 d in set states \u0026 ((d \u003d (ts.destinstate)) or substate_of((ts.destinstate), d))) and (exists1 e in set events \u0026 (e \u003d (ts.triggerevent)))))) \u003d\u003e (forall tc in set timeconstraints \u0026 ((exists1 ts in set transitionspecs \u0026 (ts \u003d (tc.transition))) \u003d\u003e ((exists1 e in set events \u0026 ((e \u003d (tc.constrainedevent)) and (((e.type) \u003d \u003cINTERNAL\u003e) or ((e.type) \u003d \u003cOUTPUT\u003e)))) \u003d\u003e (forall ds in set (tc.disablingstates) \u0026 (forall s in set states \u0026 ((not (s \u003d ds)) \u003d\u003e pre_substate_of(ds, s)))))))))))))))))))))))","type invariant satisfiable obligation:(exists mk_Trom(label, tromclass, porttypes, events, states, attributes, lsltraits, attrfunctions, transitionspecs, timeconstraints, currentstate, assignmentvector):Trom \u0026 ((forall pt1, pt2 in set porttypes \u0026 (((pt1.label) \u003d (pt2.label)) \u003d\u003e (pt1 \u003d pt2))) and ((forall e1, e2 in set events \u0026 (((e1.label) \u003d (e2.label)) \u003d\u003e (e1 \u003d e2))) and ((forall s1, s2 in set states \u0026 (((s1.label) \u003d (s2.label)) \u003d\u003e (s1 \u003d s2))) and ((forall a1, a2 in set attributes \u0026 (((a1.label) \u003d (a2.label)) \u003d\u003e (a1 \u003d a2))) and ((forall tr1, tr2 in set lsltraits \u0026 (((tr1.traittype) \u003d (tr2.traittype)) \u003d\u003e (tr1 \u003d tr2))) and ((forall af1, af2 in set attrfunctions \u0026 (((af1.stat) \u003d (af2.stat)) \u003d\u003e (af1 \u003d af2))) and ((forall ts1, ts2 in set transitionspecs \u0026 (((ts1.label) \u003d (ts2.label)) \u003d\u003e (ts1 \u003d ts2))) and ((forall tc1, tc2 in set timeconstraints \u0026 (((tc1.label) \u003d (tc2.label)) \u003d\u003e (tc1 \u003d tc2))) and ((forall e in set events \u0026 (exists pt in set porttypes \u0026 (pt \u003d (e.porttype)))) and ((exists1 s in set states \u0026 ((s.isinitial) \u003d true)) and ((exists1 s in set states \u0026 ((currentstate \u003d s) or substate_of(currentstate, s))) and ((forall a in set attributes \u0026 ((exists1 pt in set porttypes \u0026 ((pt.label) \u003d (a.type))) or (exists1 tr in set lsltraits \u0026 ((tr.traittype) \u003d (a.type))))) and ((forall tr in set lsltraits \u0026 (forall el in set (elems (tr.elementtypes)) \u0026 ((exists1 pt in set porttypes \u0026 ((pt.label) \u003d el)) or (exists1 tr2 in set lsltraits \u0026 ((tr2.traittype) \u003d el))))) and ((forall af in set attrfunctions \u0026 ((exists1 s in set states \u0026 ((s \u003d (af.stat)) or substate_of((af.stat), s))) and (forall afa in set (af.attributes) \u0026 (exists1 a in set attributes \u0026 (a \u003d afa))))) and ((forall ts in set transitionspecs \u0026 ((exists1 s in set states \u0026 ((s \u003d (ts.sourcestate)) or substate_of((ts.sourcestate), s))) and ((exists1 d in set states \u0026 ((d \u003d (ts.destinstate)) or substate_of((ts.destinstate), d))) and (exists1 e in set events \u0026 (e \u003d (ts.triggerevent)))))) and (forall tc in set timeconstraints \u0026 ((exists1 ts in set transitionspecs \u0026 (ts \u003d (tc.transition))) and ((exists1 e in set events \u0026 ((e \u003d (tc.constrainedevent)) and (((e.type) \u003d \u003cINTERNAL\u003e) or ((e.type) \u003d \u003cOUTPUT\u003e)))) and (forall ds in set (tc.disablingstates) \u0026 (exists1 s in set states \u0026 ((s \u003d ds) or substate_of(ds, s)))))))))))))))))))))))","finite set obligation:(forall mk_Subsystem(label, includes, troms, portlinks):Subsystem \u0026 ((forall s1, s2 in set includes \u0026 (((s1.label) \u003d (s2.label)) \u003d\u003e (s1 \u003d s2))) \u003d\u003e (let included_subsystem: (String * set of (Subsystem) +\u003e bool)\n\tincluded_subsystem(subsystemlabel, subsystems) \u003d\u003d\n(exists1 s in set subsystems \u0026 (((s.label) \u003d subsystemlabel) or included_subsystem(subsystemlabel, (s.includes)))) in (not included_subsystem(label, includes)) \u003d\u003e ((forall trom1, trom2 in set troms \u0026 (((trom1.label) \u003d (trom2.label)) \u003d\u003e (trom1 \u003d trom2))) \u003d\u003e (let included_trom: (String * set of (Subsystem) +\u003e bool)\n\tincluded_trom(tromlabel, subsystems) \u003d\u003d\n(exists1 s in set subsystems \u0026 ((exists1 trom in set (s.troms) \u0026 ((trom.label) \u003d tromlabel)) or included_trom(tromlabel, (s.includes)))) in (forall trom in set troms \u0026 (not included_trom((trom.label), includes))) \u003d\u003e (forall tptuple:TromPortTuple, subsystems:set of (Subsystem) \u0026 (forall s in set subsystems \u0026 (((linked_trom(tptuple, (s.troms)) and (not linked_subsystem(tptuple, (s.includes)))) or ((not linked_trom(tptuple, (s.troms))) and linked_subsystem(tptuple, (s.includes)))) \u003d\u003e (exists finmap1:map (nat) to (Subsystem) \u0026 (forall su:Subsystem \u0026 (((su in set subsystems) and (su \u003c\u003e s)) \u003d\u003e (exists findex2 in set (dom finmap1) \u0026 (finmap1(findex2) \u003d su)))))))))))))","type invariant satisfiable obligation:(exists mk_Subsystem(label, includes, troms, portlinks):Subsystem \u0026 ((forall s1, s2 in set includes \u0026 (((s1.label) \u003d (s2.label)) \u003d\u003e (s1 \u003d s2))) and (let included_subsystem: (String * set of (Subsystem) +\u003e bool)\n\tincluded_subsystem(subsystemlabel, subsystems) \u003d\u003d\n(exists1 s in set subsystems \u0026 (((s.label) \u003d subsystemlabel) or included_subsystem(subsystemlabel, (s.includes)))) in (not included_subsystem(label, includes)) and ((forall trom1, trom2 in set troms \u0026 (((trom1.label) \u003d (trom2.label)) \u003d\u003e (trom1 \u003d trom2))) and (let included_trom: (String * set of (Subsystem) +\u003e bool)\n\tincluded_trom(tromlabel, subsystems) \u003d\u003d\n(exists1 s in set subsystems \u0026 ((exists1 trom in set (s.troms) \u0026 ((trom.label) \u003d tromlabel)) or included_trom(tromlabel, (s.includes)))) in (forall trom in set troms \u0026 (not included_trom((trom.label), includes))) and let linked_trom: (TromPortTuple * set of (Trom) +\u003e bool)\n\tlinked_trom(tptuple, troms) \u003d\u003d\n(exists1 trom in set troms \u0026 (((trom.label) \u003d (tptuple.tromlabel)) and (exists1 pt in set (trom.porttypes) \u0026 (exists1 p in set (elems (pt.portlist)) \u0026 ((p.label) \u003d (tptuple.portlabel)))))), linked_subsystem: (TromPortTuple * set of (Subsystem) +\u003e bool)\n\tlinked_subsystem(tptuple, subsystems) \u003d\u003d\n(exists1 s in set subsystems \u0026 (((linked_trom(tptuple, (s.troms)) and (not linked_subsystem(tptuple, (s.includes)))) or ((not linked_trom(tptuple, (s.troms))) and linked_subsystem(tptuple, (s.includes)))) and (forall s2 in set {su | su:Subsystem \u0026 ((su in set subsystems) and (su \u003c\u003e s))} \u0026 ((not linked_trom(tptuple, (s2.troms))) and (not linked_subsystem(tptuple, (s2.includes))))))) in (forall pl in set portlinks \u0026 (((linked_trom((pl.tromporttuple1), troms) and (not linked_subsystem((pl.tromporttuple1), includes))) or ((not linked_trom((pl.tromporttuple1), troms)) and linked_subsystem((pl.tromporttuple1), includes))) and ((linked_trom((pl.tromporttuple2), troms) and (not linked_subsystem((pl.tromporttuple2), includes))) or ((not linked_trom((pl.tromporttuple2), troms)) and linked_subsystem((pl.tromporttuple2), includes))))))))))","legal sequence application obligation:(forall mk_System(subsystem, simulationeventlist, lsllibrary, clock):System \u0026 (let contains_trom: (Subsystem +\u003e bool)\n\tcontains_trom(subsys) \u003d\u003d\n(((subsys.troms) \u003c\u003e {}) or (exists1 s in set (subsys.includes) \u0026 contains_trom(s))) in contains_trom(subsystem) \u003d\u003e (let contains_portlink: (Subsystem +\u003e bool)\n\tcontains_portlink(subsys) \u003d\u003d\n(((subsys.portlinks) \u003c\u003e {}) or (exists1 s in set (subsys.includes) \u0026 contains_portlink(s))) in contains_portlink(subsystem) \u003d\u003e (forall i, j in set (inds simulationeventlist) \u0026 ((i \u003d j) \u003d\u003e (i in set (inds simulationeventlist)))))))","legal sequence application obligation:(forall mk_System(subsystem, simulationeventlist, lsllibrary, clock):System \u0026 (let contains_trom: (Subsystem +\u003e bool)\n\tcontains_trom(subsys) \u003d\u003d\n(((subsys.troms) \u003c\u003e {}) or (exists1 s in set (subsys.includes) \u0026 contains_trom(s))) in contains_trom(subsystem) \u003d\u003e (let contains_portlink: (Subsystem +\u003e bool)\n\tcontains_portlink(subsys) \u003d\u003d\n(((subsys.portlinks) \u003c\u003e {}) or (exists1 s in set (subsys.includes) \u0026 contains_portlink(s))) in contains_portlink(subsystem) \u003d\u003e (forall i, j in set (inds simulationeventlist) \u0026 ((i \u003d j) \u003d\u003e (j in set (inds simulationeventlist)))))))","legal sequence application obligation:(forall mk_System(subsystem, simulationeventlist, lsllibrary, clock):System \u0026 (let contains_trom: (Subsystem +\u003e bool)\n\tcontains_trom(subsys) \u003d\u003d\n(((subsys.troms) \u003c\u003e {}) or (exists1 s in set (subsys.includes) \u0026 contains_trom(s))) in contains_trom(subsystem) \u003d\u003e (let contains_portlink: (Subsystem +\u003e bool)\n\tcontains_portlink(subsys) \u003d\u003d\n(((subsys.portlinks) \u003c\u003e {}) or (exists1 s in set (subsys.includes) \u0026 contains_portlink(s))) in contains_portlink(subsystem) \u003d\u003e (forall i, j in set (inds simulationeventlist) \u0026 ((not ((i \u003d j) and (simulationeventlist(i) \u003d simulationeventlist(j)))) \u003d\u003e ((i \u003c j) \u003d\u003e (i in set (inds simulationeventlist))))))))","legal sequence application obligation:(forall mk_System(subsystem, simulationeventlist, lsllibrary, clock):System \u0026 (let contains_trom: (Subsystem +\u003e bool)\n\tcontains_trom(subsys) \u003d\u003d\n(((subsys.troms) \u003c\u003e {}) or (exists1 s in set (subsys.includes) \u0026 contains_trom(s))) in contains_trom(subsystem) \u003d\u003e (let contains_portlink: (Subsystem +\u003e bool)\n\tcontains_portlink(subsys) \u003d\u003d\n(((subsys.portlinks) \u003c\u003e {}) or (exists1 s in set (subsys.includes) \u0026 contains_portlink(s))) in contains_portlink(subsystem) \u003d\u003e (forall i, j in set (inds simulationeventlist) \u0026 ((not ((i \u003d j) and (simulationeventlist(i) \u003d simulationeventlist(j)))) \u003d\u003e ((i \u003c j) \u003d\u003e (j in set (inds simulationeventlist))))))))","legal sequence application obligation:(forall mk_System(subsystem, simulationeventlist, lsllibrary, clock):System \u0026 (let contains_trom: (Subsystem +\u003e bool)\n\tcontains_trom(subsys) \u003d\u003d\n(((subsys.troms) \u003c\u003e {}) or (exists1 s in set (subsys.includes) \u0026 contains_trom(s))) in contains_trom(subsystem) \u003d\u003e (let contains_portlink: (Subsystem +\u003e bool)\n\tcontains_portlink(subsys) \u003d\u003d\n(((subsys.portlinks) \u003c\u003e {}) or (exists1 s in set (subsys.includes) \u0026 contains_portlink(s))) in contains_portlink(subsystem) \u003d\u003e (forall i, j in set (inds simulationeventlist) \u0026 ((not ((i \u003d j) and (simulationeventlist(i) \u003d simulationeventlist(j)))) \u003d\u003e ((not ((i \u003c j) and ((simulationeventlist(i).occurtime) \u003c\u003d (simulationeventlist(j).occurtime)))) \u003d\u003e ((i \u003e j) \u003d\u003e (i in set (inds simulationeventlist)))))))))","legal sequence application obligation:(forall mk_System(subsystem, simulationeventlist, lsllibrary, clock):System \u0026 (let contains_trom: (Subsystem +\u003e bool)\n\tcontains_trom(subsys) \u003d\u003d\n(((subsys.troms) \u003c\u003e {}) or (exists1 s in set (subsys.includes) \u0026 contains_trom(s))) in contains_trom(subsystem) \u003d\u003e (let contains_portlink: (Subsystem +\u003e bool)\n\tcontains_portlink(subsys) \u003d\u003d\n(((subsys.portlinks) \u003c\u003e {}) or (exists1 s in set (subsys.includes) \u0026 contains_portlink(s))) in contains_portlink(subsystem) \u003d\u003e (forall i, j in set (inds simulationeventlist) \u0026 ((not ((i \u003d j) and (simulationeventlist(i) \u003d simulationeventlist(j)))) \u003d\u003e ((not ((i \u003c j) and ((simulationeventlist(i).occurtime) \u003c\u003d (simulationeventlist(j).occurtime)))) \u003d\u003e ((i \u003e j) \u003d\u003e (j in set (inds simulationeventlist)))))))))","finite set obligation:(forall mk_System(subsystem, simulationeventlist, lsllibrary, clock):System \u0026 (let contains_trom: (Subsystem +\u003e bool)\n\tcontains_trom(subsys) \u003d\u003d\n(((subsys.troms) \u003c\u003e {}) or (exists1 s in set (subsys.includes) \u0026 contains_trom(s))) in contains_trom(subsystem) \u003d\u003e (let contains_portlink: (Subsystem +\u003e bool)\n\tcontains_portlink(subsys) \u003d\u003d\n(((subsys.portlinks) \u003c\u003e {}) or (exists1 s in set (subsys.includes) \u0026 contains_portlink(s))) in contains_portlink(subsystem) \u003d\u003e ((forall i, j in set (inds simulationeventlist) \u0026 (((i \u003d j) and (simulationeventlist(i) \u003d simulationeventlist(j))) or (((i \u003c j) and ((simulationeventlist(i).occurtime) \u003c\u003d (simulationeventlist(j).occurtime))) or ((i \u003e j) and ((simulationeventlist(i).occurtime) \u003e\u003d (simulationeventlist(j).occurtime)))))) \u003d\u003e ((forall se1, se2 in set (elems simulationeventlist) \u0026 ((((se1.occurtime) \u003d (se2.occurtime)) and ((se1.tromlabel) \u003c\u003e (se2.tromlabel))) or ((se1.occurtime) \u003c\u003e (se2.occurtime)))) \u003d\u003e let accepted_by_trom: (SimulationEvent * Subsystem +\u003e bool)\n\taccepted_by_trom(se, subsys) \u003d\u003d\n(exists1 trom in set (subsys.troms) \u0026 (((trom.label) \u003d (se.tromlabel)) and (exists1 e in set (trom.events) \u0026 (((e.label) \u003d (se.eventlabel)) and (exists1 pt in set (trom.porttypes) \u0026 ((pt \u003d (e.porttype)) and (exists1 p in set (elems (pt.portlist)) \u0026 ((p.label) \u003d (se.portlabel))))))))) in (forall se:SimulationEvent, subsys:Subsystem \u0026 (forall s in set (subsys.includes) \u0026 (((accepted_by_trom(se, s) and (not accepted_by_subsystem(se, s))) or ((not accepted_by_trom(se, s)) and accepted_by_subsystem(se, s))) \u003d\u003e (exists finmap1:map (nat) to (Subsystem) \u0026 (forall su:Subsystem \u0026 (((su in set (subsys.includes)) and (su \u003c\u003e s)) \u003d\u003e (exists findex2 in set (dom finmap1) \u0026 (finmap1(findex2) \u003d su)))))))))))))","function postcondition satisfiable obligation:(forall tromlabel:String, subsystem:Subsystem \u0026 (exists trom:[Trom] \u0026 post_get_trom_object(tromlabel, subsystem, trom)))","legal function application obligation:(forall trom:Trom, se:SimulationEvent \u0026 (((trom.label) \u003d (se.tromlabel)) \u003d\u003e (exists ts:[TransitionSpec] \u0026 ((ts in set (trom.transitionspecs)) \u003d\u003e ((not (((trom.currentstate).label) \u003d ((ts.sourcestate).label))) \u003d\u003e pre_substate_of((trom.currentstate), (ts.sourcestate)))))))","function postcondition satisfiable obligation:(forall trom:Trom, se:SimulationEvent \u0026 (pre_get_transition_spec(trom, se) \u003d\u003e (exists ts:[TransitionSpec] \u0026 post_get_transition_spec(trom, se, ts))))","legal function application obligation:(forall substate:State, complexstate:State \u0026 (((complexstate.type) \u003d \u003cCOMPLEX\u003e) \u003d\u003e ((not (substate in set (complexstate.substates))) \u003d\u003e (forall s in set (complexstate.substates) \u0026 (((s.type) \u003d \u003cCOMPLEX\u003e) \u003d\u003e pre_substate_of(substate, s))))))","legal function application obligation:(forall complexstate:State \u0026 (((complexstate.type) \u003d \u003cCOMPLEX\u003e) \u003d\u003e (exists entry:State \u0026 (forall s in set (complexstate.substates) \u0026 (((s.isinitial) \u003d true) \u003d\u003e ((not (((s.type) \u003d \u003cSIMPLE\u003e) and (entry \u003d s))) \u003d\u003e (((s.type) \u003d \u003cCOMPLEX\u003e) \u003d\u003e pre_get_entry_state(s))))))))","function postcondition satisfiable obligation:(forall complexstate:State \u0026 (pre_get_entry_state(complexstate) \u003d\u003e (exists entry:State \u0026 post_get_entry_state(complexstate, entry))))","legal function application obligation:(forall trom:Trom \u0026 (((trom.states) \u003c\u003e {}) \u003d\u003e (exists initial:State \u0026 (forall s in set (trom.states) \u0026 (((s.isinitial) \u003d true) \u003d\u003e ((not (((s.type) \u003d \u003cSIMPLE\u003e) and (initial \u003d s))) \u003d\u003e (((s.type) \u003d \u003cCOMPLEX\u003e) \u003d\u003e pre_get_entry_state(s))))))))","function postcondition satisfiable obligation:(forall trom:Trom \u0026 (pre_get_initial_state(trom) \u003d\u003e (exists initial:State \u0026 post_get_initial_state(trom, initial))))","function postcondition satisfiable obligation:(forall tupleA:TromPortTuple, subsystem:Subsystem \u0026 (exists tupleB:[TromPortTuple] \u0026 post_get_linked_tromport_tuple(tupleA, subsystem, tupleB)))","legal function application obligation:(forall trom:Trom, subsys:Subsystem \u0026 ((((subsys.troms) \u003c\u003e {}) or ((subsys.includes) \u003c\u003e {})) \u003d\u003e ((not (trom in set (subsys.troms))) \u003d\u003e (forall subsystem in set (subsys.includes) \u0026 pre_exists_in_subsystem(trom, subsystem)))))","legal function application obligation:(forall trom:Trom \u0026 (exists event:[Event] \u0026 (forall ts in set (trom.transitionspecs) \u0026 (((ts.sourcestate) \u003d (trom.currentstate)) \u003d\u003e ((((ts.triggerevent).type) \u003d \u003cINTERNAL\u003e) \u003d\u003e pre_constrained_event(trom, (ts.triggerevent)))))))","function postcondition satisfiable obligation:(forall trom:Trom \u0026 (exists event:[Event] \u0026 post_get_unconstrained_internal_event(trom, event)))","legal sequence application obligation:(forall se:SimulationEvent, se_list:seq of (SimulationEvent) \u0026 ((se in set (elems se_list)) \u003d\u003e (exists index:nat1 \u0026 (index in set (inds se_list)))))","function postcondition satisfiable obligation:(forall se:SimulationEvent, se_list:seq of (SimulationEvent) \u0026 (pre_get_simevent_index(se, se_list) \u003d\u003e (exists index:nat1 \u0026 post_get_simevent_index(se, se_list, index))))","function postcondition satisfiable obligation:(forall rw:ReactionWindow \u0026 (exists time:nat \u0026 post_get_random_time_within_rw(rw, time)))","function postcondition satisfiable obligation:(forall portlist:seq of (Port) \u0026 (pre_get_lru_port(portlist) \u003d\u003e (exists port:Port \u0026 post_get_lru_port(portlist, port))))","finite set obligation:(((SIMULATIONEVENTLIST \u003c\u003e []) and ((forall se in set (elems SIMULATIONEVENTLIST) \u0026 (((se.occurtime) \u003e\u003d CLOCK) and ((se.eventhistory) \u003d nil))) and (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 (((trom.currentstate) \u003d get_initial_state(trom)) and (forall tc in set (trom.timeconstraints) \u0026 ((tc.reactionwindows) \u003d {})))))) \u003d\u003e ((SIMULATIONEVENTLIST \u003c\u003e []) \u003d\u003e ((forall se in set (elems SIMULATIONEVENTLIST) \u0026 (((se.occurtime) \u003e\u003d CLOCK) and ((se.eventhistory) \u003d nil))) \u003d\u003e (exists finmap1:map (nat) to (Trom) \u0026 (forall trom:Trom \u0026 (exists_in_subsystem(trom, SUBSYSTEM) \u003d\u003e (exists findex2 in set (dom finmap1) \u0026 (finmap1(findex2) \u003d trom))))))))","legal function application obligation:(((SIMULATIONEVENTLIST \u003c\u003e []) and ((forall se in set (elems SIMULATIONEVENTLIST) \u0026 (((se.occurtime) \u003e\u003d CLOCK) and ((se.eventhistory) \u003d nil))) and (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 (((trom.currentstate) \u003d get_initial_state(trom)) and (forall tc in set (trom.timeconstraints) \u0026 ((tc.reactionwindows) \u003d {})))))) \u003d\u003e ((SIMULATIONEVENTLIST \u003c\u003e []) \u003d\u003e ((forall se in set (elems SIMULATIONEVENTLIST) \u0026 (((se.occurtime) \u003e\u003d CLOCK) and ((se.eventhistory) \u003d nil))) \u003d\u003e (forall trom:Trom \u0026 pre_exists_in_subsystem(trom, SUBSYSTEM)))))","legal function application obligation:(((SIMULATIONEVENTLIST \u003c\u003e []) and ((forall se in set (elems SIMULATIONEVENTLIST) \u0026 (((se.occurtime) \u003e\u003d CLOCK) and ((se.eventhistory) \u003d nil))) and (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 (((trom.currentstate) \u003d get_initial_state(trom)) and (forall tc in set (trom.timeconstraints) \u0026 ((tc.reactionwindows) \u003d {})))))) \u003d\u003e ((SIMULATIONEVENTLIST \u003c\u003e []) \u003d\u003e ((forall se in set (elems SIMULATIONEVENTLIST) \u0026 (((se.occurtime) \u003e\u003d CLOCK) and ((se.eventhistory) \u003d nil))) \u003d\u003e (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 pre_get_initial_state(trom)))))","operation call obligation:(((SIMULATIONEVENTLIST \u003c\u003e []) and ((forall se in set (elems SIMULATIONEVENTLIST) \u0026 (((se.occurtime) \u003e\u003d CLOCK) and ((se.eventhistory) \u003d nil))) and (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 (((trom.currentstate) \u003d get_initial_state(trom)) and (forall tc in set (trom.timeconstraints) \u0026 ((tc.reactionwindows) \u003d {})))))) \u003d\u003e ((CLOCK \u003d 0) \u003d\u003e (CLOCK \u003d 0)))","while loop termination obligation:NotYetImplemented","while loop termination obligation:NotYetImplemented","legal sequence application obligation:(((SIMULATIONEVENTLIST \u003c\u003e []) and ((forall se in set (elems SIMULATIONEVENTLIST) \u0026 (((se.occurtime) \u003e\u003d CLOCK) and ((se.eventhistory) \u003d nil))) and (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 (((trom.currentstate) \u003d get_initial_state(trom)) and (forall tc in set (trom.timeconstraints) \u0026 ((tc.reactionwindows) \u003d {})))))) \u003d\u003e ((CLOCK \u003d 0) \u003d\u003e (((CLOCK \u003d 0) and (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 let event:[Event] \u003d get_unconstrained_internal_event(trom) in (((event \u003c\u003e nil) and let se:SimulationEvent be st (se \u003d mk_SimulationEvent((event.label), (trom.label), \"NULLPORT\", CLOCK, nil)) in ((se in set (elems SIMULATIONEVENTLIST)) and let i:nat1 be st (SIMULATIONEVENTLIST(i) \u003d se) in (forall se2 in set (elems SIMULATIONEVENTLIST~) \u0026 let j:nat1 be st (SIMULATIONEVENTLIST(j) \u003d se2) in (i \u003c j)))) or (event \u003d nil)))) \u003d\u003e (i in set (inds SIMULATIONEVENTLIST)))))","while loop termination obligation:NotYetImplemented","legal sequence application obligation:(((SIMULATIONEVENTLIST \u003c\u003e []) and ((forall se in set (elems SIMULATIONEVENTLIST) \u0026 (((se.occurtime) \u003e\u003d CLOCK) and ((se.eventhistory) \u003d nil))) and (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 (((trom.currentstate) \u003d get_initial_state(trom)) and (forall tc in set (trom.timeconstraints) \u0026 ((tc.reactionwindows) \u003d {})))))) \u003d\u003e ((CLOCK \u003d 0) \u003d\u003e (((CLOCK \u003d 0) and (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 let event:[Event] \u003d get_unconstrained_internal_event(trom) in (((event \u003c\u003e nil) and let se:SimulationEvent be st (se \u003d mk_SimulationEvent((event.label), (trom.label), \"NULLPORT\", CLOCK, nil)) in ((se in set (elems SIMULATIONEVENTLIST)) and let i:nat1 be st (SIMULATIONEVENTLIST(i) \u003d se) in (forall se2 in set (elems SIMULATIONEVENTLIST~) \u0026 let j:nat1 be st (SIMULATIONEVENTLIST(j) \u003d se2) in (i \u003c j)))) or (event \u003d nil)))) \u003d\u003e ((CLOCK \u003d (CLOCK~ + 1)) \u003d\u003e ((i \u003c\u003d (len SIMULATIONEVENTLIST)) \u003d\u003e (i in set (inds SIMULATIONEVENTLIST)))))))","legal sequence application obligation:(((SIMULATIONEVENTLIST \u003c\u003e []) and ((forall se in set (elems SIMULATIONEVENTLIST) \u0026 (((se.occurtime) \u003e\u003d CLOCK) and ((se.eventhistory) \u003d nil))) and (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 (((trom.currentstate) \u003d get_initial_state(trom)) and (forall tc in set (trom.timeconstraints) \u0026 ((tc.reactionwindows) \u003d {})))))) \u003d\u003e ((CLOCK \u003d 0) \u003d\u003e (((CLOCK \u003d 0) and (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 let event:[Event] \u003d get_unconstrained_internal_event(trom) in (((event \u003c\u003e nil) and let se:SimulationEvent be st (se \u003d mk_SimulationEvent((event.label), (trom.label), \"NULLPORT\", CLOCK, nil)) in ((se in set (elems SIMULATIONEVENTLIST)) and let i:nat1 be st (SIMULATIONEVENTLIST(i) \u003d se) in (forall se2 in set (elems SIMULATIONEVENTLIST~) \u0026 let j:nat1 be st (SIMULATIONEVENTLIST(j) \u003d se2) in (i \u003c j)))) or (event \u003d nil)))) \u003d\u003e ((CLOCK \u003d (CLOCK~ + 1)) \u003d\u003e (i in set (inds SIMULATIONEVENTLIST))))))","operation call obligation:(((SIMULATIONEVENTLIST \u003c\u003e []) and ((forall se in set (elems SIMULATIONEVENTLIST) \u0026 (((se.occurtime) \u003e\u003d CLOCK) and ((se.eventhistory) \u003d nil))) and (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 (((trom.currentstate) \u003d get_initial_state(trom)) and (forall tc in set (trom.timeconstraints) \u0026 ((tc.reactionwindows) \u003d {})))))) \u003d\u003e ((CLOCK \u003d 0) \u003d\u003e (((CLOCK \u003d 0) and (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 let event:[Event] \u003d get_unconstrained_internal_event(trom) in (((event \u003c\u003e nil) and let se:SimulationEvent be st (se \u003d mk_SimulationEvent((event.label), (trom.label), \"NULLPORT\", CLOCK, nil)) in ((se in set (elems SIMULATIONEVENTLIST)) and let i:nat1 be st (SIMULATIONEVENTLIST(i) \u003d se) in (forall se2 in set (elems SIMULATIONEVENTLIST~) \u0026 let j:nat1 be st (SIMULATIONEVENTLIST(j) \u003d se2) in (i \u003c j)))) or (event \u003d nil)))) \u003d\u003e ((CLOCK \u003d (CLOCK~ + 1)) \u003d\u003e ((SIMULATIONEVENTLIST(i).occurtime) \u003d CLOCK)))))","state invariant holds obligation:(((SIMULATIONEVENTLIST \u003c\u003e []) and ((forall se in set (elems SIMULATIONEVENTLIST) \u0026 (((se.occurtime) \u003e\u003d CLOCK) and ((se.eventhistory) \u003d nil))) and (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 (((trom.currentstate) \u003d get_initial_state(trom)) and (forall tc in set (trom.timeconstraints) \u0026 ((tc.reactionwindows) \u003d {})))))) \u003d\u003e ((CLOCK \u003d 0) \u003d\u003e (((CLOCK \u003d 0) and (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 let event:[Event] \u003d get_unconstrained_internal_event(trom) in (((event \u003c\u003e nil) and let se:SimulationEvent be st (se \u003d mk_SimulationEvent((event.label), (trom.label), \"NULLPORT\", CLOCK, nil)) in ((se in set (elems SIMULATIONEVENTLIST)) and let i:nat1 be st (SIMULATIONEVENTLIST(i) \u003d se) in (forall se2 in set (elems SIMULATIONEVENTLIST~) \u0026 let j:nat1 be st (SIMULATIONEVENTLIST(j) \u003d se2) in (i \u003c j)))) or (event \u003d nil)))) \u003d\u003e ((CLOCK \u003d (CLOCK~ + 1)) \u003d\u003e ((CLOCK \u003d CLOCK~) \u003d\u003e let mk_System(subsystem, simulationeventlist, lsllibrary, clock) \u003d System in (let contains_trom: (Subsystem +\u003e bool)\n\tcontains_trom(subsys) \u003d\u003d\n(((subsys.troms) \u003c\u003e {}) or (exists1 s in set (subsys.includes) \u0026 contains_trom(s))) in contains_trom(subsystem) and (let contains_portlink: (Subsystem +\u003e bool)\n\tcontains_portlink(subsys) \u003d\u003d\n(((subsys.portlinks) \u003c\u003e {}) or (exists1 s in set (subsys.includes) \u0026 contains_portlink(s))) in contains_portlink(subsystem) and ((forall i, j in set (inds simulationeventlist) \u0026 (((i \u003d j) and (simulationeventlist(i) \u003d simulationeventlist(j))) or (((i \u003c j) and ((simulationeventlist(i).occurtime) \u003c\u003d (simulationeventlist(j).occurtime))) or ((i \u003e j) and ((simulationeventlist(i).occurtime) \u003e\u003d (simulationeventlist(j).occurtime)))))) and ((forall se1, se2 in set (elems simulationeventlist) \u0026 ((((se1.occurtime) \u003d (se2.occurtime)) and ((se1.tromlabel) \u003c\u003e (se2.tromlabel))) or ((se1.occurtime) \u003c\u003e (se2.occurtime)))) and (let accepted_by_trom: (SimulationEvent * Subsystem +\u003e bool)\n\taccepted_by_trom(se, subsys) \u003d\u003d\n(exists1 trom in set (subsys.troms) \u0026 (((trom.label) \u003d (se.tromlabel)) and (exists1 e in set (trom.events) \u0026 (((e.label) \u003d (se.eventlabel)) and (exists1 pt in set (trom.porttypes) \u0026 ((pt \u003d (e.porttype)) and (exists1 p in set (elems (pt.portlist)) \u0026 ((p.label) \u003d (se.portlabel))))))))) in let accepted_by_subsystem: (SimulationEvent * Subsystem +\u003e bool)\n\taccepted_by_subsystem(se, subsys) \u003d\u003d\n(exists1 s in set (subsys.includes) \u0026 (((accepted_by_trom(se, s) and (not accepted_by_subsystem(se, s))) or ((not accepted_by_trom(se, s)) and accepted_by_subsystem(se, s))) and (forall s2 in set {su | su:Subsystem \u0026 ((su in set (subsys.includes)) and (su \u003c\u003e s))} \u0026 ((not accepted_by_trom(se, s2)) and (not accepted_by_subsystem(se, s2)))))) in (forall se in set (elems simulationeventlist) \u0026 ((accepted_by_trom(se, subsystem) and (not accepted_by_subsystem(se, subsystem))) or ((not accepted_by_trom(se, subsystem)) and accepted_by_subsystem(se, subsystem)))) and let exists_lsltrait: (Subsystem +\u003e bool)\n\texists_lsltrait(subsys) \u003d\u003d\n((forall trom in set (subsys.troms) \u0026 (forall tr in set (trom.lsltraits) \u0026 (exists traitdef in set lsllibrary \u0026 ((traitdef.label) \u003d (tr.traitlabel))))) and (forall s in set (subsys.includes) \u0026 exists_lsltrait(s))) in exists_lsltrait(subsystem)))))))))))","legal sequence application obligation:(((SIMULATIONEVENTLIST \u003c\u003e []) and ((forall se in set (elems SIMULATIONEVENTLIST) \u0026 (((se.occurtime) \u003e\u003d CLOCK) and ((se.eventhistory) \u003d nil))) and (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 (((trom.currentstate) \u003d get_initial_state(trom)) and (forall tc in set (trom.timeconstraints) \u0026 ((tc.reactionwindows) \u003d {})))))) \u003d\u003e ((CLOCK \u003d 0) \u003d\u003e (((CLOCK \u003d 0) and (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 let event:[Event] \u003d get_unconstrained_internal_event(trom) in (((event \u003c\u003e nil) and let se:SimulationEvent be st (se \u003d mk_SimulationEvent((event.label), (trom.label), \"NULLPORT\", CLOCK, nil)) in ((se in set (elems SIMULATIONEVENTLIST)) and let i:nat1 be st (SIMULATIONEVENTLIST(i) \u003d se) in (forall se2 in set (elems SIMULATIONEVENTLIST~) \u0026 let j:nat1 be st (SIMULATIONEVENTLIST(j) \u003d se2) in (i \u003c j)))) or (event \u003d nil)))) \u003d\u003e ((CLOCK \u003d (CLOCK~ + 1)) \u003d\u003e ((CLOCK \u003d CLOCK~) \u003d\u003e ((SIMULATIONEVENTLIST \u003c\u003e []) \u003d\u003e ((len SIMULATIONEVENTLIST) in set (inds SIMULATIONEVENTLIST))))))))","finite set obligation:(((SIMULATIONEVENTLIST \u003c\u003e []) and ((forall se in set (elems SIMULATIONEVENTLIST) \u0026 (((se.occurtime) \u003e\u003d CLOCK) and ((se.eventhistory) \u003d nil))) and (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 (((trom.currentstate) \u003d get_initial_state(trom)) and (forall tc in set (trom.timeconstraints) \u0026 ((tc.reactionwindows) \u003d {})))))) \u003d\u003e ((CLOCK \u003d 0) \u003d\u003e (((CLOCK \u003d 0) and (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 let event:[Event] \u003d get_unconstrained_internal_event(trom) in (((event \u003c\u003e nil) and let se:SimulationEvent be st (se \u003d mk_SimulationEvent((event.label), (trom.label), \"NULLPORT\", CLOCK, nil)) in ((se in set (elems SIMULATIONEVENTLIST)) and let i:nat1 be st (SIMULATIONEVENTLIST(i) \u003d se) in (forall se2 in set (elems SIMULATIONEVENTLIST~) \u0026 let j:nat1 be st (SIMULATIONEVENTLIST(j) \u003d se2) in (i \u003c j)))) or (event \u003d nil)))) \u003d\u003e ((CLOCK \u003d (CLOCK~ + 1)) \u003d\u003e ((CLOCK \u003d CLOCK~) \u003d\u003e ((SIMULATIONEVENTLIST \u003c\u003e []) \u003d\u003e (((SIMULATIONEVENTLIST((len SIMULATIONEVENTLIST)).occurtime) \u003d CLOCK) \u003d\u003e ((forall se in set (elems SIMULATIONEVENTLIST) \u0026 (((se.occurtime) \u003c\u003d CLOCK) and ((se.eventhistory) \u003c\u003e nil))) \u003d\u003e (exists finmap1:map (nat) to (Trom) \u0026 (forall trom:Trom \u0026 (exists_in_subsystem(trom, SUBSYSTEM) \u003d\u003e (exists findex2 in set (dom finmap1) \u0026 (finmap1(findex2) \u003d trom)))))))))))))","legal function application obligation:(((SIMULATIONEVENTLIST \u003c\u003e []) and ((forall se in set (elems SIMULATIONEVENTLIST) \u0026 (((se.occurtime) \u003e\u003d CLOCK) and ((se.eventhistory) \u003d nil))) and (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 (((trom.currentstate) \u003d get_initial_state(trom)) and (forall tc in set (trom.timeconstraints) \u0026 ((tc.reactionwindows) \u003d {})))))) \u003d\u003e ((CLOCK \u003d 0) \u003d\u003e (((CLOCK \u003d 0) and (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 let event:[Event] \u003d get_unconstrained_internal_event(trom) in (((event \u003c\u003e nil) and let se:SimulationEvent be st (se \u003d mk_SimulationEvent((event.label), (trom.label), \"NULLPORT\", CLOCK, nil)) in ((se in set (elems SIMULATIONEVENTLIST)) and let i:nat1 be st (SIMULATIONEVENTLIST(i) \u003d se) in (forall se2 in set (elems SIMULATIONEVENTLIST~) \u0026 let j:nat1 be st (SIMULATIONEVENTLIST(j) \u003d se2) in (i \u003c j)))) or (event \u003d nil)))) \u003d\u003e ((CLOCK \u003d (CLOCK~ + 1)) \u003d\u003e ((CLOCK \u003d CLOCK~) \u003d\u003e ((SIMULATIONEVENTLIST \u003c\u003e []) \u003d\u003e (((SIMULATIONEVENTLIST((len SIMULATIONEVENTLIST)).occurtime) \u003d CLOCK) \u003d\u003e ((forall se in set (elems SIMULATIONEVENTLIST) \u0026 (((se.occurtime) \u003c\u003d CLOCK) and ((se.eventhistory) \u003c\u003e nil))) \u003d\u003e (forall trom:Trom \u0026 pre_exists_in_subsystem(trom, SUBSYSTEM))))))))))","operation establishes postcondition obligation:(((SIMULATIONEVENTLIST \u003c\u003e []) and ((forall se in set (elems SIMULATIONEVENTLIST) \u0026 (((se.occurtime) \u003e\u003d CLOCK) and ((se.eventhistory) \u003d nil))) and (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 (((trom.currentstate) \u003d get_initial_state(trom)) and (forall tc in set (trom.timeconstraints) \u0026 ((tc.reactionwindows) \u003d {})))))) \u003d\u003e ((CLOCK \u003d 0) \u003d\u003e (((CLOCK \u003d 0) and (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 let event:[Event] \u003d get_unconstrained_internal_event(trom) in (((event \u003c\u003e nil) and let se:SimulationEvent be st (se \u003d mk_SimulationEvent((event.label), (trom.label), \"NULLPORT\", CLOCK, nil)) in ((se in set (elems SIMULATIONEVENTLIST)) and let i:nat1 be st (SIMULATIONEVENTLIST(i) \u003d se) in (forall se2 in set (elems SIMULATIONEVENTLIST~) \u0026 let j:nat1 be st (SIMULATIONEVENTLIST(j) \u003d se2) in (i \u003c j)))) or (event \u003d nil)))) \u003d\u003e ((CLOCK \u003d (CLOCK~ + 1)) \u003d\u003e ((CLOCK \u003d CLOCK~) \u003d\u003e ((SIMULATIONEVENTLIST \u003c\u003e []) and (((SIMULATIONEVENTLIST((len SIMULATIONEVENTLIST)).occurtime) \u003d CLOCK) and ((forall se in set (elems SIMULATIONEVENTLIST) \u0026 (((se.occurtime) \u003c\u003d CLOCK) and ((se.eventhistory) \u003c\u003e nil))) and (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 (forall tc in set (trom.timeconstraints) \u0026 ((tc.reactionwindows) \u003d {})))))))))))","state invariant holds obligation:(forall se:SimulationEvent, oldstate:System \u0026 (((se.occurtime) \u003d CLOCK) \u003d\u003e let mk_System(subsystem, simulationeventlist, lsllibrary, clock) \u003d System in (let contains_trom: (Subsystem +\u003e bool)\n\tcontains_trom(subsys) \u003d\u003d\n(((subsys.troms) \u003c\u003e {}) or (exists1 s in set (subsys.includes) \u0026 contains_trom(s))) in contains_trom(subsystem) and (let contains_portlink: (Subsystem +\u003e bool)\n\tcontains_portlink(subsys) \u003d\u003d\n(((subsys.portlinks) \u003c\u003e {}) or (exists1 s in set (subsys.includes) \u0026 contains_portlink(s))) in contains_portlink(subsystem) and ((forall i, j in set (inds simulationeventlist) \u0026 (((i \u003d j) and (simulationeventlist(i) \u003d simulationeventlist(j))) or (((i \u003c j) and ((simulationeventlist(i).occurtime) \u003c\u003d (simulationeventlist(j).occurtime))) or ((i \u003e j) and ((simulationeventlist(i).occurtime) \u003e\u003d (simulationeventlist(j).occurtime)))))) and ((forall se1, se2 in set (elems simulationeventlist) \u0026 ((((se1.occurtime) \u003d (se2.occurtime)) and ((se1.tromlabel) \u003c\u003e (se2.tromlabel))) or ((se1.occurtime) \u003c\u003e (se2.occurtime)))) and (let accepted_by_trom: (SimulationEvent * Subsystem +\u003e bool)\n\taccepted_by_trom(se, subsys) \u003d\u003d\n(exists1 trom in set (subsys.troms) \u0026 (((trom.label) \u003d (se.tromlabel)) and (exists1 e in set (trom.events) \u0026 (((e.label) \u003d (se.eventlabel)) and (exists1 pt in set (trom.porttypes) \u0026 ((pt \u003d (e.porttype)) and (exists1 p in set (elems (pt.portlist)) \u0026 ((p.label) \u003d (se.portlabel))))))))) in let accepted_by_subsystem: (SimulationEvent * Subsystem +\u003e bool)\n\taccepted_by_subsystem(se, subsys) \u003d\u003d\n(exists1 s in set (subsys.includes) \u0026 (((accepted_by_trom(se, s) and (not accepted_by_subsystem(se, s))) or ((not accepted_by_trom(se, s)) and accepted_by_subsystem(se, s))) and (forall s2 in set {su | su:Subsystem \u0026 ((su in set (subsys.includes)) and (su \u003c\u003e s))} \u0026 ((not accepted_by_trom(se, s2)) and (not accepted_by_subsystem(se, s2)))))) in (forall se in set (elems simulationeventlist) \u0026 ((accepted_by_trom(se, subsystem) and (not accepted_by_subsystem(se, subsystem))) or ((not accepted_by_trom(se, subsystem)) and accepted_by_subsystem(se, subsystem)))) and let exists_lsltrait: (Subsystem +\u003e bool)\n\texists_lsltrait(subsys) \u003d\u003d\n((forall trom in set (subsys.troms) \u0026 (forall tr in set (trom.lsltraits) \u0026 (exists traitdef in set lsllibrary \u0026 ((traitdef.label) \u003d (tr.traitlabel))))) and (forall s in set (subsys.includes) \u0026 exists_lsltrait(s))) in exists_lsltrait(subsystem))))))))","state invariant holds obligation:(forall se:SimulationEvent, oldstate:System \u0026 (((se.occurtime) \u003d CLOCK) \u003d\u003e let mk_System(subsystem, simulationeventlist, lsllibrary, clock) \u003d System in (let contains_trom: (Subsystem +\u003e bool)\n\tcontains_trom(subsys) \u003d\u003d\n(((subsys.troms) \u003c\u003e {}) or (exists1 s in set (subsys.includes) \u0026 contains_trom(s))) in contains_trom(subsystem) and (let contains_portlink: (Subsystem +\u003e bool)\n\tcontains_portlink(subsys) \u003d\u003d\n(((subsys.portlinks) \u003c\u003e {}) or (exists1 s in set (subsys.includes) \u0026 contains_portlink(s))) in contains_portlink(subsystem) and ((forall i, j in set (inds simulationeventlist) \u0026 (((i \u003d j) and (simulationeventlist(i) \u003d simulationeventlist(j))) or (((i \u003c j) and ((simulationeventlist(i).occurtime) \u003c\u003d (simulationeventlist(j).occurtime))) or ((i \u003e j) and ((simulationeventlist(i).occurtime) \u003e\u003d (simulationeventlist(j).occurtime)))))) and ((forall se1, se2 in set (elems simulationeventlist) \u0026 ((((se1.occurtime) \u003d (se2.occurtime)) and ((se1.tromlabel) \u003c\u003e (se2.tromlabel))) or ((se1.occurtime) \u003c\u003e (se2.occurtime)))) and (let accepted_by_trom: (SimulationEvent * Subsystem +\u003e bool)\n\taccepted_by_trom(se, subsys) \u003d\u003d\n(exists1 trom in set (subsys.troms) \u0026 (((trom.label) \u003d (se.tromlabel)) and (exists1 e in set (trom.events) \u0026 (((e.label) \u003d (se.eventlabel)) and (exists1 pt in set (trom.porttypes) \u0026 ((pt \u003d (e.porttype)) and (exists1 p in set (elems (pt.portlist)) \u0026 ((p.label) \u003d (se.portlabel))))))))) in let accepted_by_subsystem: (SimulationEvent * Subsystem +\u003e bool)\n\taccepted_by_subsystem(se, subsys) \u003d\u003d\n(exists1 s in set (subsys.includes) \u0026 (((accepted_by_trom(se, s) and (not accepted_by_subsystem(se, s))) or ((not accepted_by_trom(se, s)) and accepted_by_subsystem(se, s))) and (forall s2 in set {su | su:Subsystem \u0026 ((su in set (subsys.includes)) and (su \u003c\u003e s))} \u0026 ((not accepted_by_trom(se, s2)) and (not accepted_by_subsystem(se, s2)))))) in (forall se in set (elems simulationeventlist) \u0026 ((accepted_by_trom(se, subsystem) and (not accepted_by_subsystem(se, subsystem))) or ((not accepted_by_trom(se, subsystem)) and accepted_by_subsystem(se, subsystem)))) and let exists_lsltrait: (Subsystem +\u003e bool)\n\texists_lsltrait(subsys) \u003d\u003d\n((forall trom in set (subsys.troms) \u0026 (forall tr in set (trom.lsltraits) \u0026 (exists traitdef in set lsllibrary \u0026 ((traitdef.label) \u003d (tr.traitlabel))))) and (forall s in set (subsys.includes) \u0026 exists_lsltrait(s))) in exists_lsltrait(subsystem))))))))","legal function application obligation:(forall se:SimulationEvent, oldstate:System \u0026 (((se.occurtime) \u003d CLOCK) \u003d\u003e pre_get_transition_spec(trom, se)))","type compatibility obligation:(forall se:SimulationEvent, oldstate:System \u0026 (((se.occurtime) \u003d CLOCK) \u003d\u003e (inv_Trom(trom) and is_(trom, Trom))))","operation call obligation:(forall se:SimulationEvent, oldstate:System \u0026 (((se.occurtime) \u003d CLOCK) \u003d\u003e ((get_trom_object((se.tromlabel), SUBSYSTEM) \u003d nil) or ((get_trom_object((se.tromlabel), SUBSYSTEM).postcondition) \u003d false))))","operation call obligation:(forall se:SimulationEvent, oldstate:System \u0026 (((se.occurtime) \u003d CLOCK) \u003d\u003e (((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).triggeredtransition) \u003d false) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).tromcurrentstate) \u003d nil) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).assignmentvector) \u003d nil) and (((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).reactionshistory) \u003d {})))) \u003d\u003e (get_trom_object((se.tromlabel), SUBSYSTEM) \u003c\u003e nil))))","operation call obligation:(forall se:SimulationEvent, oldstate:System \u0026 (((se.occurtime) \u003d CLOCK) \u003d\u003e (((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).triggeredtransition) \u003d false) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).tromcurrentstate) \u003d nil) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).assignmentvector) \u003d nil) and (((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).reactionshistory) \u003d {})))) \u003d\u003e ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).assignmentvector) \u003d (get_trom_object((se.tromlabel), SUBSYSTEM).assignmentvector)) \u003d\u003e ((get_trom_object((se.tromlabel), SUBSYSTEM) \u003d nil) or ((get_trom_object((se.tromlabel), SUBSYSTEM).postcondition) \u003d false))))))","operation call obligation:(forall se:SimulationEvent, oldstate:System \u0026 (((se.occurtime) \u003d CLOCK) \u003d\u003e (((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).triggeredtransition) \u003d false) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).tromcurrentstate) \u003d nil) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).assignmentvector) \u003d nil) and (((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).reactionshistory) \u003d {})))) \u003d\u003e ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).assignmentvector) \u003d (get_trom_object((se.tromlabel), SUBSYSTEM).assignmentvector)) \u003d\u003e (((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).triggeredtransition) \u003d false) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).tromcurrentstate) \u003d nil) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).assignmentvector) \u003d nil) and (((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).reactionshistory) \u003d {})))) \u003d\u003e ((get_trom_object((se.tromlabel), SUBSYSTEM).postcondition) \u003d true))))))","operation call obligation:(forall se:SimulationEvent, oldstate:System \u0026 (((se.occurtime) \u003d CLOCK) \u003d\u003e (((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).triggeredtransition) \u003d false) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).tromcurrentstate) \u003d nil) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).assignmentvector) \u003d nil) and (((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).reactionshistory) \u003d {})))) \u003d\u003e ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).assignmentvector) \u003d (get_trom_object((se.tromlabel), SUBSYSTEM).assignmentvector)) \u003d\u003e (((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).triggeredtransition) \u003d false) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).tromcurrentstate) \u003d nil) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).assignmentvector) \u003d nil) and (((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).reactionshistory) \u003d {})))) \u003d\u003e (((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).triggeredtransition) \u003d true) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).tromcurrentstate) \u003d (get_trom_object((se.tromlabel), SUBSYSTEM).currentstate)) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).assignmentvector) \u003d (get_trom_object((se.tromlabel), SUBSYSTEM).assignmentvector)) and (((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).reactionshistory) \u003d {})))) \u003d\u003e ((get_trom_object((se.tromlabel), SUBSYSTEM).postcondition) \u003d true)))))))","operation call obligation:(forall se:SimulationEvent, oldstate:System \u0026 (((se.occurtime) \u003d CLOCK) \u003d\u003e (((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).triggeredtransition) \u003d false) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).tromcurrentstate) \u003d nil) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).assignmentvector) \u003d nil) and (((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).reactionshistory) \u003d {})))) \u003d\u003e ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).assignmentvector) \u003d (get_trom_object((se.tromlabel), SUBSYSTEM).assignmentvector)) \u003d\u003e (((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).triggeredtransition) \u003d false) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).tromcurrentstate) \u003d nil) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).assignmentvector) \u003d nil) and (((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).reactionshistory) \u003d {})))) \u003d\u003e (((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).triggeredtransition) \u003d true) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).tromcurrentstate) \u003d (get_trom_object((se.tromlabel), SUBSYSTEM).currentstate)) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).assignmentvector) \u003d (get_trom_object((se.tromlabel), SUBSYSTEM).assignmentvector)) and (((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).reactionshistory) \u003d {})))) \u003d\u003e ((((((get_trom_object((se.tromlabel), SUBSYSTEM).destinstate).type) \u003d \u003cSIMPLE\u003e) and ((get_trom_object((se.tromlabel), SUBSYSTEM).currentstate) \u003d (get_trom_object((se.tromlabel), SUBSYSTEM).destinstate))) or ((((get_trom_object((se.tromlabel), SUBSYSTEM).destinstate).type) \u003d \u003cCOMPLEX\u003e) and ((get_trom_object((se.tromlabel), SUBSYSTEM).currentstate) \u003d get_entry_state((ts.destinstate))))) \u003d\u003e ((get_trom_object((se.tromlabel), SUBSYSTEM).occurtime) \u003d CLOCK))))))))","operation call obligation:(forall se:SimulationEvent, oldstate:System \u0026 (((se.occurtime) \u003d CLOCK) \u003d\u003e (((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).triggeredtransition) \u003d false) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).tromcurrentstate) \u003d nil) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).assignmentvector) \u003d nil) and (((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).reactionshistory) \u003d {})))) \u003d\u003e ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).assignmentvector) \u003d (get_trom_object((se.tromlabel), SUBSYSTEM).assignmentvector)) \u003d\u003e (((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).triggeredtransition) \u003d false) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).tromcurrentstate) \u003d nil) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).assignmentvector) \u003d nil) and (((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).reactionshistory) \u003d {})))) \u003d\u003e (((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).triggeredtransition) \u003d true) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).tromcurrentstate) \u003d (get_trom_object((se.tromlabel), SUBSYSTEM).currentstate)) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).assignmentvector) \u003d (get_trom_object((se.tromlabel), SUBSYSTEM).assignmentvector)) and (((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).reactionshistory) \u003d {})))) \u003d\u003e ((((((get_trom_object((se.tromlabel), SUBSYSTEM).destinstate).type) \u003d \u003cSIMPLE\u003e) and ((get_trom_object((se.tromlabel), SUBSYSTEM).currentstate) \u003d (get_trom_object((se.tromlabel), SUBSYSTEM).destinstate))) or ((((get_trom_object((se.tromlabel), SUBSYSTEM).destinstate).type) \u003d \u003cCOMPLEX\u003e) and ((get_trom_object((se.tromlabel), SUBSYSTEM).currentstate) \u003d get_entry_state((ts.destinstate))))) \u003d\u003e ((CLOCK \u003d CLOCK~) \u003d\u003e ((get_trom_object((se.tromlabel), SUBSYSTEM) in set (elems SIMULATIONEVENTLIST)) and ((get_trom_object((se.tromlabel), SUBSYSTEM).tromlabel) \u003d (get_trom_object((se.tromlabel), SUBSYSTEM).label)))))))))))","operation establishes postcondition obligation:(forall se:SimulationEvent, oldstate:System \u0026 (((se.occurtime) \u003d CLOCK) \u003d\u003e (((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).triggeredtransition) \u003d false) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).tromcurrentstate) \u003d nil) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).assignmentvector) \u003d nil) and (((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).reactionshistory) \u003d {})))) \u003d\u003e ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).assignmentvector) \u003d (get_trom_object((se.tromlabel), SUBSYSTEM).assignmentvector)) \u003d\u003e (((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).triggeredtransition) \u003d false) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).tromcurrentstate) \u003d nil) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).assignmentvector) \u003d nil) and (((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).reactionshistory) \u003d {})))) \u003d\u003e (((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).triggeredtransition) \u003d true) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).tromcurrentstate) \u003d (get_trom_object((se.tromlabel), SUBSYSTEM).currentstate)) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).assignmentvector) \u003d (get_trom_object((se.tromlabel), SUBSYSTEM).assignmentvector)) and (((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).reactionshistory) \u003d {})))) \u003d\u003e ((((((get_trom_object((se.tromlabel), SUBSYSTEM).destinstate).type) \u003d \u003cSIMPLE\u003e) and ((get_trom_object((se.tromlabel), SUBSYSTEM).currentstate) \u003d (get_trom_object((se.tromlabel), SUBSYSTEM).destinstate))) or ((((get_trom_object((se.tromlabel), SUBSYSTEM).destinstate).type) \u003d \u003cCOMPLEX\u003e) and ((get_trom_object((se.tromlabel), SUBSYSTEM).currentstate) \u003d get_entry_state((ts.destinstate))))) \u003d\u003e ((CLOCK \u003d CLOCK~) \u003d\u003e (let event:[Event] \u003d get_unconstrained_internal_event(trom) in (((event \u003c\u003e nil) and let j:nat1 be st (j \u003d get_simevent_index(se, SIMULATIONEVENTLIST)) in let se2:SimulationEvent be st (se2 \u003d mk_SimulationEvent((event.label), (trom.label), \"NULLPORT\", CLOCK, nil)) in (SIMULATIONEVENTLIST \u003d (([SIMULATIONEVENTLIST~(i) | i in set (inds SIMULATIONEVENTLIST~) \u0026 (i \u003c\u003d j)] ^ [se2]) ^ [SIMULATIONEVENTLIST~(i) | i in set (inds SIMULATIONEVENTLIST~) \u0026 (i \u003e j)]))) or (event \u003d nil)) \u003d\u003e (CLOCK \u003d CLOCK~))))))))))","operation call obligation:(forall trom:Trom, se:SimulationEvent, ts:TransitionSpec, oldstate:System \u0026 (((se.occurtime) \u003d CLOCK) \u003d\u003e ((((trom.constrainedevent).label) \u003d (trom.eventlabel)) and ((trom in set (trom.reactionwindows)) and (((trom.occurtime) \u003e\u003d (trom.lowertimebound)) and ((trom.occurtime) \u003c\u003d (trom.uppertimebound)))))))","operation call obligation:(forall trom:Trom, se:SimulationEvent, ts:TransitionSpec, oldstate:System \u0026 (((se.occurtime) \u003d CLOCK) \u003d\u003e ((exists rh in set ((se.eventhistory).reactionshistory) \u0026 (((rh.timeconstraint) \u003d trom) and (((rh.reactionwindow) \u003d trom) and ((rh.reaction) \u003d \u003cFIRED\u003e)))) \u003d\u003e ((((trom.constrainedevent).label) \u003d (trom.eventlabel)) and ((trom in set (trom.reactionwindows)) and (((trom.occurtime) \u003e\u003d (trom.lowertimebound)) and ((trom.occurtime) \u003c\u003d (trom.uppertimebound))))))))","operation call obligation:(forall trom:Trom, se:SimulationEvent, ts:TransitionSpec, oldstate:System \u0026 (((se.occurtime) \u003d CLOCK) \u003d\u003e ((exists rh in set ((se.eventhistory).reactionshistory) \u0026 (((rh.timeconstraint) \u003d trom) and (((rh.reactionwindow) \u003d trom) and ((rh.reaction) \u003d \u003cFIRED\u003e)))) \u003d\u003e ((trom not in set (trom.reactionwindows)) \u003d\u003e (((trom.currentstate) in set (trom.disablingstates)) and (trom in set (trom.reactionwindows)))))))","operation call obligation:(forall trom:Trom, se:SimulationEvent, ts:TransitionSpec, oldstate:System \u0026 (((se.occurtime) \u003d CLOCK) \u003d\u003e ((exists rh in set ((se.eventhistory).reactionshistory) \u0026 (((rh.timeconstraint) \u003d trom) and (((rh.reactionwindow) \u003d trom) and ((rh.reaction) \u003d \u003cFIRED\u003e)))) \u003d\u003e ((trom not in set (trom.reactionwindows)) \u003d\u003e ((exists rh in set ((se.eventhistory).reactionshistory) \u0026 (((rh.timeconstraint) \u003d trom) and (((rh.reactionwindow) \u003d trom) and ((rh.reaction) \u003d \u003cDISABLED\u003e)))) \u003d\u003e (((trom.currentstate) in set (trom.disablingstates)) and (trom in set (trom.reactionwindows))))))))","operation call obligation:(forall trom:Trom, se:SimulationEvent, ts:TransitionSpec, oldstate:System \u0026 (((se.occurtime) \u003d CLOCK) \u003d\u003e ((exists rh in set ((se.eventhistory).reactionshistory) \u0026 (((rh.timeconstraint) \u003d trom) and (((rh.reactionwindow) \u003d trom) and ((rh.reaction) \u003d \u003cFIRED\u003e)))) \u003d\u003e ((trom not in set (trom.reactionwindows)) \u003d\u003e ((exists rh in set ((se.eventhistory).reactionshistory) \u0026 (((rh.timeconstraint) \u003d trom) and (((rh.reactionwindow) \u003d trom) and ((rh.reaction) \u003d \u003cDISABLED\u003e)))) \u003d\u003e (((trom not in set (trom.reactionwindows)) and let se2:SimulationEvent be st (se2 \u003d get_enabled_simevent(trom, tc)) in (((((tc.constrainedevent).type) \u003d \u003cINTERNAL\u003e) and (SIMULATIONEVENTLIST \u003d [SIMULATIONEVENTLIST~(i) | i in set (inds SIMULATIONEVENTLIST~) \u0026 (SIMULATIONEVENTLIST~(i) \u003c\u003e se2)])) or ((((tc.constrainedevent).type) \u003d \u003cOUTPUT\u003e) and let tromporttuple:[TromPortTuple] be st (tromporttuple \u003d get_linked_tromport_tuple(mk_TromPortTuple((se2.tromlabel), (se2.portlabel)), SUBSYSTEM)) in let se3:SimulationEvent be st (se3 \u003d get_enabled_simevent_synch(tromporttuple, tc)) in (SIMULATIONEVENTLIST \u003d [SIMULATIONEVENTLIST~(i) | i in set (inds SIMULATIONEVENTLIST~) \u0026 ((SIMULATIONEVENTLIST~(i) \u003c\u003e se2) and (SIMULATIONEVENTLIST~(i) \u003c\u003e se3))])))) \u003d\u003e ((trom.label) \u003d ((trom.transition).label))))))))","operation call obligation:(forall trom:Trom, se:SimulationEvent, ts:TransitionSpec, oldstate:System \u0026 (((se.occurtime) \u003d CLOCK) \u003d\u003e ((exists rh in set ((se.eventhistory).reactionshistory) \u0026 (((rh.timeconstraint) \u003d trom) and (((rh.reactionwindow) \u003d trom) and ((rh.reaction) \u003d \u003cFIRED\u003e)))) \u003d\u003e ((trom not in set (trom.reactionwindows)) \u003d\u003e ((exists rh in set ((se.eventhistory).reactionshistory) \u0026 (((rh.timeconstraint) \u003d trom) and (((rh.reactionwindow) \u003d trom) and ((rh.reaction) \u003d \u003cDISABLED\u003e)))) \u003d\u003e (((trom not in set (trom.reactionwindows)) and let se2:SimulationEvent be st (se2 \u003d get_enabled_simevent(trom, tc)) in (((((tc.constrainedevent).type) \u003d \u003cINTERNAL\u003e) and (SIMULATIONEVENTLIST \u003d [SIMULATIONEVENTLIST~(i) | i in set (inds SIMULATIONEVENTLIST~) \u0026 (SIMULATIONEVENTLIST~(i) \u003c\u003e se2)])) or ((((tc.constrainedevent).type) \u003d \u003cOUTPUT\u003e) and let tromporttuple:[TromPortTuple] be st (tromporttuple \u003d get_linked_tromport_tuple(mk_TromPortTuple((se2.tromlabel), (se2.portlabel)), SUBSYSTEM)) in let se3:SimulationEvent be st (se3 \u003d get_enabled_simevent_synch(tromporttuple, tc)) in (SIMULATIONEVENTLIST \u003d [SIMULATIONEVENTLIST~(i) | i in set (inds SIMULATIONEVENTLIST~) \u0026 ((SIMULATIONEVENTLIST~(i) \u003c\u003e se2) and (SIMULATIONEVENTLIST~(i) \u003c\u003e se3))])))) \u003d\u003e (let rw:ReactionWindow be st (rw \u003d mk_ReactionWindow((((tc.timebounds).lowertimebound) + CLOCK), (((tc.timebounds).uppertimebound) + CLOCK))) in (exists rh in set ((se.eventhistory).reactionshistory) \u0026 (((rh.timeconstraint) \u003d tc) and (((rh.reactionwindow) \u003d rw) and ((rh.reaction) \u003d \u003cENABLED\u003e)))) \u003d\u003e ((trom.label) \u003d ((trom.transition).label)))))))))","operation establishes postcondition obligation:(forall trom:Trom, se:SimulationEvent, ts:TransitionSpec, oldstate:System \u0026 (((se.occurtime) \u003d CLOCK) \u003d\u003e ((exists rh in set ((se.eventhistory).reactionshistory) \u0026 (((rh.timeconstraint) \u003d trom) and (((rh.reactionwindow) \u003d trom) and ((rh.reaction) \u003d \u003cFIRED\u003e)))) \u003d\u003e ((trom not in set (trom.reactionwindows)) \u003d\u003e ((exists rh in set ((se.eventhistory).reactionshistory) \u0026 (((rh.timeconstraint) \u003d trom) and (((rh.reactionwindow) \u003d trom) and ((rh.reaction) \u003d \u003cDISABLED\u003e)))) \u003d\u003e (((trom not in set (trom.reactionwindows)) and let se2:SimulationEvent be st (se2 \u003d get_enabled_simevent(trom, tc)) in (((((tc.constrainedevent).type) \u003d \u003cINTERNAL\u003e) and (SIMULATIONEVENTLIST \u003d [SIMULATIONEVENTLIST~(i) | i in set (inds SIMULATIONEVENTLIST~) \u0026 (SIMULATIONEVENTLIST~(i) \u003c\u003e se2)])) or ((((tc.constrainedevent).type) \u003d \u003cOUTPUT\u003e) and let tromporttuple:[TromPortTuple] be st (tromporttuple \u003d get_linked_tromport_tuple(mk_TromPortTuple((se2.tromlabel), (se2.portlabel)), SUBSYSTEM)) in let se3:SimulationEvent be st (se3 \u003d get_enabled_simevent_synch(tromporttuple, tc)) in (SIMULATIONEVENTLIST \u003d [SIMULATIONEVENTLIST~(i) | i in set (inds SIMULATIONEVENTLIST~) \u0026 ((SIMULATIONEVENTLIST~(i) \u003c\u003e se2) and (SIMULATIONEVENTLIST~(i) \u003c\u003e se3))])))) \u003d\u003e (let rw:ReactionWindow be st (rw \u003d mk_ReactionWindow((((tc.timebounds).lowertimebound) + CLOCK), (((tc.timebounds).uppertimebound) + CLOCK))) in (exists rh in set ((se.eventhistory).reactionshistory) \u0026 (((rh.timeconstraint) \u003d tc) and (((rh.reactionwindow) \u003d rw) and ((rh.reaction) \u003d \u003cENABLED\u003e)))) \u003d\u003e (let rw:ReactionWindow be st (rw \u003d mk_ReactionWindow((((tc.timebounds).lowertimebound) + CLOCK), (((tc.timebounds).uppertimebound) + CLOCK))) in let port:Port be st (port \u003d get_lru_port((((tc.constrainedevent).porttype).portlist))) in let occurtime:nat be st (occurtime \u003d get_random_time_within_rw(rw)) in let se2:SimulationEvent be st (se2 \u003d mk_SimulationEvent(((tc.constrainedevent).label), (trom.label), (port.label), occurtime, nil)) in ((rw in set (tc.reactionwindows)) and ((se2 in set (elems SIMULATIONEVENTLIST)) and (((((tc.constrainedevent).type) \u003d \u003cOUTPUT\u003e) and let tromporttuple:[TromPortTuple] be st (tromporttuple \u003d get_linked_tromport_tuple(mk_TromPortTuple((se2.tromlabel), (se2.portlabel)), SUBSYSTEM)) in (((tromporttuple \u003c\u003e nil) and let se3:SimulationEvent be st (se3 \u003d mk_SimulationEvent((se2.eventlabel), (tromporttuple.tromlabel), (tromporttuple.portlabel), (se2.occurtime), nil)) in (se3 in set (elems SIMULATIONEVENTLIST))) or (tromporttuple \u003d nil))) or (((tc.constrainedevent).type) \u003d \u003cINTERNAL\u003e)))) \u003d\u003e (CLOCK \u003d CLOCK~)))))))))","legal function application obligation:(((ts.postcondition) \u003d true) \u003d\u003e ((not ((((trom.destinstate).type) \u003d \u003cSIMPLE\u003e) and ((trom.currentstate) \u003d (trom.destinstate)))) \u003d\u003e ((((trom.destinstate).type) \u003d \u003cCOMPLEX\u003e) \u003d\u003e pre_get_entry_state((ts.destinstate)))))","operation postcondition satisfiable obligation:(forall trom:Trom, se:SimulationEvent, ts:TransitionSpec, oldstate:System \u0026 (pre_update_trom_current_state(trom, se, ts, oldstate) \u003d\u003e (exists newstate:System \u0026 post_update_trom_current_state(trom, se, ts, oldstate, newstate))))","operation postcondition satisfiable obligation:(forall trom:Trom, se:SimulationEvent, ts:[TransitionSpec], oldstate:System \u0026 (pre_update_history_assignment_vector(trom, se, ts, oldstate) \u003d\u003e (exists newstate:System \u0026 post_update_history_assignment_vector(trom, se, ts, oldstate, newstate))))","operation postcondition satisfiable obligation:(forall trom:Trom, se:SimulationEvent, ts:[TransitionSpec], oldstate:System \u0026 (pre_update_history_notransition(trom, se, ts, oldstate) \u003d\u003e (exists newstate:System \u0026 post_update_history_notransition(trom, se, ts, oldstate, newstate))))","operation postcondition satisfiable obligation:(forall trom:Trom, se:SimulationEvent, ts:TransitionSpec, oldstate:System \u0026 (pre_update_history_transition(trom, se, ts, oldstate) \u003d\u003e (exists newstate:System \u0026 post_update_history_transition(trom, se, ts, oldstate, newstate))))","operation postcondition satisfiable obligation:(forall trom:Trom, se:SimulationEvent, tc:TimeConstraint, rw:ReactionWindow, oldstate:System \u0026 (pre_update_history_fire_reaction(trom, se, tc, rw, oldstate) \u003d\u003e (exists newstate:System \u0026 post_update_history_fire_reaction(trom, se, tc, rw, oldstate, newstate))))","operation postcondition satisfiable obligation:(forall trom:Trom, se:SimulationEvent, tc:TimeConstraint, rw:ReactionWindow, oldstate:System \u0026 (pre_update_history_disable_reaction(trom, se, tc, rw, oldstate) \u003d\u003e (exists newstate:System \u0026 post_update_history_disable_reaction(trom, se, tc, rw, oldstate, newstate))))","let be st existence obligation:(((ts.label) \u003d ((tc.transition).label)) \u003d\u003e (exists rw:ReactionWindow \u0026 (rw \u003d mk_ReactionWindow((((tc.timebounds).lowertimebound) + CLOCK), (((tc.timebounds).uppertimebound) + CLOCK)))))","type compatibility obligation:(((ts.label) \u003d ((tc.transition).label)) \u003d\u003e (forall rw:ReactionWindow \u0026 inv_ReactionWindow(mk_ReactionWindow((((tc.timebounds).lowertimebound) + CLOCK), (((tc.timebounds).uppertimebound) + CLOCK)))))","operation postcondition satisfiable obligation:(forall trom:Trom, se:SimulationEvent, tc:TimeConstraint, ts:TransitionSpec, oldstate:System \u0026 (pre_update_history_enable_reaction(trom, se, tc, ts, oldstate) \u003d\u003e (exists newstate:System \u0026 post_update_history_enable_reaction(trom, se, tc, ts, oldstate, newstate))))","operation postcondition satisfiable obligation:(forall trom:Trom, se:SimulationEvent, tc:TimeConstraint, rw:ReactionWindow, oldstate:System \u0026 (pre_fire_reaction(trom, se, tc, rw, oldstate) \u003d\u003e (exists newstate:System \u0026 post_fire_reaction(trom, se, tc, rw, oldstate, newstate))))","let be st existence obligation:((((trom.currentstate) in set (tc.disablingstates)) and (rw in set (tc.reactionwindows))) \u003d\u003e ((trom not in set (trom.reactionwindows)) \u003d\u003e (exists se2:SimulationEvent \u0026 (se2 \u003d get_enabled_simevent(trom, tc)))))","legal sequence application obligation:((((trom.currentstate) in set (tc.disablingstates)) and (rw in set (tc.reactionwindows))) \u003d\u003e ((trom not in set (trom.reactionwindows)) \u003d\u003e (forall se2:SimulationEvent \u0026 ((se2 \u003d get_enabled_simevent(trom, tc)) \u003d\u003e ((((tc.constrainedevent).type) \u003d \u003cINTERNAL\u003e) \u003d\u003e (forall i in set (inds SIMULATIONEVENTLIST~) \u0026 ((SIMULATIONEVENTLIST~(i) \u003c\u003e se2) \u003d\u003e (i in set (inds SIMULATIONEVENTLIST~)))))))))","legal sequence application obligation:((((trom.currentstate) in set (tc.disablingstates)) and (rw in set (tc.reactionwindows))) \u003d\u003e ((trom not in set (trom.reactionwindows)) \u003d\u003e (forall se2:SimulationEvent \u0026 ((se2 \u003d get_enabled_simevent(trom, tc)) \u003d\u003e ((((tc.constrainedevent).type) \u003d \u003cINTERNAL\u003e) \u003d\u003e (forall i in set (inds SIMULATIONEVENTLIST~) \u0026 (i in set (inds SIMULATIONEVENTLIST~))))))))","let be st existence obligation:((((trom.currentstate) in set (tc.disablingstates)) and (rw in set (tc.reactionwindows))) \u003d\u003e ((trom not in set (trom.reactionwindows)) \u003d\u003e (forall se2:SimulationEvent \u0026 ((se2 \u003d get_enabled_simevent(trom, tc)) \u003d\u003e ((not ((((tc.constrainedevent).type) \u003d \u003cINTERNAL\u003e) and (SIMULATIONEVENTLIST \u003d [SIMULATIONEVENTLIST~(i) | i in set (inds SIMULATIONEVENTLIST~) \u0026 (SIMULATIONEVENTLIST~(i) \u003c\u003e se2)]))) \u003d\u003e ((((tc.constrainedevent).type) \u003d \u003cOUTPUT\u003e) \u003d\u003e (exists tromporttuple:[TromPortTuple] \u0026 (tromporttuple \u003d get_linked_tromport_tuple(mk_TromPortTuple((se2.tromlabel), (se2.portlabel)), SUBSYSTEM)))))))))","let be st existence obligation:((((trom.currentstate) in set (tc.disablingstates)) and (rw in set (tc.reactionwindows))) \u003d\u003e ((trom not in set (trom.reactionwindows)) \u003d\u003e (forall se2:SimulationEvent \u0026 ((se2 \u003d get_enabled_simevent(trom, tc)) \u003d\u003e ((not ((((tc.constrainedevent).type) \u003d \u003cINTERNAL\u003e) and (SIMULATIONEVENTLIST \u003d [SIMULATIONEVENTLIST~(i) | i in set (inds SIMULATIONEVENTLIST~) \u0026 (SIMULATIONEVENTLIST~(i) \u003c\u003e se2)]))) \u003d\u003e ((((tc.constrainedevent).type) \u003d \u003cOUTPUT\u003e) \u003d\u003e (forall tromporttuple:[TromPortTuple] \u0026 ((tromporttuple \u003d get_linked_tromport_tuple(mk_TromPortTuple((se2.tromlabel), (se2.portlabel)), SUBSYSTEM)) \u003d\u003e (exists se3:SimulationEvent \u0026 (se3 \u003d get_enabled_simevent_synch(tromporttuple, tc)))))))))))","legal sequence application obligation:((((trom.currentstate) in set (tc.disablingstates)) and (rw in set (tc.reactionwindows))) \u003d\u003e ((trom not in set (trom.reactionwindows)) \u003d\u003e (forall se2:SimulationEvent \u0026 ((se2 \u003d get_enabled_simevent(trom, tc)) \u003d\u003e ((not ((((tc.constrainedevent).type) \u003d \u003cINTERNAL\u003e) and (SIMULATIONEVENTLIST \u003d [SIMULATIONEVENTLIST~(i) | i in set (inds SIMULATIONEVENTLIST~) \u0026 (SIMULATIONEVENTLIST~(i) \u003c\u003e se2)]))) \u003d\u003e ((((tc.constrainedevent).type) \u003d \u003cOUTPUT\u003e) \u003d\u003e (forall tromporttuple:[TromPortTuple] \u0026 ((tromporttuple \u003d get_linked_tromport_tuple(mk_TromPortTuple((se2.tromlabel), (se2.portlabel)), SUBSYSTEM)) \u003d\u003e (forall se3:SimulationEvent \u0026 ((se3 \u003d get_enabled_simevent_synch(tromporttuple, tc)) \u003d\u003e (forall i in set (inds SIMULATIONEVENTLIST~) \u0026 (((SIMULATIONEVENTLIST~(i) \u003c\u003e se2) and (SIMULATIONEVENTLIST~(i) \u003c\u003e se3)) \u003d\u003e (i in set (inds SIMULATIONEVENTLIST~))))))))))))))","legal sequence application obligation:((((trom.currentstate) in set (tc.disablingstates)) and (rw in set (tc.reactionwindows))) \u003d\u003e ((trom not in set (trom.reactionwindows)) \u003d\u003e (forall se2:SimulationEvent \u0026 ((se2 \u003d get_enabled_simevent(trom, tc)) \u003d\u003e ((not ((((tc.constrainedevent).type) \u003d \u003cINTERNAL\u003e) and (SIMULATIONEVENTLIST \u003d [SIMULATIONEVENTLIST~(i) | i in set (inds SIMULATIONEVENTLIST~) \u0026 (SIMULATIONEVENTLIST~(i) \u003c\u003e se2)]))) \u003d\u003e ((((tc.constrainedevent).type) \u003d \u003cOUTPUT\u003e) \u003d\u003e (forall tromporttuple:[TromPortTuple] \u0026 ((tromporttuple \u003d get_linked_tromport_tuple(mk_TromPortTuple((se2.tromlabel), (se2.portlabel)), SUBSYSTEM)) \u003d\u003e (forall se3:SimulationEvent \u0026 ((se3 \u003d get_enabled_simevent_synch(tromporttuple, tc)) \u003d\u003e (forall i in set (inds SIMULATIONEVENTLIST~) \u0026 (i in set (inds SIMULATIONEVENTLIST~)))))))))))))","legal sequence application obligation:((((trom.currentstate) in set (tc.disablingstates)) and (rw in set (tc.reactionwindows))) \u003d\u003e ((trom not in set (trom.reactionwindows)) \u003d\u003e (forall se2:SimulationEvent \u0026 ((se2 \u003d get_enabled_simevent(trom, tc)) \u003d\u003e ((not ((((tc.constrainedevent).type) \u003d \u003cINTERNAL\u003e) and (SIMULATIONEVENTLIST \u003d [SIMULATIONEVENTLIST~(i) | i in set (inds SIMULATIONEVENTLIST~) \u0026 (SIMULATIONEVENTLIST~(i) \u003c\u003e se2)]))) \u003d\u003e ((((tc.constrainedevent).type) \u003d \u003cOUTPUT\u003e) \u003d\u003e (forall tromporttuple:[TromPortTuple] \u0026 ((tromporttuple \u003d get_linked_tromport_tuple(mk_TromPortTuple((se2.tromlabel), (se2.portlabel)), SUBSYSTEM)) \u003d\u003e (forall se3:SimulationEvent \u0026 ((se3 \u003d get_enabled_simevent_synch(tromporttuple, tc)) \u003d\u003e (forall i in set (inds SIMULATIONEVENTLIST~) \u0026 ((SIMULATIONEVENTLIST~(i) \u003c\u003e se2) \u003d\u003e (i in set (inds SIMULATIONEVENTLIST~))))))))))))))","operation postcondition satisfiable obligation:(forall trom:Trom, se:SimulationEvent, tc:TimeConstraint, rw:ReactionWindow, oldstate:System \u0026 (pre_disable_reaction(trom, se, tc, rw, oldstate) \u003d\u003e (exists newstate:System \u0026 post_disable_reaction(trom, se, tc, rw, oldstate, newstate))))","let be st existence obligation:(((ts.label) \u003d ((tc.transition).label)) \u003d\u003e (exists rw:ReactionWindow \u0026 (rw \u003d mk_ReactionWindow((((tc.timebounds).lowertimebound) + CLOCK), (((tc.timebounds).uppertimebound) + CLOCK)))))","type compatibility obligation:(((ts.label) \u003d ((tc.transition).label)) \u003d\u003e (forall rw:ReactionWindow \u0026 inv_ReactionWindow(mk_ReactionWindow((((tc.timebounds).lowertimebound) + CLOCK), (((tc.timebounds).uppertimebound) + CLOCK)))))","let be st existence obligation:(((ts.label) \u003d ((tc.transition).label)) \u003d\u003e (forall rw:ReactionWindow \u0026 ((rw \u003d mk_ReactionWindow((((tc.timebounds).lowertimebound) + CLOCK), (((tc.timebounds).uppertimebound) + CLOCK))) \u003d\u003e (exists port:Port \u0026 (port \u003d get_lru_port((((tc.constrainedevent).porttype).portlist)))))))","legal function application obligation:(((ts.label) \u003d ((tc.transition).label)) \u003d\u003e (forall rw:ReactionWindow \u0026 ((rw \u003d mk_ReactionWindow((((tc.timebounds).lowertimebound) + CLOCK), (((tc.timebounds).uppertimebound) + CLOCK))) \u003d\u003e (forall port:Port \u0026 pre_get_lru_port((((tc.constrainedevent).porttype).portlist))))))","let be st existence obligation:(((ts.label) \u003d ((tc.transition).label)) \u003d\u003e (forall rw:ReactionWindow \u0026 ((rw \u003d mk_ReactionWindow((((tc.timebounds).lowertimebound) + CLOCK), (((tc.timebounds).uppertimebound) + CLOCK))) \u003d\u003e (forall port:Port \u0026 ((port \u003d get_lru_port((((tc.constrainedevent).porttype).portlist))) \u003d\u003e (exists occurtime:nat \u0026 (occurtime \u003d get_random_time_within_rw(rw))))))))","let be st existence obligation:(((ts.label) \u003d ((tc.transition).label)) \u003d\u003e (forall rw:ReactionWindow \u0026 ((rw \u003d mk_ReactionWindow((((tc.timebounds).lowertimebound) + CLOCK), (((tc.timebounds).uppertimebound) + CLOCK))) \u003d\u003e (forall port:Port \u0026 ((port \u003d get_lru_port((((tc.constrainedevent).porttype).portlist))) \u003d\u003e (forall occurtime:nat \u0026 ((occurtime \u003d get_random_time_within_rw(rw)) \u003d\u003e (exists se2:SimulationEvent \u0026 (se2 \u003d mk_SimulationEvent(((tc.constrainedevent).label), (trom.label), (port.label), occurtime, nil))))))))))","let be st existence obligation:(((ts.label) \u003d ((tc.transition).label)) \u003d\u003e (forall rw:ReactionWindow \u0026 ((rw \u003d mk_ReactionWindow((((tc.timebounds).lowertimebound) + CLOCK), (((tc.timebounds).uppertimebound) + CLOCK))) \u003d\u003e (forall port:Port \u0026 ((port \u003d get_lru_port((((tc.constrainedevent).porttype).portlist))) \u003d\u003e (forall occurtime:nat \u0026 ((occurtime \u003d get_random_time_within_rw(rw)) \u003d\u003e (forall se2:SimulationEvent \u0026 ((se2 \u003d mk_SimulationEvent(((tc.constrainedevent).label), (trom.label), (port.label), occurtime, nil)) \u003d\u003e ((rw in set (tc.reactionwindows)) \u003d\u003e ((se2 in set (elems SIMULATIONEVENTLIST)) \u003d\u003e ((((tc.constrainedevent).type) \u003d \u003cOUTPUT\u003e) \u003d\u003e (exists tromporttuple:[TromPortTuple] \u0026 (tromporttuple \u003d get_linked_tromport_tuple(mk_TromPortTuple((se2.tromlabel), (se2.portlabel)), SUBSYSTEM)))))))))))))))","let be st existence obligation:(((ts.label) \u003d ((tc.transition).label)) \u003d\u003e (forall rw:ReactionWindow \u0026 ((rw \u003d mk_ReactionWindow((((tc.timebounds).lowertimebound) + CLOCK), (((tc.timebounds).uppertimebound) + CLOCK))) \u003d\u003e (forall port:Port \u0026 ((port \u003d get_lru_port((((tc.constrainedevent).porttype).portlist))) \u003d\u003e (forall occurtime:nat \u0026 ((occurtime \u003d get_random_time_within_rw(rw)) \u003d\u003e (forall se2:SimulationEvent \u0026 ((se2 \u003d mk_SimulationEvent(((tc.constrainedevent).label), (trom.label), (port.label), occurtime, nil)) \u003d\u003e ((rw in set (tc.reactionwindows)) \u003d\u003e ((se2 in set (elems SIMULATIONEVENTLIST)) \u003d\u003e ((((tc.constrainedevent).type) \u003d \u003cOUTPUT\u003e) \u003d\u003e (forall tromporttuple:[TromPortTuple] \u0026 ((tromporttuple \u003d get_linked_tromport_tuple(mk_TromPortTuple((se2.tromlabel), (se2.portlabel)), SUBSYSTEM)) \u003d\u003e ((tromporttuple \u003c\u003e nil) \u003d\u003e (exists se3:SimulationEvent \u0026 (se3 \u003d mk_SimulationEvent((se2.eventlabel), (tromporttuple.tromlabel), (tromporttuple.portlabel), (se2.occurtime), nil))))))))))))))))))","operation postcondition satisfiable obligation:(forall trom:Trom, se:SimulationEvent, tc:TimeConstraint, ts:TransitionSpec, oldstate:System \u0026 (pre_enable_reaction(trom, se, tc, ts, oldstate) \u003d\u003e (exists newstate:System \u0026 post_enable_reaction(trom, se, tc, ts, oldstate, newstate))))","operation postcondition satisfiable obligation:(forall trom:Trom, tc:TimeConstraint, oldstate:System \u0026 (pre_get_enabled_simevent(trom, tc, oldstate) \u003d\u003e (exists se:SimulationEvent \u0026 post_get_enabled_simevent(trom, tc, oldstate, se, oldstate, newstate))))","operation postcondition satisfiable obligation:(forall tromporttuple:TromPortTuple, tc:TimeConstraint, oldstate:System \u0026 (exists se:SimulationEvent \u0026 post_get_enabled_simevent_synch(tromporttuple, tc, oldstate, se, oldstate, newstate)))","finite set obligation:((CLOCK \u003d 0) \u003d\u003e ((CLOCK \u003d 0) \u003d\u003e (exists finmap1:map (nat) to (Trom) \u0026 (forall trom:Trom \u0026 (exists_in_subsystem(trom, SUBSYSTEM) \u003d\u003e (exists findex2 in set (dom finmap1) \u0026 (finmap1(findex2) \u003d trom)))))))","legal function application obligation:((CLOCK \u003d 0) \u003d\u003e ((CLOCK \u003d 0) \u003d\u003e (forall trom:Trom \u0026 pre_exists_in_subsystem(trom, SUBSYSTEM))))","let be st existence obligation:((CLOCK \u003d 0) \u003d\u003e ((CLOCK \u003d 0) \u003d\u003e (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 let event:[Event] \u003d get_unconstrained_internal_event(trom) in ((event \u003c\u003e nil) \u003d\u003e (exists se:SimulationEvent \u0026 (se \u003d mk_SimulationEvent((event.label), (trom.label), \"NULLPORT\", CLOCK, nil)))))))","let be st existence obligation:((CLOCK \u003d 0) \u003d\u003e ((CLOCK \u003d 0) \u003d\u003e (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 let event:[Event] \u003d get_unconstrained_internal_event(trom) in ((event \u003c\u003e nil) \u003d\u003e (forall se:SimulationEvent \u0026 ((se \u003d mk_SimulationEvent((event.label), (trom.label), \"NULLPORT\", CLOCK, nil)) \u003d\u003e ((se in set (elems SIMULATIONEVENTLIST)) \u003d\u003e (exists i:nat1 \u0026 (SIMULATIONEVENTLIST(i) \u003d se)))))))))","legal sequence application obligation:((CLOCK \u003d 0) \u003d\u003e ((CLOCK \u003d 0) \u003d\u003e (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 let event:[Event] \u003d get_unconstrained_internal_event(trom) in ((event \u003c\u003e nil) \u003d\u003e (forall se:SimulationEvent \u0026 ((se \u003d mk_SimulationEvent((event.label), (trom.label), \"NULLPORT\", CLOCK, nil)) \u003d\u003e ((se in set (elems SIMULATIONEVENTLIST)) \u003d\u003e (forall i:nat1 \u0026 (i in set (inds SIMULATIONEVENTLIST))))))))))","let be st existence obligation:((CLOCK \u003d 0) \u003d\u003e ((CLOCK \u003d 0) \u003d\u003e (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 let event:[Event] \u003d get_unconstrained_internal_event(trom) in ((event \u003c\u003e nil) \u003d\u003e (forall se:SimulationEvent \u0026 ((se \u003d mk_SimulationEvent((event.label), (trom.label), \"NULLPORT\", CLOCK, nil)) \u003d\u003e ((se in set (elems SIMULATIONEVENTLIST)) \u003d\u003e (forall i:nat1 \u0026 ((SIMULATIONEVENTLIST(i) \u003d se) \u003d\u003e (forall se2 in set (elems SIMULATIONEVENTLIST~) \u0026 (exists j:nat1 \u0026 (SIMULATIONEVENTLIST(j) \u003d se2))))))))))))","legal sequence application obligation:((CLOCK \u003d 0) \u003d\u003e ((CLOCK \u003d 0) \u003d\u003e (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 let event:[Event] \u003d get_unconstrained_internal_event(trom) in ((event \u003c\u003e nil) \u003d\u003e (forall se:SimulationEvent \u0026 ((se \u003d mk_SimulationEvent((event.label), (trom.label), \"NULLPORT\", CLOCK, nil)) \u003d\u003e ((se in set (elems SIMULATIONEVENTLIST)) \u003d\u003e (forall i:nat1 \u0026 ((SIMULATIONEVENTLIST(i) \u003d se) \u003d\u003e (forall se2 in set (elems SIMULATIONEVENTLIST~) \u0026 (forall j:nat1 \u0026 (j in set (inds SIMULATIONEVENTLIST)))))))))))))","operation postcondition satisfiable obligation:(pre_schedule_unconstrained_internal_events_from_initial_state(oldstate) \u003d\u003e (exists newstate:System \u0026 post_schedule_unconstrained_internal_events_from_initial_state(oldstate, newstate)))","let be st existence obligation:(((se in set (elems SIMULATIONEVENTLIST)) and ((se.tromlabel) \u003d (trom.label))) \u003d\u003e let event:[Event] \u003d get_unconstrained_internal_event(trom) in ((event \u003c\u003e nil) \u003d\u003e (exists j:nat1 \u0026 (j \u003d get_simevent_index(se, SIMULATIONEVENTLIST)))))","legal function application obligation:(((se in set (elems SIMULATIONEVENTLIST)) and ((se.tromlabel) \u003d (trom.label))) \u003d\u003e let event:[Event] \u003d get_unconstrained_internal_event(trom) in ((event \u003c\u003e nil) \u003d\u003e (forall j:nat1 \u0026 pre_get_simevent_index(se, SIMULATIONEVENTLIST))))","let be st existence obligation:(((se in set (elems SIMULATIONEVENTLIST)) and ((se.tromlabel) \u003d (trom.label))) \u003d\u003e let event:[Event] \u003d get_unconstrained_internal_event(trom) in ((event \u003c\u003e nil) \u003d\u003e (forall j:nat1 \u0026 ((j \u003d get_simevent_index(se, SIMULATIONEVENTLIST)) \u003d\u003e (exists se2:SimulationEvent \u0026 (se2 \u003d mk_SimulationEvent((event.label), (trom.label), \"NULLPORT\", CLOCK, nil)))))))","legal sequence application obligation:(((se in set (elems SIMULATIONEVENTLIST)) and ((se.tromlabel) \u003d (trom.label))) \u003d\u003e let event:[Event] \u003d get_unconstrained_internal_event(trom) in ((event \u003c\u003e nil) \u003d\u003e (forall j:nat1 \u0026 ((j \u003d get_simevent_index(se, SIMULATIONEVENTLIST)) \u003d\u003e (forall se2:SimulationEvent \u0026 ((se2 \u003d mk_SimulationEvent((event.label), (trom.label), \"NULLPORT\", CLOCK, nil)) \u003d\u003e (forall i in set (inds SIMULATIONEVENTLIST~) \u0026 ((i \u003c\u003d j) \u003d\u003e (i in set (inds SIMULATIONEVENTLIST~))))))))))","legal sequence application obligation:(((se in set (elems SIMULATIONEVENTLIST)) and ((se.tromlabel) \u003d (trom.label))) \u003d\u003e let event:[Event] \u003d get_unconstrained_internal_event(trom) in ((event \u003c\u003e nil) \u003d\u003e (forall j:nat1 \u0026 ((j \u003d get_simevent_index(se, SIMULATIONEVENTLIST)) \u003d\u003e (forall se2:SimulationEvent \u0026 ((se2 \u003d mk_SimulationEvent((event.label), (trom.label), \"NULLPORT\", CLOCK, nil)) \u003d\u003e (forall i in set (inds SIMULATIONEVENTLIST~) \u0026 ((i \u003e j) \u003d\u003e (i in set (inds SIMULATIONEVENTLIST~))))))))))","operation postcondition satisfiable obligation:(forall trom:Trom, se:SimulationEvent, oldstate:System \u0026 (pre_schedule_unconstrained_internal_event(trom, se, oldstate) \u003d\u003e (exists newstate:System \u0026 post_schedule_unconstrained_internal_event(trom, se, oldstate, newstate))))","operation postcondition satisfiable obligation:(exists newstate:System \u0026 post_initialize_simulation_clock(oldstate, newstate))","operation postcondition satisfiable obligation:(exists newstate:System \u0026 post_update_simulation_clock(oldstate, newstate))"] \ No newline at end of file +["type invariant satisfiable obligation:(exists mk_PortType(label, cardinality, portlist):PortType \u0026 (cardinality \u003d (card (elems portlist))))","type invariant satisfiable obligation:(exists mk_Event(label, type, porttype):Event \u0026 (((type \u003d \u003cINTERNAL\u003e) and ((porttype.label) \u003d \"NULLPORT\")) or (((type \u003d \u003cINPUT\u003e) and ((porttype.label) \u003c\u003e \"NULLPORT\")) or ((type \u003d \u003cOUTPUT\u003e) and ((porttype.label) \u003c\u003e \"NULLPORT\")))))","type invariant satisfiable obligation:(exists mk_State(label, type, isinitial, substates):State \u0026 let exists_entry_state: (set of (State) +\u003e bool)\n\texists_entry_state(substates) \u003d\u003d\n((exists1 s in set substates \u0026 ((s.isinitial) \u003d true)) and (forall s in set substates \u0026 ((((s.type) \u003d \u003cSIMPLE\u003e) and ((s.substates) \u003d {})) or (((s.type) \u003d \u003cCOMPLEX\u003e) and exists_entry_state((s.substates)))))) in (((type \u003d \u003cSIMPLE\u003e) and (substates \u003d {})) or ((type \u003d \u003cCOMPLEX\u003e) and exists_entry_state(substates))))","type invariant satisfiable obligation:(exists mk_TimeConstraint(label, transition, cevent, tbounds, dstates, rwindows):TimeConstraint \u0026 ((((cevent.type) \u003d \u003cINTERNAL\u003e) or ((cevent.type) \u003d \u003cOUTPUT\u003e)) and (forall rw in set rwindows \u0026 (((rw.uppertimebound) - (rw.lowertimebound)) \u003d ((tbounds.uppertimebound) - (tbounds.lowertimebound))))))","type invariant satisfiable obligation:(exists mk_ReactionWindow(lowertimebound, uppertimebound):ReactionWindow \u0026 (lowertimebound \u003c\u003d uppertimebound))","type invariant satisfiable obligation:(exists mk_PortLink(tromporttuple1, tromporttuple2):PortLink \u0026 ((tromporttuple1.tromlabel) \u003c\u003e (tromporttuple2.tromlabel)))","legal function application obligation:(forall mk_Trom(label, tromclass, porttypes, events, states, attributes, lsltraits, attrfunctions, transitionspecs, timeconstraints, currentstate, assignmentvector):Trom \u0026 ((forall pt1, pt2 in set porttypes \u0026 (((pt1.label) \u003d (pt2.label)) \u003d\u003e (pt1 \u003d pt2))) \u003d\u003e ((forall e1, e2 in set events \u0026 (((e1.label) \u003d (e2.label)) \u003d\u003e (e1 \u003d e2))) \u003d\u003e ((forall s1, s2 in set states \u0026 (((s1.label) \u003d (s2.label)) \u003d\u003e (s1 \u003d s2))) \u003d\u003e ((forall a1, a2 in set attributes \u0026 (((a1.label) \u003d (a2.label)) \u003d\u003e (a1 \u003d a2))) \u003d\u003e ((forall tr1, tr2 in set lsltraits \u0026 (((tr1.traittype) \u003d (tr2.traittype)) \u003d\u003e (tr1 \u003d tr2))) \u003d\u003e ((forall af1, af2 in set attrfunctions \u0026 (((af1.stat) \u003d (af2.stat)) \u003d\u003e (af1 \u003d af2))) \u003d\u003e ((forall ts1, ts2 in set transitionspecs \u0026 (((ts1.label) \u003d (ts2.label)) \u003d\u003e (ts1 \u003d ts2))) \u003d\u003e ((forall tc1, tc2 in set timeconstraints \u0026 (((tc1.label) \u003d (tc2.label)) \u003d\u003e (tc1 \u003d tc2))) \u003d\u003e ((forall e in set events \u0026 (exists pt in set porttypes \u0026 (pt \u003d (e.porttype)))) \u003d\u003e ((exists1 s in set states \u0026 ((s.isinitial) \u003d true)) \u003d\u003e (forall s in set states \u0026 ((not (currentstate \u003d s)) \u003d\u003e pre_substate_of(currentstate, s))))))))))))))","legal function application obligation:(forall mk_Trom(label, tromclass, porttypes, events, states, attributes, lsltraits, attrfunctions, transitionspecs, timeconstraints, currentstate, assignmentvector):Trom \u0026 ((forall pt1, pt2 in set porttypes \u0026 (((pt1.label) \u003d (pt2.label)) \u003d\u003e (pt1 \u003d pt2))) \u003d\u003e ((forall e1, e2 in set events \u0026 (((e1.label) \u003d (e2.label)) \u003d\u003e (e1 \u003d e2))) \u003d\u003e ((forall s1, s2 in set states \u0026 (((s1.label) \u003d (s2.label)) \u003d\u003e (s1 \u003d s2))) \u003d\u003e ((forall a1, a2 in set attributes \u0026 (((a1.label) \u003d (a2.label)) \u003d\u003e (a1 \u003d a2))) \u003d\u003e ((forall tr1, tr2 in set lsltraits \u0026 (((tr1.traittype) \u003d (tr2.traittype)) \u003d\u003e (tr1 \u003d tr2))) \u003d\u003e ((forall af1, af2 in set attrfunctions \u0026 (((af1.stat) \u003d (af2.stat)) \u003d\u003e (af1 \u003d af2))) \u003d\u003e ((forall ts1, ts2 in set transitionspecs \u0026 (((ts1.label) \u003d (ts2.label)) \u003d\u003e (ts1 \u003d ts2))) \u003d\u003e ((forall tc1, tc2 in set timeconstraints \u0026 (((tc1.label) \u003d (tc2.label)) \u003d\u003e (tc1 \u003d tc2))) \u003d\u003e ((forall e in set events \u0026 (exists pt in set porttypes \u0026 (pt \u003d (e.porttype)))) \u003d\u003e ((exists1 s in set states \u0026 ((s.isinitial) \u003d true)) \u003d\u003e ((exists1 s in set states \u0026 ((currentstate \u003d s) or substate_of(currentstate, s))) \u003d\u003e ((forall a in set attributes \u0026 ((exists1 pt in set porttypes \u0026 ((pt.label) \u003d (a.type))) or (exists1 tr in set lsltraits \u0026 ((tr.traittype) \u003d (a.type))))) \u003d\u003e ((forall tr in set lsltraits \u0026 (forall el in set (elems (tr.elementtypes)) \u0026 ((exists1 pt in set porttypes \u0026 ((pt.label) \u003d el)) or (exists1 tr2 in set lsltraits \u0026 ((tr2.traittype) \u003d el))))) \u003d\u003e (forall af in set attrfunctions \u0026 (forall s in set states \u0026 ((not (s \u003d (af.stat))) \u003d\u003e pre_substate_of((af.stat), s))))))))))))))))))","legal function application obligation:(forall mk_Trom(label, tromclass, porttypes, events, states, attributes, lsltraits, attrfunctions, transitionspecs, timeconstraints, currentstate, assignmentvector):Trom \u0026 ((forall pt1, pt2 in set porttypes \u0026 (((pt1.label) \u003d (pt2.label)) \u003d\u003e (pt1 \u003d pt2))) \u003d\u003e ((forall e1, e2 in set events \u0026 (((e1.label) \u003d (e2.label)) \u003d\u003e (e1 \u003d e2))) \u003d\u003e ((forall s1, s2 in set states \u0026 (((s1.label) \u003d (s2.label)) \u003d\u003e (s1 \u003d s2))) \u003d\u003e ((forall a1, a2 in set attributes \u0026 (((a1.label) \u003d (a2.label)) \u003d\u003e (a1 \u003d a2))) \u003d\u003e ((forall tr1, tr2 in set lsltraits \u0026 (((tr1.traittype) \u003d (tr2.traittype)) \u003d\u003e (tr1 \u003d tr2))) \u003d\u003e ((forall af1, af2 in set attrfunctions \u0026 (((af1.stat) \u003d (af2.stat)) \u003d\u003e (af1 \u003d af2))) \u003d\u003e ((forall ts1, ts2 in set transitionspecs \u0026 (((ts1.label) \u003d (ts2.label)) \u003d\u003e (ts1 \u003d ts2))) \u003d\u003e ((forall tc1, tc2 in set timeconstraints \u0026 (((tc1.label) \u003d (tc2.label)) \u003d\u003e (tc1 \u003d tc2))) \u003d\u003e ((forall e in set events \u0026 (exists pt in set porttypes \u0026 (pt \u003d (e.porttype)))) \u003d\u003e ((exists1 s in set states \u0026 ((s.isinitial) \u003d true)) \u003d\u003e ((exists1 s in set states \u0026 ((currentstate \u003d s) or substate_of(currentstate, s))) \u003d\u003e ((forall a in set attributes \u0026 ((exists1 pt in set porttypes \u0026 ((pt.label) \u003d (a.type))) or (exists1 tr in set lsltraits \u0026 ((tr.traittype) \u003d (a.type))))) \u003d\u003e ((forall tr in set lsltraits \u0026 (forall el in set (elems (tr.elementtypes)) \u0026 ((exists1 pt in set porttypes \u0026 ((pt.label) \u003d el)) or (exists1 tr2 in set lsltraits \u0026 ((tr2.traittype) \u003d el))))) \u003d\u003e ((forall af in set attrfunctions \u0026 ((exists1 s in set states \u0026 ((s \u003d (af.stat)) or substate_of((af.stat), s))) and (forall afa in set (af.attributes) \u0026 (exists1 a in set attributes \u0026 (a \u003d afa))))) \u003d\u003e (forall ts in set transitionspecs \u0026 (forall s in set states \u0026 ((not (s \u003d (ts.sourcestate))) \u003d\u003e pre_substate_of((ts.sourcestate), s)))))))))))))))))))","legal function application obligation:(forall mk_Trom(label, tromclass, porttypes, events, states, attributes, lsltraits, attrfunctions, transitionspecs, timeconstraints, currentstate, assignmentvector):Trom \u0026 ((forall pt1, pt2 in set porttypes \u0026 (((pt1.label) \u003d (pt2.label)) \u003d\u003e (pt1 \u003d pt2))) \u003d\u003e ((forall e1, e2 in set events \u0026 (((e1.label) \u003d (e2.label)) \u003d\u003e (e1 \u003d e2))) \u003d\u003e ((forall s1, s2 in set states \u0026 (((s1.label) \u003d (s2.label)) \u003d\u003e (s1 \u003d s2))) \u003d\u003e ((forall a1, a2 in set attributes \u0026 (((a1.label) \u003d (a2.label)) \u003d\u003e (a1 \u003d a2))) \u003d\u003e ((forall tr1, tr2 in set lsltraits \u0026 (((tr1.traittype) \u003d (tr2.traittype)) \u003d\u003e (tr1 \u003d tr2))) \u003d\u003e ((forall af1, af2 in set attrfunctions \u0026 (((af1.stat) \u003d (af2.stat)) \u003d\u003e (af1 \u003d af2))) \u003d\u003e ((forall ts1, ts2 in set transitionspecs \u0026 (((ts1.label) \u003d (ts2.label)) \u003d\u003e (ts1 \u003d ts2))) \u003d\u003e ((forall tc1, tc2 in set timeconstraints \u0026 (((tc1.label) \u003d (tc2.label)) \u003d\u003e (tc1 \u003d tc2))) \u003d\u003e ((forall e in set events \u0026 (exists pt in set porttypes \u0026 (pt \u003d (e.porttype)))) \u003d\u003e ((exists1 s in set states \u0026 ((s.isinitial) \u003d true)) \u003d\u003e ((exists1 s in set states \u0026 ((currentstate \u003d s) or substate_of(currentstate, s))) \u003d\u003e ((forall a in set attributes \u0026 ((exists1 pt in set porttypes \u0026 ((pt.label) \u003d (a.type))) or (exists1 tr in set lsltraits \u0026 ((tr.traittype) \u003d (a.type))))) \u003d\u003e ((forall tr in set lsltraits \u0026 (forall el in set (elems (tr.elementtypes)) \u0026 ((exists1 pt in set porttypes \u0026 ((pt.label) \u003d el)) or (exists1 tr2 in set lsltraits \u0026 ((tr2.traittype) \u003d el))))) \u003d\u003e ((forall af in set attrfunctions \u0026 ((exists1 s in set states \u0026 ((s \u003d (af.stat)) or substate_of((af.stat), s))) and (forall afa in set (af.attributes) \u0026 (exists1 a in set attributes \u0026 (a \u003d afa))))) \u003d\u003e (forall ts in set transitionspecs \u0026 ((exists1 s in set states \u0026 ((s \u003d (ts.sourcestate)) or substate_of((ts.sourcestate), s))) \u003d\u003e (forall d in set states \u0026 ((not (d \u003d (ts.destinstate))) \u003d\u003e pre_substate_of((ts.destinstate), d))))))))))))))))))))","legal function application obligation:(forall mk_Trom(label, tromclass, porttypes, events, states, attributes, lsltraits, attrfunctions, transitionspecs, timeconstraints, currentstate, assignmentvector):Trom \u0026 ((forall pt1, pt2 in set porttypes \u0026 (((pt1.label) \u003d (pt2.label)) \u003d\u003e (pt1 \u003d pt2))) \u003d\u003e ((forall e1, e2 in set events \u0026 (((e1.label) \u003d (e2.label)) \u003d\u003e (e1 \u003d e2))) \u003d\u003e ((forall s1, s2 in set states \u0026 (((s1.label) \u003d (s2.label)) \u003d\u003e (s1 \u003d s2))) \u003d\u003e ((forall a1, a2 in set attributes \u0026 (((a1.label) \u003d (a2.label)) \u003d\u003e (a1 \u003d a2))) \u003d\u003e ((forall tr1, tr2 in set lsltraits \u0026 (((tr1.traittype) \u003d (tr2.traittype)) \u003d\u003e (tr1 \u003d tr2))) \u003d\u003e ((forall af1, af2 in set attrfunctions \u0026 (((af1.stat) \u003d (af2.stat)) \u003d\u003e (af1 \u003d af2))) \u003d\u003e ((forall ts1, ts2 in set transitionspecs \u0026 (((ts1.label) \u003d (ts2.label)) \u003d\u003e (ts1 \u003d ts2))) \u003d\u003e ((forall tc1, tc2 in set timeconstraints \u0026 (((tc1.label) \u003d (tc2.label)) \u003d\u003e (tc1 \u003d tc2))) \u003d\u003e ((forall e in set events \u0026 (exists pt in set porttypes \u0026 (pt \u003d (e.porttype)))) \u003d\u003e ((exists1 s in set states \u0026 ((s.isinitial) \u003d true)) \u003d\u003e ((exists1 s in set states \u0026 ((currentstate \u003d s) or substate_of(currentstate, s))) \u003d\u003e ((forall a in set attributes \u0026 ((exists1 pt in set porttypes \u0026 ((pt.label) \u003d (a.type))) or (exists1 tr in set lsltraits \u0026 ((tr.traittype) \u003d (a.type))))) \u003d\u003e ((forall tr in set lsltraits \u0026 (forall el in set (elems (tr.elementtypes)) \u0026 ((exists1 pt in set porttypes \u0026 ((pt.label) \u003d el)) or (exists1 tr2 in set lsltraits \u0026 ((tr2.traittype) \u003d el))))) \u003d\u003e ((forall af in set attrfunctions \u0026 ((exists1 s in set states \u0026 ((s \u003d (af.stat)) or substate_of((af.stat), s))) and (forall afa in set (af.attributes) \u0026 (exists1 a in set attributes \u0026 (a \u003d afa))))) \u003d\u003e ((forall ts in set transitionspecs \u0026 ((exists1 s in set states \u0026 ((s \u003d (ts.sourcestate)) or substate_of((ts.sourcestate), s))) and ((exists1 d in set states \u0026 ((d \u003d (ts.destinstate)) or substate_of((ts.destinstate), d))) and (exists1 e in set events \u0026 (e \u003d (ts.triggerevent)))))) \u003d\u003e (forall tc in set timeconstraints \u0026 ((exists1 ts in set transitionspecs \u0026 (ts \u003d (tc.transition))) \u003d\u003e ((exists1 e in set events \u0026 ((e \u003d (tc.constrainedevent)) and (((e.type) \u003d \u003cINTERNAL\u003e) or ((e.type) \u003d \u003cOUTPUT\u003e)))) \u003d\u003e (forall ds in set (tc.disablingstates) \u0026 (forall s in set states \u0026 ((not (s \u003d ds)) \u003d\u003e pre_substate_of(ds, s)))))))))))))))))))))))","type invariant satisfiable obligation:(exists mk_Trom(label, tromclass, porttypes, events, states, attributes, lsltraits, attrfunctions, transitionspecs, timeconstraints, currentstate, assignmentvector):Trom \u0026 ((forall pt1, pt2 in set porttypes \u0026 (((pt1.label) \u003d (pt2.label)) \u003d\u003e (pt1 \u003d pt2))) and ((forall e1, e2 in set events \u0026 (((e1.label) \u003d (e2.label)) \u003d\u003e (e1 \u003d e2))) and ((forall s1, s2 in set states \u0026 (((s1.label) \u003d (s2.label)) \u003d\u003e (s1 \u003d s2))) and ((forall a1, a2 in set attributes \u0026 (((a1.label) \u003d (a2.label)) \u003d\u003e (a1 \u003d a2))) and ((forall tr1, tr2 in set lsltraits \u0026 (((tr1.traittype) \u003d (tr2.traittype)) \u003d\u003e (tr1 \u003d tr2))) and ((forall af1, af2 in set attrfunctions \u0026 (((af1.stat) \u003d (af2.stat)) \u003d\u003e (af1 \u003d af2))) and ((forall ts1, ts2 in set transitionspecs \u0026 (((ts1.label) \u003d (ts2.label)) \u003d\u003e (ts1 \u003d ts2))) and ((forall tc1, tc2 in set timeconstraints \u0026 (((tc1.label) \u003d (tc2.label)) \u003d\u003e (tc1 \u003d tc2))) and ((forall e in set events \u0026 (exists pt in set porttypes \u0026 (pt \u003d (e.porttype)))) and ((exists1 s in set states \u0026 ((s.isinitial) \u003d true)) and ((exists1 s in set states \u0026 ((currentstate \u003d s) or substate_of(currentstate, s))) and ((forall a in set attributes \u0026 ((exists1 pt in set porttypes \u0026 ((pt.label) \u003d (a.type))) or (exists1 tr in set lsltraits \u0026 ((tr.traittype) \u003d (a.type))))) and ((forall tr in set lsltraits \u0026 (forall el in set (elems (tr.elementtypes)) \u0026 ((exists1 pt in set porttypes \u0026 ((pt.label) \u003d el)) or (exists1 tr2 in set lsltraits \u0026 ((tr2.traittype) \u003d el))))) and ((forall af in set attrfunctions \u0026 ((exists1 s in set states \u0026 ((s \u003d (af.stat)) or substate_of((af.stat), s))) and (forall afa in set (af.attributes) \u0026 (exists1 a in set attributes \u0026 (a \u003d afa))))) and ((forall ts in set transitionspecs \u0026 ((exists1 s in set states \u0026 ((s \u003d (ts.sourcestate)) or substate_of((ts.sourcestate), s))) and ((exists1 d in set states \u0026 ((d \u003d (ts.destinstate)) or substate_of((ts.destinstate), d))) and (exists1 e in set events \u0026 (e \u003d (ts.triggerevent)))))) and (forall tc in set timeconstraints \u0026 ((exists1 ts in set transitionspecs \u0026 (ts \u003d (tc.transition))) and ((exists1 e in set events \u0026 ((e \u003d (tc.constrainedevent)) and (((e.type) \u003d \u003cINTERNAL\u003e) or ((e.type) \u003d \u003cOUTPUT\u003e)))) and (forall ds in set (tc.disablingstates) \u0026 (exists1 s in set states \u0026 ((s \u003d ds) or substate_of(ds, s)))))))))))))))))))))))","finite set obligation:(forall mk_Subsystem(label, includes, troms, portlinks):Subsystem \u0026 ((forall s1, s2 in set includes \u0026 (((s1.label) \u003d (s2.label)) \u003d\u003e (s1 \u003d s2))) \u003d\u003e (let included_subsystem: (String * set of (Subsystem) +\u003e bool)\n\tincluded_subsystem(subsystemlabel, subsystems) \u003d\u003d\n(exists1 s in set subsystems \u0026 (((s.label) \u003d subsystemlabel) or included_subsystem(subsystemlabel, (s.includes)))) in (not included_subsystem(label, includes)) \u003d\u003e ((forall trom1, trom2 in set troms \u0026 (((trom1.label) \u003d (trom2.label)) \u003d\u003e (trom1 \u003d trom2))) \u003d\u003e (let included_trom: (String * set of (Subsystem) +\u003e bool)\n\tincluded_trom(tromlabel, subsystems) \u003d\u003d\n(exists1 s in set subsystems \u0026 ((exists1 trom in set (s.troms) \u0026 ((trom.label) \u003d tromlabel)) or included_trom(tromlabel, (s.includes)))) in (forall trom in set troms \u0026 (not included_trom((trom.label), includes))) \u003d\u003e (forall tptuple:TromPortTuple, subsystems:set of (Subsystem) \u0026 (forall s in set subsystems \u0026 (((linked_trom(tptuple, (s.troms)) and (not linked_subsystem(tptuple, (s.includes)))) or ((not linked_trom(tptuple, (s.troms))) and linked_subsystem(tptuple, (s.includes)))) \u003d\u003e (exists finmap1:map (nat) to (Subsystem) \u0026 (forall su:Subsystem \u0026 (((su in set subsystems) and (su \u003c\u003e s)) \u003d\u003e (exists findex2 in set (dom finmap1) \u0026 (finmap1(findex2) \u003d su)))))))))))))","type invariant satisfiable obligation:(exists mk_Subsystem(label, includes, troms, portlinks):Subsystem \u0026 ((forall s1, s2 in set includes \u0026 (((s1.label) \u003d (s2.label)) \u003d\u003e (s1 \u003d s2))) and (let included_subsystem: (String * set of (Subsystem) +\u003e bool)\n\tincluded_subsystem(subsystemlabel, subsystems) \u003d\u003d\n(exists1 s in set subsystems \u0026 (((s.label) \u003d subsystemlabel) or included_subsystem(subsystemlabel, (s.includes)))) in (not included_subsystem(label, includes)) and ((forall trom1, trom2 in set troms \u0026 (((trom1.label) \u003d (trom2.label)) \u003d\u003e (trom1 \u003d trom2))) and (let included_trom: (String * set of (Subsystem) +\u003e bool)\n\tincluded_trom(tromlabel, subsystems) \u003d\u003d\n(exists1 s in set subsystems \u0026 ((exists1 trom in set (s.troms) \u0026 ((trom.label) \u003d tromlabel)) or included_trom(tromlabel, (s.includes)))) in (forall trom in set troms \u0026 (not included_trom((trom.label), includes))) and let linked_trom: (TromPortTuple * set of (Trom) +\u003e bool)\n\tlinked_trom(tptuple, troms) \u003d\u003d\n(exists1 trom in set troms \u0026 (((trom.label) \u003d (tptuple.tromlabel)) and (exists1 pt in set (trom.porttypes) \u0026 (exists1 p in set (elems (pt.portlist)) \u0026 ((p.label) \u003d (tptuple.portlabel)))))), linked_subsystem: (TromPortTuple * set of (Subsystem) +\u003e bool)\n\tlinked_subsystem(tptuple, subsystems) \u003d\u003d\n(exists1 s in set subsystems \u0026 (((linked_trom(tptuple, (s.troms)) and (not linked_subsystem(tptuple, (s.includes)))) or ((not linked_trom(tptuple, (s.troms))) and linked_subsystem(tptuple, (s.includes)))) and (forall s2 in set {su | su:Subsystem \u0026 ((su in set subsystems) and (su \u003c\u003e s))} \u0026 ((not linked_trom(tptuple, (s2.troms))) and (not linked_subsystem(tptuple, (s2.includes))))))) in (forall pl in set portlinks \u0026 (((linked_trom((pl.tromporttuple1), troms) and (not linked_subsystem((pl.tromporttuple1), includes))) or ((not linked_trom((pl.tromporttuple1), troms)) and linked_subsystem((pl.tromporttuple1), includes))) and ((linked_trom((pl.tromporttuple2), troms) and (not linked_subsystem((pl.tromporttuple2), includes))) or ((not linked_trom((pl.tromporttuple2), troms)) and linked_subsystem((pl.tromporttuple2), includes))))))))))","legal sequence application obligation:(forall mk_System(subsystem, simulationeventlist, lsllibrary, clock):System \u0026 (let contains_trom: (Subsystem +\u003e bool)\n\tcontains_trom(subsys) \u003d\u003d\n(((subsys.troms) \u003c\u003e {}) or (exists1 s in set (subsys.includes) \u0026 contains_trom(s))) in contains_trom(subsystem) \u003d\u003e (let contains_portlink: (Subsystem +\u003e bool)\n\tcontains_portlink(subsys) \u003d\u003d\n(((subsys.portlinks) \u003c\u003e {}) or (exists1 s in set (subsys.includes) \u0026 contains_portlink(s))) in contains_portlink(subsystem) \u003d\u003e (forall i, j in set (inds simulationeventlist) \u0026 ((i \u003d j) \u003d\u003e (i in set (inds simulationeventlist)))))))","legal sequence application obligation:(forall mk_System(subsystem, simulationeventlist, lsllibrary, clock):System \u0026 (let contains_trom: (Subsystem +\u003e bool)\n\tcontains_trom(subsys) \u003d\u003d\n(((subsys.troms) \u003c\u003e {}) or (exists1 s in set (subsys.includes) \u0026 contains_trom(s))) in contains_trom(subsystem) \u003d\u003e (let contains_portlink: (Subsystem +\u003e bool)\n\tcontains_portlink(subsys) \u003d\u003d\n(((subsys.portlinks) \u003c\u003e {}) or (exists1 s in set (subsys.includes) \u0026 contains_portlink(s))) in contains_portlink(subsystem) \u003d\u003e (forall i, j in set (inds simulationeventlist) \u0026 ((i \u003d j) \u003d\u003e (j in set (inds simulationeventlist)))))))","legal sequence application obligation:(forall mk_System(subsystem, simulationeventlist, lsllibrary, clock):System \u0026 (let contains_trom: (Subsystem +\u003e bool)\n\tcontains_trom(subsys) \u003d\u003d\n(((subsys.troms) \u003c\u003e {}) or (exists1 s in set (subsys.includes) \u0026 contains_trom(s))) in contains_trom(subsystem) \u003d\u003e (let contains_portlink: (Subsystem +\u003e bool)\n\tcontains_portlink(subsys) \u003d\u003d\n(((subsys.portlinks) \u003c\u003e {}) or (exists1 s in set (subsys.includes) \u0026 contains_portlink(s))) in contains_portlink(subsystem) \u003d\u003e (forall i, j in set (inds simulationeventlist) \u0026 ((not ((i \u003d j) and (simulationeventlist(i) \u003d simulationeventlist(j)))) \u003d\u003e ((i \u003c j) \u003d\u003e (i in set (inds simulationeventlist))))))))","legal sequence application obligation:(forall mk_System(subsystem, simulationeventlist, lsllibrary, clock):System \u0026 (let contains_trom: (Subsystem +\u003e bool)\n\tcontains_trom(subsys) \u003d\u003d\n(((subsys.troms) \u003c\u003e {}) or (exists1 s in set (subsys.includes) \u0026 contains_trom(s))) in contains_trom(subsystem) \u003d\u003e (let contains_portlink: (Subsystem +\u003e bool)\n\tcontains_portlink(subsys) \u003d\u003d\n(((subsys.portlinks) \u003c\u003e {}) or (exists1 s in set (subsys.includes) \u0026 contains_portlink(s))) in contains_portlink(subsystem) \u003d\u003e (forall i, j in set (inds simulationeventlist) \u0026 ((not ((i \u003d j) and (simulationeventlist(i) \u003d simulationeventlist(j)))) \u003d\u003e ((i \u003c j) \u003d\u003e (j in set (inds simulationeventlist))))))))","legal sequence application obligation:(forall mk_System(subsystem, simulationeventlist, lsllibrary, clock):System \u0026 (let contains_trom: (Subsystem +\u003e bool)\n\tcontains_trom(subsys) \u003d\u003d\n(((subsys.troms) \u003c\u003e {}) or (exists1 s in set (subsys.includes) \u0026 contains_trom(s))) in contains_trom(subsystem) \u003d\u003e (let contains_portlink: (Subsystem +\u003e bool)\n\tcontains_portlink(subsys) \u003d\u003d\n(((subsys.portlinks) \u003c\u003e {}) or (exists1 s in set (subsys.includes) \u0026 contains_portlink(s))) in contains_portlink(subsystem) \u003d\u003e (forall i, j in set (inds simulationeventlist) \u0026 ((not ((i \u003d j) and (simulationeventlist(i) \u003d simulationeventlist(j)))) \u003d\u003e ((not ((i \u003c j) and ((simulationeventlist(i).occurtime) \u003c\u003d (simulationeventlist(j).occurtime)))) \u003d\u003e ((i \u003e j) \u003d\u003e (i in set (inds simulationeventlist)))))))))","legal sequence application obligation:(forall mk_System(subsystem, simulationeventlist, lsllibrary, clock):System \u0026 (let contains_trom: (Subsystem +\u003e bool)\n\tcontains_trom(subsys) \u003d\u003d\n(((subsys.troms) \u003c\u003e {}) or (exists1 s in set (subsys.includes) \u0026 contains_trom(s))) in contains_trom(subsystem) \u003d\u003e (let contains_portlink: (Subsystem +\u003e bool)\n\tcontains_portlink(subsys) \u003d\u003d\n(((subsys.portlinks) \u003c\u003e {}) or (exists1 s in set (subsys.includes) \u0026 contains_portlink(s))) in contains_portlink(subsystem) \u003d\u003e (forall i, j in set (inds simulationeventlist) \u0026 ((not ((i \u003d j) and (simulationeventlist(i) \u003d simulationeventlist(j)))) \u003d\u003e ((not ((i \u003c j) and ((simulationeventlist(i).occurtime) \u003c\u003d (simulationeventlist(j).occurtime)))) \u003d\u003e ((i \u003e j) \u003d\u003e (j in set (inds simulationeventlist)))))))))","finite set obligation:(forall mk_System(subsystem, simulationeventlist, lsllibrary, clock):System \u0026 (let contains_trom: (Subsystem +\u003e bool)\n\tcontains_trom(subsys) \u003d\u003d\n(((subsys.troms) \u003c\u003e {}) or (exists1 s in set (subsys.includes) \u0026 contains_trom(s))) in contains_trom(subsystem) \u003d\u003e (let contains_portlink: (Subsystem +\u003e bool)\n\tcontains_portlink(subsys) \u003d\u003d\n(((subsys.portlinks) \u003c\u003e {}) or (exists1 s in set (subsys.includes) \u0026 contains_portlink(s))) in contains_portlink(subsystem) \u003d\u003e ((forall i, j in set (inds simulationeventlist) \u0026 (((i \u003d j) and (simulationeventlist(i) \u003d simulationeventlist(j))) or (((i \u003c j) and ((simulationeventlist(i).occurtime) \u003c\u003d (simulationeventlist(j).occurtime))) or ((i \u003e j) and ((simulationeventlist(i).occurtime) \u003e\u003d (simulationeventlist(j).occurtime)))))) \u003d\u003e ((forall se1, se2 in set (elems simulationeventlist) \u0026 ((((se1.occurtime) \u003d (se2.occurtime)) and ((se1.tromlabel) \u003c\u003e (se2.tromlabel))) or ((se1.occurtime) \u003c\u003e (se2.occurtime)))) \u003d\u003e let accepted_by_trom: (SimulationEvent * Subsystem +\u003e bool)\n\taccepted_by_trom(se, subsys) \u003d\u003d\n(exists1 trom in set (subsys.troms) \u0026 (((trom.label) \u003d (se.tromlabel)) and (exists1 e in set (trom.events) \u0026 (((e.label) \u003d (se.eventlabel)) and (exists1 pt in set (trom.porttypes) \u0026 ((pt \u003d (e.porttype)) and (exists1 p in set (elems (pt.portlist)) \u0026 ((p.label) \u003d (se.portlabel))))))))) in (forall se:SimulationEvent, subsys:Subsystem \u0026 (forall s in set (subsys.includes) \u0026 (((accepted_by_trom(se, s) and (not accepted_by_subsystem(se, s))) or ((not accepted_by_trom(se, s)) and accepted_by_subsystem(se, s))) \u003d\u003e (exists finmap1:map (nat) to (Subsystem) \u0026 (forall su:Subsystem \u0026 (((su in set (subsys.includes)) and (su \u003c\u003e s)) \u003d\u003e (exists findex2 in set (dom finmap1) \u0026 (finmap1(findex2) \u003d su)))))))))))))","function postcondition satisfiable obligation:(forall tromlabel:String, subsystem:Subsystem \u0026 (exists trom:[Trom] \u0026 post_get_trom_object(tromlabel, subsystem, trom)))","legal function application obligation:(forall trom:Trom, se:SimulationEvent \u0026 (((trom.label) \u003d (se.tromlabel)) \u003d\u003e (exists ts:[TransitionSpec] \u0026 ((ts in set (trom.transitionspecs)) \u003d\u003e ((not (((trom.currentstate).label) \u003d ((ts.sourcestate).label))) \u003d\u003e pre_substate_of((trom.currentstate), (ts.sourcestate)))))))","function postcondition satisfiable obligation:(forall trom:Trom, se:SimulationEvent \u0026 (pre_get_transition_spec(trom, se) \u003d\u003e (exists ts:[TransitionSpec] \u0026 post_get_transition_spec(trom, se, ts))))","legal function application obligation:(forall substate:State, complexstate:State \u0026 (((complexstate.type) \u003d \u003cCOMPLEX\u003e) \u003d\u003e ((not (substate in set (complexstate.substates))) \u003d\u003e (forall s in set (complexstate.substates) \u0026 (((s.type) \u003d \u003cCOMPLEX\u003e) \u003d\u003e pre_substate_of(substate, s))))))","legal function application obligation:(forall complexstate:State \u0026 (((complexstate.type) \u003d \u003cCOMPLEX\u003e) \u003d\u003e (exists entry:State \u0026 (forall s in set (complexstate.substates) \u0026 (((s.isinitial) \u003d true) \u003d\u003e ((not (((s.type) \u003d \u003cSIMPLE\u003e) and (entry \u003d s))) \u003d\u003e (((s.type) \u003d \u003cCOMPLEX\u003e) \u003d\u003e pre_get_entry_state(s))))))))","function postcondition satisfiable obligation:(forall complexstate:State \u0026 (pre_get_entry_state(complexstate) \u003d\u003e (exists entry:State \u0026 post_get_entry_state(complexstate, entry))))","legal function application obligation:(forall trom:Trom \u0026 (((trom.states) \u003c\u003e {}) \u003d\u003e (exists initial:State \u0026 (forall s in set (trom.states) \u0026 (((s.isinitial) \u003d true) \u003d\u003e ((not (((s.type) \u003d \u003cSIMPLE\u003e) and (initial \u003d s))) \u003d\u003e (((s.type) \u003d \u003cCOMPLEX\u003e) \u003d\u003e pre_get_entry_state(s))))))))","function postcondition satisfiable obligation:(forall trom:Trom \u0026 (pre_get_initial_state(trom) \u003d\u003e (exists initial:State \u0026 post_get_initial_state(trom, initial))))","function postcondition satisfiable obligation:(forall tupleA:TromPortTuple, subsystem:Subsystem \u0026 (exists tupleB:[TromPortTuple] \u0026 post_get_linked_tromport_tuple(tupleA, subsystem, tupleB)))","legal function application obligation:(forall trom:Trom, subsys:Subsystem \u0026 ((((subsys.troms) \u003c\u003e {}) or ((subsys.includes) \u003c\u003e {})) \u003d\u003e ((not (trom in set (subsys.troms))) \u003d\u003e (forall subsystem in set (subsys.includes) \u0026 pre_exists_in_subsystem(trom, subsystem)))))","legal function application obligation:(forall trom:Trom \u0026 (exists event:[Event] \u0026 (forall ts in set (trom.transitionspecs) \u0026 (((ts.sourcestate) \u003d (trom.currentstate)) \u003d\u003e ((((ts.triggerevent).type) \u003d \u003cINTERNAL\u003e) \u003d\u003e pre_constrained_event(trom, (ts.triggerevent)))))))","function postcondition satisfiable obligation:(forall trom:Trom \u0026 (exists event:[Event] \u0026 post_get_unconstrained_internal_event(trom, event)))","legal sequence application obligation:(forall se:SimulationEvent, se_list:seq of (SimulationEvent) \u0026 ((se in set (elems se_list)) \u003d\u003e (exists index:nat1 \u0026 (index in set (inds se_list)))))","function postcondition satisfiable obligation:(forall se:SimulationEvent, se_list:seq of (SimulationEvent) \u0026 (pre_get_simevent_index(se, se_list) \u003d\u003e (exists index:nat1 \u0026 post_get_simevent_index(se, se_list, index))))","function postcondition satisfiable obligation:(forall rw:ReactionWindow \u0026 (exists time:nat \u0026 post_get_random_time_within_rw(rw, time)))","function postcondition satisfiable obligation:(forall portlist:seq of (Port) \u0026 (pre_get_lru_port(portlist) \u003d\u003e (exists port:Port \u0026 post_get_lru_port(portlist, port))))","finite set obligation:(((SIMULATIONEVENTLIST \u003c\u003e []) and ((forall se in set (elems SIMULATIONEVENTLIST) \u0026 (((se.occurtime) \u003e\u003d CLOCK) and ((se.eventhistory) \u003d nil))) and (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 (((trom.currentstate) \u003d get_initial_state(trom)) and (forall tc in set (trom.timeconstraints) \u0026 ((tc.reactionwindows) \u003d {})))))) \u003d\u003e ((SIMULATIONEVENTLIST \u003c\u003e []) \u003d\u003e ((forall se in set (elems SIMULATIONEVENTLIST) \u0026 (((se.occurtime) \u003e\u003d CLOCK) and ((se.eventhistory) \u003d nil))) \u003d\u003e (exists finmap1:map (nat) to (Trom) \u0026 (forall trom:Trom \u0026 (exists_in_subsystem(trom, SUBSYSTEM) \u003d\u003e (exists findex2 in set (dom finmap1) \u0026 (finmap1(findex2) \u003d trom))))))))","legal function application obligation:(((SIMULATIONEVENTLIST \u003c\u003e []) and ((forall se in set (elems SIMULATIONEVENTLIST) \u0026 (((se.occurtime) \u003e\u003d CLOCK) and ((se.eventhistory) \u003d nil))) and (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 (((trom.currentstate) \u003d get_initial_state(trom)) and (forall tc in set (trom.timeconstraints) \u0026 ((tc.reactionwindows) \u003d {})))))) \u003d\u003e ((SIMULATIONEVENTLIST \u003c\u003e []) \u003d\u003e ((forall se in set (elems SIMULATIONEVENTLIST) \u0026 (((se.occurtime) \u003e\u003d CLOCK) and ((se.eventhistory) \u003d nil))) \u003d\u003e (forall trom:Trom \u0026 pre_exists_in_subsystem(trom, SUBSYSTEM)))))","legal function application obligation:(((SIMULATIONEVENTLIST \u003c\u003e []) and ((forall se in set (elems SIMULATIONEVENTLIST) \u0026 (((se.occurtime) \u003e\u003d CLOCK) and ((se.eventhistory) \u003d nil))) and (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 (((trom.currentstate) \u003d get_initial_state(trom)) and (forall tc in set (trom.timeconstraints) \u0026 ((tc.reactionwindows) \u003d {})))))) \u003d\u003e ((SIMULATIONEVENTLIST \u003c\u003e []) \u003d\u003e ((forall se in set (elems SIMULATIONEVENTLIST) \u0026 (((se.occurtime) \u003e\u003d CLOCK) and ((se.eventhistory) \u003d nil))) \u003d\u003e (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 pre_get_initial_state(trom)))))","operation call obligation:(((SIMULATIONEVENTLIST \u003c\u003e []) and ((forall se in set (elems SIMULATIONEVENTLIST) \u0026 (((se.occurtime) \u003e\u003d CLOCK) and ((se.eventhistory) \u003d nil))) and (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 (((trom.currentstate) \u003d get_initial_state(trom)) and (forall tc in set (trom.timeconstraints) \u0026 ((tc.reactionwindows) \u003d {})))))) \u003d\u003e ((CLOCK \u003d 0) \u003d\u003e (CLOCK \u003d 0)))","while loop termination obligation:...","while loop termination obligation:...","legal sequence application obligation:(((SIMULATIONEVENTLIST \u003c\u003e []) and ((forall se in set (elems SIMULATIONEVENTLIST) \u0026 (((se.occurtime) \u003e\u003d CLOCK) and ((se.eventhistory) \u003d nil))) and (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 (((trom.currentstate) \u003d get_initial_state(trom)) and (forall tc in set (trom.timeconstraints) \u0026 ((tc.reactionwindows) \u003d {})))))) \u003d\u003e ((CLOCK \u003d 0) \u003d\u003e (((CLOCK \u003d 0) and (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 let event:[Event] \u003d get_unconstrained_internal_event(trom) in (((event \u003c\u003e nil) and let se:SimulationEvent be st (se \u003d mk_SimulationEvent((event.label), (trom.label), \"NULLPORT\", CLOCK, nil)) in ((se in set (elems SIMULATIONEVENTLIST)) and let i:nat1 be st (SIMULATIONEVENTLIST(i) \u003d se) in (forall se2 in set (elems SIMULATIONEVENTLIST~) \u0026 let j:nat1 be st (SIMULATIONEVENTLIST(j) \u003d se2) in (i \u003c j)))) or (event \u003d nil)))) \u003d\u003e (i in set (inds SIMULATIONEVENTLIST)))))","while loop termination obligation:...","legal sequence application obligation:(((SIMULATIONEVENTLIST \u003c\u003e []) and ((forall se in set (elems SIMULATIONEVENTLIST) \u0026 (((se.occurtime) \u003e\u003d CLOCK) and ((se.eventhistory) \u003d nil))) and (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 (((trom.currentstate) \u003d get_initial_state(trom)) and (forall tc in set (trom.timeconstraints) \u0026 ((tc.reactionwindows) \u003d {})))))) \u003d\u003e ((CLOCK \u003d 0) \u003d\u003e (((CLOCK \u003d 0) and (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 let event:[Event] \u003d get_unconstrained_internal_event(trom) in (((event \u003c\u003e nil) and let se:SimulationEvent be st (se \u003d mk_SimulationEvent((event.label), (trom.label), \"NULLPORT\", CLOCK, nil)) in ((se in set (elems SIMULATIONEVENTLIST)) and let i:nat1 be st (SIMULATIONEVENTLIST(i) \u003d se) in (forall se2 in set (elems SIMULATIONEVENTLIST~) \u0026 let j:nat1 be st (SIMULATIONEVENTLIST(j) \u003d se2) in (i \u003c j)))) or (event \u003d nil)))) \u003d\u003e ((CLOCK \u003d (CLOCK~ + 1)) \u003d\u003e ((i \u003c\u003d (len SIMULATIONEVENTLIST)) \u003d\u003e (i in set (inds SIMULATIONEVENTLIST)))))))","legal sequence application obligation:(((SIMULATIONEVENTLIST \u003c\u003e []) and ((forall se in set (elems SIMULATIONEVENTLIST) \u0026 (((se.occurtime) \u003e\u003d CLOCK) and ((se.eventhistory) \u003d nil))) and (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 (((trom.currentstate) \u003d get_initial_state(trom)) and (forall tc in set (trom.timeconstraints) \u0026 ((tc.reactionwindows) \u003d {})))))) \u003d\u003e ((CLOCK \u003d 0) \u003d\u003e (((CLOCK \u003d 0) and (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 let event:[Event] \u003d get_unconstrained_internal_event(trom) in (((event \u003c\u003e nil) and let se:SimulationEvent be st (se \u003d mk_SimulationEvent((event.label), (trom.label), \"NULLPORT\", CLOCK, nil)) in ((se in set (elems SIMULATIONEVENTLIST)) and let i:nat1 be st (SIMULATIONEVENTLIST(i) \u003d se) in (forall se2 in set (elems SIMULATIONEVENTLIST~) \u0026 let j:nat1 be st (SIMULATIONEVENTLIST(j) \u003d se2) in (i \u003c j)))) or (event \u003d nil)))) \u003d\u003e ((CLOCK \u003d (CLOCK~ + 1)) \u003d\u003e (i in set (inds SIMULATIONEVENTLIST))))))","operation call obligation:(((SIMULATIONEVENTLIST \u003c\u003e []) and ((forall se in set (elems SIMULATIONEVENTLIST) \u0026 (((se.occurtime) \u003e\u003d CLOCK) and ((se.eventhistory) \u003d nil))) and (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 (((trom.currentstate) \u003d get_initial_state(trom)) and (forall tc in set (trom.timeconstraints) \u0026 ((tc.reactionwindows) \u003d {})))))) \u003d\u003e ((CLOCK \u003d 0) \u003d\u003e (((CLOCK \u003d 0) and (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 let event:[Event] \u003d get_unconstrained_internal_event(trom) in (((event \u003c\u003e nil) and let se:SimulationEvent be st (se \u003d mk_SimulationEvent((event.label), (trom.label), \"NULLPORT\", CLOCK, nil)) in ((se in set (elems SIMULATIONEVENTLIST)) and let i:nat1 be st (SIMULATIONEVENTLIST(i) \u003d se) in (forall se2 in set (elems SIMULATIONEVENTLIST~) \u0026 let j:nat1 be st (SIMULATIONEVENTLIST(j) \u003d se2) in (i \u003c j)))) or (event \u003d nil)))) \u003d\u003e ((CLOCK \u003d (CLOCK~ + 1)) \u003d\u003e ((SIMULATIONEVENTLIST(i).occurtime) \u003d CLOCK)))))","state invariant holds obligation:(((SIMULATIONEVENTLIST \u003c\u003e []) and ((forall se in set (elems SIMULATIONEVENTLIST) \u0026 (((se.occurtime) \u003e\u003d CLOCK) and ((se.eventhistory) \u003d nil))) and (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 (((trom.currentstate) \u003d get_initial_state(trom)) and (forall tc in set (trom.timeconstraints) \u0026 ((tc.reactionwindows) \u003d {})))))) \u003d\u003e ((CLOCK \u003d 0) \u003d\u003e (((CLOCK \u003d 0) and (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 let event:[Event] \u003d get_unconstrained_internal_event(trom) in (((event \u003c\u003e nil) and let se:SimulationEvent be st (se \u003d mk_SimulationEvent((event.label), (trom.label), \"NULLPORT\", CLOCK, nil)) in ((se in set (elems SIMULATIONEVENTLIST)) and let i:nat1 be st (SIMULATIONEVENTLIST(i) \u003d se) in (forall se2 in set (elems SIMULATIONEVENTLIST~) \u0026 let j:nat1 be st (SIMULATIONEVENTLIST(j) \u003d se2) in (i \u003c j)))) or (event \u003d nil)))) \u003d\u003e ((CLOCK \u003d (CLOCK~ + 1)) \u003d\u003e ((CLOCK \u003d CLOCK~) \u003d\u003e let mk_System(subsystem, simulationeventlist, lsllibrary, clock) \u003d System in (let contains_trom: (Subsystem +\u003e bool)\n\tcontains_trom(subsys) \u003d\u003d\n(((subsys.troms) \u003c\u003e {}) or (exists1 s in set (subsys.includes) \u0026 contains_trom(s))) in contains_trom(subsystem) and (let contains_portlink: (Subsystem +\u003e bool)\n\tcontains_portlink(subsys) \u003d\u003d\n(((subsys.portlinks) \u003c\u003e {}) or (exists1 s in set (subsys.includes) \u0026 contains_portlink(s))) in contains_portlink(subsystem) and ((forall i, j in set (inds simulationeventlist) \u0026 (((i \u003d j) and (simulationeventlist(i) \u003d simulationeventlist(j))) or (((i \u003c j) and ((simulationeventlist(i).occurtime) \u003c\u003d (simulationeventlist(j).occurtime))) or ((i \u003e j) and ((simulationeventlist(i).occurtime) \u003e\u003d (simulationeventlist(j).occurtime)))))) and ((forall se1, se2 in set (elems simulationeventlist) \u0026 ((((se1.occurtime) \u003d (se2.occurtime)) and ((se1.tromlabel) \u003c\u003e (se2.tromlabel))) or ((se1.occurtime) \u003c\u003e (se2.occurtime)))) and (let accepted_by_trom: (SimulationEvent * Subsystem +\u003e bool)\n\taccepted_by_trom(se, subsys) \u003d\u003d\n(exists1 trom in set (subsys.troms) \u0026 (((trom.label) \u003d (se.tromlabel)) and (exists1 e in set (trom.events) \u0026 (((e.label) \u003d (se.eventlabel)) and (exists1 pt in set (trom.porttypes) \u0026 ((pt \u003d (e.porttype)) and (exists1 p in set (elems (pt.portlist)) \u0026 ((p.label) \u003d (se.portlabel))))))))) in let accepted_by_subsystem: (SimulationEvent * Subsystem +\u003e bool)\n\taccepted_by_subsystem(se, subsys) \u003d\u003d\n(exists1 s in set (subsys.includes) \u0026 (((accepted_by_trom(se, s) and (not accepted_by_subsystem(se, s))) or ((not accepted_by_trom(se, s)) and accepted_by_subsystem(se, s))) and (forall s2 in set {su | su:Subsystem \u0026 ((su in set (subsys.includes)) and (su \u003c\u003e s))} \u0026 ((not accepted_by_trom(se, s2)) and (not accepted_by_subsystem(se, s2)))))) in (forall se in set (elems simulationeventlist) \u0026 ((accepted_by_trom(se, subsystem) and (not accepted_by_subsystem(se, subsystem))) or ((not accepted_by_trom(se, subsystem)) and accepted_by_subsystem(se, subsystem)))) and let exists_lsltrait: (Subsystem +\u003e bool)\n\texists_lsltrait(subsys) \u003d\u003d\n((forall trom in set (subsys.troms) \u0026 (forall tr in set (trom.lsltraits) \u0026 (exists traitdef in set lsllibrary \u0026 ((traitdef.label) \u003d (tr.traitlabel))))) and (forall s in set (subsys.includes) \u0026 exists_lsltrait(s))) in exists_lsltrait(subsystem)))))))))))","legal sequence application obligation:(((SIMULATIONEVENTLIST \u003c\u003e []) and ((forall se in set (elems SIMULATIONEVENTLIST) \u0026 (((se.occurtime) \u003e\u003d CLOCK) and ((se.eventhistory) \u003d nil))) and (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 (((trom.currentstate) \u003d get_initial_state(trom)) and (forall tc in set (trom.timeconstraints) \u0026 ((tc.reactionwindows) \u003d {})))))) \u003d\u003e ((CLOCK \u003d 0) \u003d\u003e (((CLOCK \u003d 0) and (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 let event:[Event] \u003d get_unconstrained_internal_event(trom) in (((event \u003c\u003e nil) and let se:SimulationEvent be st (se \u003d mk_SimulationEvent((event.label), (trom.label), \"NULLPORT\", CLOCK, nil)) in ((se in set (elems SIMULATIONEVENTLIST)) and let i:nat1 be st (SIMULATIONEVENTLIST(i) \u003d se) in (forall se2 in set (elems SIMULATIONEVENTLIST~) \u0026 let j:nat1 be st (SIMULATIONEVENTLIST(j) \u003d se2) in (i \u003c j)))) or (event \u003d nil)))) \u003d\u003e ((CLOCK \u003d (CLOCK~ + 1)) \u003d\u003e ((CLOCK \u003d CLOCK~) \u003d\u003e ((SIMULATIONEVENTLIST \u003c\u003e []) \u003d\u003e ((len SIMULATIONEVENTLIST) in set (inds SIMULATIONEVENTLIST))))))))","finite set obligation:(((SIMULATIONEVENTLIST \u003c\u003e []) and ((forall se in set (elems SIMULATIONEVENTLIST) \u0026 (((se.occurtime) \u003e\u003d CLOCK) and ((se.eventhistory) \u003d nil))) and (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 (((trom.currentstate) \u003d get_initial_state(trom)) and (forall tc in set (trom.timeconstraints) \u0026 ((tc.reactionwindows) \u003d {})))))) \u003d\u003e ((CLOCK \u003d 0) \u003d\u003e (((CLOCK \u003d 0) and (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 let event:[Event] \u003d get_unconstrained_internal_event(trom) in (((event \u003c\u003e nil) and let se:SimulationEvent be st (se \u003d mk_SimulationEvent((event.label), (trom.label), \"NULLPORT\", CLOCK, nil)) in ((se in set (elems SIMULATIONEVENTLIST)) and let i:nat1 be st (SIMULATIONEVENTLIST(i) \u003d se) in (forall se2 in set (elems SIMULATIONEVENTLIST~) \u0026 let j:nat1 be st (SIMULATIONEVENTLIST(j) \u003d se2) in (i \u003c j)))) or (event \u003d nil)))) \u003d\u003e ((CLOCK \u003d (CLOCK~ + 1)) \u003d\u003e ((CLOCK \u003d CLOCK~) \u003d\u003e ((SIMULATIONEVENTLIST \u003c\u003e []) \u003d\u003e (((SIMULATIONEVENTLIST((len SIMULATIONEVENTLIST)).occurtime) \u003d CLOCK) \u003d\u003e ((forall se in set (elems SIMULATIONEVENTLIST) \u0026 (((se.occurtime) \u003c\u003d CLOCK) and ((se.eventhistory) \u003c\u003e nil))) \u003d\u003e (exists finmap1:map (nat) to (Trom) \u0026 (forall trom:Trom \u0026 (exists_in_subsystem(trom, SUBSYSTEM) \u003d\u003e (exists findex2 in set (dom finmap1) \u0026 (finmap1(findex2) \u003d trom)))))))))))))","legal function application obligation:(((SIMULATIONEVENTLIST \u003c\u003e []) and ((forall se in set (elems SIMULATIONEVENTLIST) \u0026 (((se.occurtime) \u003e\u003d CLOCK) and ((se.eventhistory) \u003d nil))) and (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 (((trom.currentstate) \u003d get_initial_state(trom)) and (forall tc in set (trom.timeconstraints) \u0026 ((tc.reactionwindows) \u003d {})))))) \u003d\u003e ((CLOCK \u003d 0) \u003d\u003e (((CLOCK \u003d 0) and (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 let event:[Event] \u003d get_unconstrained_internal_event(trom) in (((event \u003c\u003e nil) and let se:SimulationEvent be st (se \u003d mk_SimulationEvent((event.label), (trom.label), \"NULLPORT\", CLOCK, nil)) in ((se in set (elems SIMULATIONEVENTLIST)) and let i:nat1 be st (SIMULATIONEVENTLIST(i) \u003d se) in (forall se2 in set (elems SIMULATIONEVENTLIST~) \u0026 let j:nat1 be st (SIMULATIONEVENTLIST(j) \u003d se2) in (i \u003c j)))) or (event \u003d nil)))) \u003d\u003e ((CLOCK \u003d (CLOCK~ + 1)) \u003d\u003e ((CLOCK \u003d CLOCK~) \u003d\u003e ((SIMULATIONEVENTLIST \u003c\u003e []) \u003d\u003e (((SIMULATIONEVENTLIST((len SIMULATIONEVENTLIST)).occurtime) \u003d CLOCK) \u003d\u003e ((forall se in set (elems SIMULATIONEVENTLIST) \u0026 (((se.occurtime) \u003c\u003d CLOCK) and ((se.eventhistory) \u003c\u003e nil))) \u003d\u003e (forall trom:Trom \u0026 pre_exists_in_subsystem(trom, SUBSYSTEM))))))))))","operation establishes postcondition obligation:(((SIMULATIONEVENTLIST \u003c\u003e []) and ((forall se in set (elems SIMULATIONEVENTLIST) \u0026 (((se.occurtime) \u003e\u003d CLOCK) and ((se.eventhistory) \u003d nil))) and (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 (((trom.currentstate) \u003d get_initial_state(trom)) and (forall tc in set (trom.timeconstraints) \u0026 ((tc.reactionwindows) \u003d {})))))) \u003d\u003e ((CLOCK \u003d 0) \u003d\u003e (((CLOCK \u003d 0) and (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 let event:[Event] \u003d get_unconstrained_internal_event(trom) in (((event \u003c\u003e nil) and let se:SimulationEvent be st (se \u003d mk_SimulationEvent((event.label), (trom.label), \"NULLPORT\", CLOCK, nil)) in ((se in set (elems SIMULATIONEVENTLIST)) and let i:nat1 be st (SIMULATIONEVENTLIST(i) \u003d se) in (forall se2 in set (elems SIMULATIONEVENTLIST~) \u0026 let j:nat1 be st (SIMULATIONEVENTLIST(j) \u003d se2) in (i \u003c j)))) or (event \u003d nil)))) \u003d\u003e ((CLOCK \u003d (CLOCK~ + 1)) \u003d\u003e ((CLOCK \u003d CLOCK~) \u003d\u003e ((SIMULATIONEVENTLIST \u003c\u003e []) and (((SIMULATIONEVENTLIST((len SIMULATIONEVENTLIST)).occurtime) \u003d CLOCK) and ((forall se in set (elems SIMULATIONEVENTLIST) \u0026 (((se.occurtime) \u003c\u003d CLOCK) and ((se.eventhistory) \u003c\u003e nil))) and (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 (forall tc in set (trom.timeconstraints) \u0026 ((tc.reactionwindows) \u003d {})))))))))))","state invariant holds obligation:(forall se:SimulationEvent, oldstate:System \u0026 (((se.occurtime) \u003d CLOCK) \u003d\u003e let mk_System(subsystem, simulationeventlist, lsllibrary, clock) \u003d System in (let contains_trom: (Subsystem +\u003e bool)\n\tcontains_trom(subsys) \u003d\u003d\n(((subsys.troms) \u003c\u003e {}) or (exists1 s in set (subsys.includes) \u0026 contains_trom(s))) in contains_trom(subsystem) and (let contains_portlink: (Subsystem +\u003e bool)\n\tcontains_portlink(subsys) \u003d\u003d\n(((subsys.portlinks) \u003c\u003e {}) or (exists1 s in set (subsys.includes) \u0026 contains_portlink(s))) in contains_portlink(subsystem) and ((forall i, j in set (inds simulationeventlist) \u0026 (((i \u003d j) and (simulationeventlist(i) \u003d simulationeventlist(j))) or (((i \u003c j) and ((simulationeventlist(i).occurtime) \u003c\u003d (simulationeventlist(j).occurtime))) or ((i \u003e j) and ((simulationeventlist(i).occurtime) \u003e\u003d (simulationeventlist(j).occurtime)))))) and ((forall se1, se2 in set (elems simulationeventlist) \u0026 ((((se1.occurtime) \u003d (se2.occurtime)) and ((se1.tromlabel) \u003c\u003e (se2.tromlabel))) or ((se1.occurtime) \u003c\u003e (se2.occurtime)))) and (let accepted_by_trom: (SimulationEvent * Subsystem +\u003e bool)\n\taccepted_by_trom(se, subsys) \u003d\u003d\n(exists1 trom in set (subsys.troms) \u0026 (((trom.label) \u003d (se.tromlabel)) and (exists1 e in set (trom.events) \u0026 (((e.label) \u003d (se.eventlabel)) and (exists1 pt in set (trom.porttypes) \u0026 ((pt \u003d (e.porttype)) and (exists1 p in set (elems (pt.portlist)) \u0026 ((p.label) \u003d (se.portlabel))))))))) in let accepted_by_subsystem: (SimulationEvent * Subsystem +\u003e bool)\n\taccepted_by_subsystem(se, subsys) \u003d\u003d\n(exists1 s in set (subsys.includes) \u0026 (((accepted_by_trom(se, s) and (not accepted_by_subsystem(se, s))) or ((not accepted_by_trom(se, s)) and accepted_by_subsystem(se, s))) and (forall s2 in set {su | su:Subsystem \u0026 ((su in set (subsys.includes)) and (su \u003c\u003e s))} \u0026 ((not accepted_by_trom(se, s2)) and (not accepted_by_subsystem(se, s2)))))) in (forall se in set (elems simulationeventlist) \u0026 ((accepted_by_trom(se, subsystem) and (not accepted_by_subsystem(se, subsystem))) or ((not accepted_by_trom(se, subsystem)) and accepted_by_subsystem(se, subsystem)))) and let exists_lsltrait: (Subsystem +\u003e bool)\n\texists_lsltrait(subsys) \u003d\u003d\n((forall trom in set (subsys.troms) \u0026 (forall tr in set (trom.lsltraits) \u0026 (exists traitdef in set lsllibrary \u0026 ((traitdef.label) \u003d (tr.traitlabel))))) and (forall s in set (subsys.includes) \u0026 exists_lsltrait(s))) in exists_lsltrait(subsystem))))))))","state invariant holds obligation:(forall se:SimulationEvent, oldstate:System \u0026 (((se.occurtime) \u003d CLOCK) \u003d\u003e let mk_System(subsystem, simulationeventlist, lsllibrary, clock) \u003d System in (let contains_trom: (Subsystem +\u003e bool)\n\tcontains_trom(subsys) \u003d\u003d\n(((subsys.troms) \u003c\u003e {}) or (exists1 s in set (subsys.includes) \u0026 contains_trom(s))) in contains_trom(subsystem) and (let contains_portlink: (Subsystem +\u003e bool)\n\tcontains_portlink(subsys) \u003d\u003d\n(((subsys.portlinks) \u003c\u003e {}) or (exists1 s in set (subsys.includes) \u0026 contains_portlink(s))) in contains_portlink(subsystem) and ((forall i, j in set (inds simulationeventlist) \u0026 (((i \u003d j) and (simulationeventlist(i) \u003d simulationeventlist(j))) or (((i \u003c j) and ((simulationeventlist(i).occurtime) \u003c\u003d (simulationeventlist(j).occurtime))) or ((i \u003e j) and ((simulationeventlist(i).occurtime) \u003e\u003d (simulationeventlist(j).occurtime)))))) and ((forall se1, se2 in set (elems simulationeventlist) \u0026 ((((se1.occurtime) \u003d (se2.occurtime)) and ((se1.tromlabel) \u003c\u003e (se2.tromlabel))) or ((se1.occurtime) \u003c\u003e (se2.occurtime)))) and (let accepted_by_trom: (SimulationEvent * Subsystem +\u003e bool)\n\taccepted_by_trom(se, subsys) \u003d\u003d\n(exists1 trom in set (subsys.troms) \u0026 (((trom.label) \u003d (se.tromlabel)) and (exists1 e in set (trom.events) \u0026 (((e.label) \u003d (se.eventlabel)) and (exists1 pt in set (trom.porttypes) \u0026 ((pt \u003d (e.porttype)) and (exists1 p in set (elems (pt.portlist)) \u0026 ((p.label) \u003d (se.portlabel))))))))) in let accepted_by_subsystem: (SimulationEvent * Subsystem +\u003e bool)\n\taccepted_by_subsystem(se, subsys) \u003d\u003d\n(exists1 s in set (subsys.includes) \u0026 (((accepted_by_trom(se, s) and (not accepted_by_subsystem(se, s))) or ((not accepted_by_trom(se, s)) and accepted_by_subsystem(se, s))) and (forall s2 in set {su | su:Subsystem \u0026 ((su in set (subsys.includes)) and (su \u003c\u003e s))} \u0026 ((not accepted_by_trom(se, s2)) and (not accepted_by_subsystem(se, s2)))))) in (forall se in set (elems simulationeventlist) \u0026 ((accepted_by_trom(se, subsystem) and (not accepted_by_subsystem(se, subsystem))) or ((not accepted_by_trom(se, subsystem)) and accepted_by_subsystem(se, subsystem)))) and let exists_lsltrait: (Subsystem +\u003e bool)\n\texists_lsltrait(subsys) \u003d\u003d\n((forall trom in set (subsys.troms) \u0026 (forall tr in set (trom.lsltraits) \u0026 (exists traitdef in set lsllibrary \u0026 ((traitdef.label) \u003d (tr.traitlabel))))) and (forall s in set (subsys.includes) \u0026 exists_lsltrait(s))) in exists_lsltrait(subsystem))))))))","legal function application obligation:(forall se:SimulationEvent, oldstate:System \u0026 (((se.occurtime) \u003d CLOCK) \u003d\u003e pre_get_transition_spec(trom, se)))","type compatibility obligation:(forall se:SimulationEvent, oldstate:System \u0026 (((se.occurtime) \u003d CLOCK) \u003d\u003e (inv_Trom(trom) and is_(trom, Trom))))","operation call obligation:(forall se:SimulationEvent, oldstate:System \u0026 (((se.occurtime) \u003d CLOCK) \u003d\u003e ((get_trom_object((se.tromlabel), SUBSYSTEM) \u003d nil) or ((get_trom_object((se.tromlabel), SUBSYSTEM).postcondition) \u003d false))))","operation call obligation:(forall se:SimulationEvent, oldstate:System \u0026 (((se.occurtime) \u003d CLOCK) \u003d\u003e (((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).triggeredtransition) \u003d false) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).tromcurrentstate) \u003d nil) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).assignmentvector) \u003d nil) and (((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).reactionshistory) \u003d {})))) \u003d\u003e (get_trom_object((se.tromlabel), SUBSYSTEM) \u003c\u003e nil))))","operation call obligation:(forall se:SimulationEvent, oldstate:System \u0026 (((se.occurtime) \u003d CLOCK) \u003d\u003e (((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).triggeredtransition) \u003d false) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).tromcurrentstate) \u003d nil) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).assignmentvector) \u003d nil) and (((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).reactionshistory) \u003d {})))) \u003d\u003e ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).assignmentvector) \u003d (get_trom_object((se.tromlabel), SUBSYSTEM).assignmentvector)) \u003d\u003e ((get_trom_object((se.tromlabel), SUBSYSTEM) \u003d nil) or ((get_trom_object((se.tromlabel), SUBSYSTEM).postcondition) \u003d false))))))","operation call obligation:(forall se:SimulationEvent, oldstate:System \u0026 (((se.occurtime) \u003d CLOCK) \u003d\u003e (((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).triggeredtransition) \u003d false) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).tromcurrentstate) \u003d nil) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).assignmentvector) \u003d nil) and (((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).reactionshistory) \u003d {})))) \u003d\u003e ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).assignmentvector) \u003d (get_trom_object((se.tromlabel), SUBSYSTEM).assignmentvector)) \u003d\u003e (((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).triggeredtransition) \u003d false) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).tromcurrentstate) \u003d nil) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).assignmentvector) \u003d nil) and (((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).reactionshistory) \u003d {})))) \u003d\u003e ((get_trom_object((se.tromlabel), SUBSYSTEM).postcondition) \u003d true))))))","operation call obligation:(forall se:SimulationEvent, oldstate:System \u0026 (((se.occurtime) \u003d CLOCK) \u003d\u003e (((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).triggeredtransition) \u003d false) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).tromcurrentstate) \u003d nil) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).assignmentvector) \u003d nil) and (((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).reactionshistory) \u003d {})))) \u003d\u003e ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).assignmentvector) \u003d (get_trom_object((se.tromlabel), SUBSYSTEM).assignmentvector)) \u003d\u003e (((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).triggeredtransition) \u003d false) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).tromcurrentstate) \u003d nil) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).assignmentvector) \u003d nil) and (((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).reactionshistory) \u003d {})))) \u003d\u003e (((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).triggeredtransition) \u003d true) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).tromcurrentstate) \u003d (get_trom_object((se.tromlabel), SUBSYSTEM).currentstate)) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).assignmentvector) \u003d (get_trom_object((se.tromlabel), SUBSYSTEM).assignmentvector)) and (((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).reactionshistory) \u003d {})))) \u003d\u003e ((get_trom_object((se.tromlabel), SUBSYSTEM).postcondition) \u003d true)))))))","operation call obligation:(forall se:SimulationEvent, oldstate:System \u0026 (((se.occurtime) \u003d CLOCK) \u003d\u003e (((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).triggeredtransition) \u003d false) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).tromcurrentstate) \u003d nil) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).assignmentvector) \u003d nil) and (((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).reactionshistory) \u003d {})))) \u003d\u003e ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).assignmentvector) \u003d (get_trom_object((se.tromlabel), SUBSYSTEM).assignmentvector)) \u003d\u003e (((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).triggeredtransition) \u003d false) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).tromcurrentstate) \u003d nil) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).assignmentvector) \u003d nil) and (((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).reactionshistory) \u003d {})))) \u003d\u003e (((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).triggeredtransition) \u003d true) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).tromcurrentstate) \u003d (get_trom_object((se.tromlabel), SUBSYSTEM).currentstate)) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).assignmentvector) \u003d (get_trom_object((se.tromlabel), SUBSYSTEM).assignmentvector)) and (((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).reactionshistory) \u003d {})))) \u003d\u003e ((((((get_trom_object((se.tromlabel), SUBSYSTEM).destinstate).type) \u003d \u003cSIMPLE\u003e) and ((get_trom_object((se.tromlabel), SUBSYSTEM).currentstate) \u003d (get_trom_object((se.tromlabel), SUBSYSTEM).destinstate))) or ((((get_trom_object((se.tromlabel), SUBSYSTEM).destinstate).type) \u003d \u003cCOMPLEX\u003e) and ((get_trom_object((se.tromlabel), SUBSYSTEM).currentstate) \u003d get_entry_state((ts.destinstate))))) \u003d\u003e ((get_trom_object((se.tromlabel), SUBSYSTEM).occurtime) \u003d CLOCK))))))))","operation call obligation:(forall se:SimulationEvent, oldstate:System \u0026 (((se.occurtime) \u003d CLOCK) \u003d\u003e (((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).triggeredtransition) \u003d false) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).tromcurrentstate) \u003d nil) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).assignmentvector) \u003d nil) and (((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).reactionshistory) \u003d {})))) \u003d\u003e ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).assignmentvector) \u003d (get_trom_object((se.tromlabel), SUBSYSTEM).assignmentvector)) \u003d\u003e (((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).triggeredtransition) \u003d false) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).tromcurrentstate) \u003d nil) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).assignmentvector) \u003d nil) and (((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).reactionshistory) \u003d {})))) \u003d\u003e (((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).triggeredtransition) \u003d true) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).tromcurrentstate) \u003d (get_trom_object((se.tromlabel), SUBSYSTEM).currentstate)) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).assignmentvector) \u003d (get_trom_object((se.tromlabel), SUBSYSTEM).assignmentvector)) and (((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).reactionshistory) \u003d {})))) \u003d\u003e ((((((get_trom_object((se.tromlabel), SUBSYSTEM).destinstate).type) \u003d \u003cSIMPLE\u003e) and ((get_trom_object((se.tromlabel), SUBSYSTEM).currentstate) \u003d (get_trom_object((se.tromlabel), SUBSYSTEM).destinstate))) or ((((get_trom_object((se.tromlabel), SUBSYSTEM).destinstate).type) \u003d \u003cCOMPLEX\u003e) and ((get_trom_object((se.tromlabel), SUBSYSTEM).currentstate) \u003d get_entry_state((ts.destinstate))))) \u003d\u003e ((CLOCK \u003d CLOCK~) \u003d\u003e ((get_trom_object((se.tromlabel), SUBSYSTEM) in set (elems SIMULATIONEVENTLIST)) and ((get_trom_object((se.tromlabel), SUBSYSTEM).tromlabel) \u003d (get_trom_object((se.tromlabel), SUBSYSTEM).label)))))))))))","operation establishes postcondition obligation:(forall se:SimulationEvent, oldstate:System \u0026 (((se.occurtime) \u003d CLOCK) \u003d\u003e (((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).triggeredtransition) \u003d false) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).tromcurrentstate) \u003d nil) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).assignmentvector) \u003d nil) and (((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).reactionshistory) \u003d {})))) \u003d\u003e ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).assignmentvector) \u003d (get_trom_object((se.tromlabel), SUBSYSTEM).assignmentvector)) \u003d\u003e (((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).triggeredtransition) \u003d false) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).tromcurrentstate) \u003d nil) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).assignmentvector) \u003d nil) and (((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).reactionshistory) \u003d {})))) \u003d\u003e (((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).triggeredtransition) \u003d true) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).tromcurrentstate) \u003d (get_trom_object((se.tromlabel), SUBSYSTEM).currentstate)) and ((((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).assignmentvector) \u003d (get_trom_object((se.tromlabel), SUBSYSTEM).assignmentvector)) and (((get_trom_object((se.tromlabel), SUBSYSTEM).eventhistory).reactionshistory) \u003d {})))) \u003d\u003e ((((((get_trom_object((se.tromlabel), SUBSYSTEM).destinstate).type) \u003d \u003cSIMPLE\u003e) and ((get_trom_object((se.tromlabel), SUBSYSTEM).currentstate) \u003d (get_trom_object((se.tromlabel), SUBSYSTEM).destinstate))) or ((((get_trom_object((se.tromlabel), SUBSYSTEM).destinstate).type) \u003d \u003cCOMPLEX\u003e) and ((get_trom_object((se.tromlabel), SUBSYSTEM).currentstate) \u003d get_entry_state((ts.destinstate))))) \u003d\u003e ((CLOCK \u003d CLOCK~) \u003d\u003e (let event:[Event] \u003d get_unconstrained_internal_event(trom) in (((event \u003c\u003e nil) and let j:nat1 be st (j \u003d get_simevent_index(se, SIMULATIONEVENTLIST)) in let se2:SimulationEvent be st (se2 \u003d mk_SimulationEvent((event.label), (trom.label), \"NULLPORT\", CLOCK, nil)) in (SIMULATIONEVENTLIST \u003d (([SIMULATIONEVENTLIST~(i) | i in set (inds SIMULATIONEVENTLIST~) \u0026 (i \u003c\u003d j)] ^ [se2]) ^ [SIMULATIONEVENTLIST~(i) | i in set (inds SIMULATIONEVENTLIST~) \u0026 (i \u003e j)]))) or (event \u003d nil)) \u003d\u003e (CLOCK \u003d CLOCK~))))))))))","operation call obligation:(forall trom:Trom, se:SimulationEvent, ts:TransitionSpec, oldstate:System \u0026 (((se.occurtime) \u003d CLOCK) \u003d\u003e ((((trom.constrainedevent).label) \u003d (trom.eventlabel)) and ((trom in set (trom.reactionwindows)) and (((trom.occurtime) \u003e\u003d (trom.lowertimebound)) and ((trom.occurtime) \u003c\u003d (trom.uppertimebound)))))))","operation call obligation:(forall trom:Trom, se:SimulationEvent, ts:TransitionSpec, oldstate:System \u0026 (((se.occurtime) \u003d CLOCK) \u003d\u003e ((exists rh in set ((se.eventhistory).reactionshistory) \u0026 (((rh.timeconstraint) \u003d trom) and (((rh.reactionwindow) \u003d trom) and ((rh.reaction) \u003d \u003cFIRED\u003e)))) \u003d\u003e ((((trom.constrainedevent).label) \u003d (trom.eventlabel)) and ((trom in set (trom.reactionwindows)) and (((trom.occurtime) \u003e\u003d (trom.lowertimebound)) and ((trom.occurtime) \u003c\u003d (trom.uppertimebound))))))))","operation call obligation:(forall trom:Trom, se:SimulationEvent, ts:TransitionSpec, oldstate:System \u0026 (((se.occurtime) \u003d CLOCK) \u003d\u003e ((exists rh in set ((se.eventhistory).reactionshistory) \u0026 (((rh.timeconstraint) \u003d trom) and (((rh.reactionwindow) \u003d trom) and ((rh.reaction) \u003d \u003cFIRED\u003e)))) \u003d\u003e ((trom not in set (trom.reactionwindows)) \u003d\u003e (((trom.currentstate) in set (trom.disablingstates)) and (trom in set (trom.reactionwindows)))))))","operation call obligation:(forall trom:Trom, se:SimulationEvent, ts:TransitionSpec, oldstate:System \u0026 (((se.occurtime) \u003d CLOCK) \u003d\u003e ((exists rh in set ((se.eventhistory).reactionshistory) \u0026 (((rh.timeconstraint) \u003d trom) and (((rh.reactionwindow) \u003d trom) and ((rh.reaction) \u003d \u003cFIRED\u003e)))) \u003d\u003e ((trom not in set (trom.reactionwindows)) \u003d\u003e ((exists rh in set ((se.eventhistory).reactionshistory) \u0026 (((rh.timeconstraint) \u003d trom) and (((rh.reactionwindow) \u003d trom) and ((rh.reaction) \u003d \u003cDISABLED\u003e)))) \u003d\u003e (((trom.currentstate) in set (trom.disablingstates)) and (trom in set (trom.reactionwindows))))))))","operation call obligation:(forall trom:Trom, se:SimulationEvent, ts:TransitionSpec, oldstate:System \u0026 (((se.occurtime) \u003d CLOCK) \u003d\u003e ((exists rh in set ((se.eventhistory).reactionshistory) \u0026 (((rh.timeconstraint) \u003d trom) and (((rh.reactionwindow) \u003d trom) and ((rh.reaction) \u003d \u003cFIRED\u003e)))) \u003d\u003e ((trom not in set (trom.reactionwindows)) \u003d\u003e ((exists rh in set ((se.eventhistory).reactionshistory) \u0026 (((rh.timeconstraint) \u003d trom) and (((rh.reactionwindow) \u003d trom) and ((rh.reaction) \u003d \u003cDISABLED\u003e)))) \u003d\u003e (((trom not in set (trom.reactionwindows)) and let se2:SimulationEvent be st (se2 \u003d get_enabled_simevent(trom, tc)) in (((((tc.constrainedevent).type) \u003d \u003cINTERNAL\u003e) and (SIMULATIONEVENTLIST \u003d [SIMULATIONEVENTLIST~(i) | i in set (inds SIMULATIONEVENTLIST~) \u0026 (SIMULATIONEVENTLIST~(i) \u003c\u003e se2)])) or ((((tc.constrainedevent).type) \u003d \u003cOUTPUT\u003e) and let tromporttuple:[TromPortTuple] be st (tromporttuple \u003d get_linked_tromport_tuple(mk_TromPortTuple((se2.tromlabel), (se2.portlabel)), SUBSYSTEM)) in let se3:SimulationEvent be st (se3 \u003d get_enabled_simevent_synch(tromporttuple, tc)) in (SIMULATIONEVENTLIST \u003d [SIMULATIONEVENTLIST~(i) | i in set (inds SIMULATIONEVENTLIST~) \u0026 ((SIMULATIONEVENTLIST~(i) \u003c\u003e se2) and (SIMULATIONEVENTLIST~(i) \u003c\u003e se3))])))) \u003d\u003e ((trom.label) \u003d ((trom.transition).label))))))))","operation call obligation:(forall trom:Trom, se:SimulationEvent, ts:TransitionSpec, oldstate:System \u0026 (((se.occurtime) \u003d CLOCK) \u003d\u003e ((exists rh in set ((se.eventhistory).reactionshistory) \u0026 (((rh.timeconstraint) \u003d trom) and (((rh.reactionwindow) \u003d trom) and ((rh.reaction) \u003d \u003cFIRED\u003e)))) \u003d\u003e ((trom not in set (trom.reactionwindows)) \u003d\u003e ((exists rh in set ((se.eventhistory).reactionshistory) \u0026 (((rh.timeconstraint) \u003d trom) and (((rh.reactionwindow) \u003d trom) and ((rh.reaction) \u003d \u003cDISABLED\u003e)))) \u003d\u003e (((trom not in set (trom.reactionwindows)) and let se2:SimulationEvent be st (se2 \u003d get_enabled_simevent(trom, tc)) in (((((tc.constrainedevent).type) \u003d \u003cINTERNAL\u003e) and (SIMULATIONEVENTLIST \u003d [SIMULATIONEVENTLIST~(i) | i in set (inds SIMULATIONEVENTLIST~) \u0026 (SIMULATIONEVENTLIST~(i) \u003c\u003e se2)])) or ((((tc.constrainedevent).type) \u003d \u003cOUTPUT\u003e) and let tromporttuple:[TromPortTuple] be st (tromporttuple \u003d get_linked_tromport_tuple(mk_TromPortTuple((se2.tromlabel), (se2.portlabel)), SUBSYSTEM)) in let se3:SimulationEvent be st (se3 \u003d get_enabled_simevent_synch(tromporttuple, tc)) in (SIMULATIONEVENTLIST \u003d [SIMULATIONEVENTLIST~(i) | i in set (inds SIMULATIONEVENTLIST~) \u0026 ((SIMULATIONEVENTLIST~(i) \u003c\u003e se2) and (SIMULATIONEVENTLIST~(i) \u003c\u003e se3))])))) \u003d\u003e (let rw:ReactionWindow be st (rw \u003d mk_ReactionWindow((((tc.timebounds).lowertimebound) + CLOCK), (((tc.timebounds).uppertimebound) + CLOCK))) in (exists rh in set ((se.eventhistory).reactionshistory) \u0026 (((rh.timeconstraint) \u003d tc) and (((rh.reactionwindow) \u003d rw) and ((rh.reaction) \u003d \u003cENABLED\u003e)))) \u003d\u003e ((trom.label) \u003d ((trom.transition).label)))))))))","operation establishes postcondition obligation:(forall trom:Trom, se:SimulationEvent, ts:TransitionSpec, oldstate:System \u0026 (((se.occurtime) \u003d CLOCK) \u003d\u003e ((exists rh in set ((se.eventhistory).reactionshistory) \u0026 (((rh.timeconstraint) \u003d trom) and (((rh.reactionwindow) \u003d trom) and ((rh.reaction) \u003d \u003cFIRED\u003e)))) \u003d\u003e ((trom not in set (trom.reactionwindows)) \u003d\u003e ((exists rh in set ((se.eventhistory).reactionshistory) \u0026 (((rh.timeconstraint) \u003d trom) and (((rh.reactionwindow) \u003d trom) and ((rh.reaction) \u003d \u003cDISABLED\u003e)))) \u003d\u003e (((trom not in set (trom.reactionwindows)) and let se2:SimulationEvent be st (se2 \u003d get_enabled_simevent(trom, tc)) in (((((tc.constrainedevent).type) \u003d \u003cINTERNAL\u003e) and (SIMULATIONEVENTLIST \u003d [SIMULATIONEVENTLIST~(i) | i in set (inds SIMULATIONEVENTLIST~) \u0026 (SIMULATIONEVENTLIST~(i) \u003c\u003e se2)])) or ((((tc.constrainedevent).type) \u003d \u003cOUTPUT\u003e) and let tromporttuple:[TromPortTuple] be st (tromporttuple \u003d get_linked_tromport_tuple(mk_TromPortTuple((se2.tromlabel), (se2.portlabel)), SUBSYSTEM)) in let se3:SimulationEvent be st (se3 \u003d get_enabled_simevent_synch(tromporttuple, tc)) in (SIMULATIONEVENTLIST \u003d [SIMULATIONEVENTLIST~(i) | i in set (inds SIMULATIONEVENTLIST~) \u0026 ((SIMULATIONEVENTLIST~(i) \u003c\u003e se2) and (SIMULATIONEVENTLIST~(i) \u003c\u003e se3))])))) \u003d\u003e (let rw:ReactionWindow be st (rw \u003d mk_ReactionWindow((((tc.timebounds).lowertimebound) + CLOCK), (((tc.timebounds).uppertimebound) + CLOCK))) in (exists rh in set ((se.eventhistory).reactionshistory) \u0026 (((rh.timeconstraint) \u003d tc) and (((rh.reactionwindow) \u003d rw) and ((rh.reaction) \u003d \u003cENABLED\u003e)))) \u003d\u003e (let rw:ReactionWindow be st (rw \u003d mk_ReactionWindow((((tc.timebounds).lowertimebound) + CLOCK), (((tc.timebounds).uppertimebound) + CLOCK))) in let port:Port be st (port \u003d get_lru_port((((tc.constrainedevent).porttype).portlist))) in let occurtime:nat be st (occurtime \u003d get_random_time_within_rw(rw)) in let se2:SimulationEvent be st (se2 \u003d mk_SimulationEvent(((tc.constrainedevent).label), (trom.label), (port.label), occurtime, nil)) in ((rw in set (tc.reactionwindows)) and ((se2 in set (elems SIMULATIONEVENTLIST)) and (((((tc.constrainedevent).type) \u003d \u003cOUTPUT\u003e) and let tromporttuple:[TromPortTuple] be st (tromporttuple \u003d get_linked_tromport_tuple(mk_TromPortTuple((se2.tromlabel), (se2.portlabel)), SUBSYSTEM)) in (((tromporttuple \u003c\u003e nil) and let se3:SimulationEvent be st (se3 \u003d mk_SimulationEvent((se2.eventlabel), (tromporttuple.tromlabel), (tromporttuple.portlabel), (se2.occurtime), nil)) in (se3 in set (elems SIMULATIONEVENTLIST))) or (tromporttuple \u003d nil))) or (((tc.constrainedevent).type) \u003d \u003cINTERNAL\u003e)))) \u003d\u003e (CLOCK \u003d CLOCK~)))))))))","legal function application obligation:(((ts.postcondition) \u003d true) \u003d\u003e ((not ((((trom.destinstate).type) \u003d \u003cSIMPLE\u003e) and ((trom.currentstate) \u003d (trom.destinstate)))) \u003d\u003e ((((trom.destinstate).type) \u003d \u003cCOMPLEX\u003e) \u003d\u003e pre_get_entry_state((ts.destinstate)))))","operation postcondition satisfiable obligation:(forall trom:Trom, se:SimulationEvent, ts:TransitionSpec, oldstate:System \u0026 (pre_update_trom_current_state(trom, se, ts, oldstate) \u003d\u003e (exists newstate:System \u0026 post_update_trom_current_state(trom, se, ts, oldstate, newstate))))","operation postcondition satisfiable obligation:(forall trom:Trom, se:SimulationEvent, ts:[TransitionSpec], oldstate:System \u0026 (pre_update_history_assignment_vector(trom, se, ts, oldstate) \u003d\u003e (exists newstate:System \u0026 post_update_history_assignment_vector(trom, se, ts, oldstate, newstate))))","operation postcondition satisfiable obligation:(forall trom:Trom, se:SimulationEvent, ts:[TransitionSpec], oldstate:System \u0026 (pre_update_history_notransition(trom, se, ts, oldstate) \u003d\u003e (exists newstate:System \u0026 post_update_history_notransition(trom, se, ts, oldstate, newstate))))","operation postcondition satisfiable obligation:(forall trom:Trom, se:SimulationEvent, ts:TransitionSpec, oldstate:System \u0026 (pre_update_history_transition(trom, se, ts, oldstate) \u003d\u003e (exists newstate:System \u0026 post_update_history_transition(trom, se, ts, oldstate, newstate))))","operation postcondition satisfiable obligation:(forall trom:Trom, se:SimulationEvent, tc:TimeConstraint, rw:ReactionWindow, oldstate:System \u0026 (pre_update_history_fire_reaction(trom, se, tc, rw, oldstate) \u003d\u003e (exists newstate:System \u0026 post_update_history_fire_reaction(trom, se, tc, rw, oldstate, newstate))))","operation postcondition satisfiable obligation:(forall trom:Trom, se:SimulationEvent, tc:TimeConstraint, rw:ReactionWindow, oldstate:System \u0026 (pre_update_history_disable_reaction(trom, se, tc, rw, oldstate) \u003d\u003e (exists newstate:System \u0026 post_update_history_disable_reaction(trom, se, tc, rw, oldstate, newstate))))","let be st existence obligation:(((ts.label) \u003d ((tc.transition).label)) \u003d\u003e (exists rw:ReactionWindow \u0026 (rw \u003d mk_ReactionWindow((((tc.timebounds).lowertimebound) + CLOCK), (((tc.timebounds).uppertimebound) + CLOCK)))))","type compatibility obligation:(((ts.label) \u003d ((tc.transition).label)) \u003d\u003e (forall rw:ReactionWindow \u0026 inv_ReactionWindow(mk_ReactionWindow((((tc.timebounds).lowertimebound) + CLOCK), (((tc.timebounds).uppertimebound) + CLOCK)))))","operation postcondition satisfiable obligation:(forall trom:Trom, se:SimulationEvent, tc:TimeConstraint, ts:TransitionSpec, oldstate:System \u0026 (pre_update_history_enable_reaction(trom, se, tc, ts, oldstate) \u003d\u003e (exists newstate:System \u0026 post_update_history_enable_reaction(trom, se, tc, ts, oldstate, newstate))))","operation postcondition satisfiable obligation:(forall trom:Trom, se:SimulationEvent, tc:TimeConstraint, rw:ReactionWindow, oldstate:System \u0026 (pre_fire_reaction(trom, se, tc, rw, oldstate) \u003d\u003e (exists newstate:System \u0026 post_fire_reaction(trom, se, tc, rw, oldstate, newstate))))","let be st existence obligation:((((trom.currentstate) in set (tc.disablingstates)) and (rw in set (tc.reactionwindows))) \u003d\u003e ((trom not in set (trom.reactionwindows)) \u003d\u003e (exists se2:SimulationEvent \u0026 (se2 \u003d get_enabled_simevent(trom, tc)))))","legal sequence application obligation:((((trom.currentstate) in set (tc.disablingstates)) and (rw in set (tc.reactionwindows))) \u003d\u003e ((trom not in set (trom.reactionwindows)) \u003d\u003e (forall se2:SimulationEvent \u0026 ((se2 \u003d get_enabled_simevent(trom, tc)) \u003d\u003e ((((tc.constrainedevent).type) \u003d \u003cINTERNAL\u003e) \u003d\u003e (forall i in set (inds SIMULATIONEVENTLIST~) \u0026 ((SIMULATIONEVENTLIST~(i) \u003c\u003e se2) \u003d\u003e (i in set (inds SIMULATIONEVENTLIST~)))))))))","legal sequence application obligation:((((trom.currentstate) in set (tc.disablingstates)) and (rw in set (tc.reactionwindows))) \u003d\u003e ((trom not in set (trom.reactionwindows)) \u003d\u003e (forall se2:SimulationEvent \u0026 ((se2 \u003d get_enabled_simevent(trom, tc)) \u003d\u003e ((((tc.constrainedevent).type) \u003d \u003cINTERNAL\u003e) \u003d\u003e (forall i in set (inds SIMULATIONEVENTLIST~) \u0026 (i in set (inds SIMULATIONEVENTLIST~))))))))","let be st existence obligation:((((trom.currentstate) in set (tc.disablingstates)) and (rw in set (tc.reactionwindows))) \u003d\u003e ((trom not in set (trom.reactionwindows)) \u003d\u003e (forall se2:SimulationEvent \u0026 ((se2 \u003d get_enabled_simevent(trom, tc)) \u003d\u003e ((not ((((tc.constrainedevent).type) \u003d \u003cINTERNAL\u003e) and (SIMULATIONEVENTLIST \u003d [SIMULATIONEVENTLIST~(i) | i in set (inds SIMULATIONEVENTLIST~) \u0026 (SIMULATIONEVENTLIST~(i) \u003c\u003e se2)]))) \u003d\u003e ((((tc.constrainedevent).type) \u003d \u003cOUTPUT\u003e) \u003d\u003e (exists tromporttuple:[TromPortTuple] \u0026 (tromporttuple \u003d get_linked_tromport_tuple(mk_TromPortTuple((se2.tromlabel), (se2.portlabel)), SUBSYSTEM)))))))))","let be st existence obligation:((((trom.currentstate) in set (tc.disablingstates)) and (rw in set (tc.reactionwindows))) \u003d\u003e ((trom not in set (trom.reactionwindows)) \u003d\u003e (forall se2:SimulationEvent \u0026 ((se2 \u003d get_enabled_simevent(trom, tc)) \u003d\u003e ((not ((((tc.constrainedevent).type) \u003d \u003cINTERNAL\u003e) and (SIMULATIONEVENTLIST \u003d [SIMULATIONEVENTLIST~(i) | i in set (inds SIMULATIONEVENTLIST~) \u0026 (SIMULATIONEVENTLIST~(i) \u003c\u003e se2)]))) \u003d\u003e ((((tc.constrainedevent).type) \u003d \u003cOUTPUT\u003e) \u003d\u003e (forall tromporttuple:[TromPortTuple] \u0026 ((tromporttuple \u003d get_linked_tromport_tuple(mk_TromPortTuple((se2.tromlabel), (se2.portlabel)), SUBSYSTEM)) \u003d\u003e (exists se3:SimulationEvent \u0026 (se3 \u003d get_enabled_simevent_synch(tromporttuple, tc)))))))))))","legal sequence application obligation:((((trom.currentstate) in set (tc.disablingstates)) and (rw in set (tc.reactionwindows))) \u003d\u003e ((trom not in set (trom.reactionwindows)) \u003d\u003e (forall se2:SimulationEvent \u0026 ((se2 \u003d get_enabled_simevent(trom, tc)) \u003d\u003e ((not ((((tc.constrainedevent).type) \u003d \u003cINTERNAL\u003e) and (SIMULATIONEVENTLIST \u003d [SIMULATIONEVENTLIST~(i) | i in set (inds SIMULATIONEVENTLIST~) \u0026 (SIMULATIONEVENTLIST~(i) \u003c\u003e se2)]))) \u003d\u003e ((((tc.constrainedevent).type) \u003d \u003cOUTPUT\u003e) \u003d\u003e (forall tromporttuple:[TromPortTuple] \u0026 ((tromporttuple \u003d get_linked_tromport_tuple(mk_TromPortTuple((se2.tromlabel), (se2.portlabel)), SUBSYSTEM)) \u003d\u003e (forall se3:SimulationEvent \u0026 ((se3 \u003d get_enabled_simevent_synch(tromporttuple, tc)) \u003d\u003e (forall i in set (inds SIMULATIONEVENTLIST~) \u0026 (((SIMULATIONEVENTLIST~(i) \u003c\u003e se2) and (SIMULATIONEVENTLIST~(i) \u003c\u003e se3)) \u003d\u003e (i in set (inds SIMULATIONEVENTLIST~))))))))))))))","legal sequence application obligation:((((trom.currentstate) in set (tc.disablingstates)) and (rw in set (tc.reactionwindows))) \u003d\u003e ((trom not in set (trom.reactionwindows)) \u003d\u003e (forall se2:SimulationEvent \u0026 ((se2 \u003d get_enabled_simevent(trom, tc)) \u003d\u003e ((not ((((tc.constrainedevent).type) \u003d \u003cINTERNAL\u003e) and (SIMULATIONEVENTLIST \u003d [SIMULATIONEVENTLIST~(i) | i in set (inds SIMULATIONEVENTLIST~) \u0026 (SIMULATIONEVENTLIST~(i) \u003c\u003e se2)]))) \u003d\u003e ((((tc.constrainedevent).type) \u003d \u003cOUTPUT\u003e) \u003d\u003e (forall tromporttuple:[TromPortTuple] \u0026 ((tromporttuple \u003d get_linked_tromport_tuple(mk_TromPortTuple((se2.tromlabel), (se2.portlabel)), SUBSYSTEM)) \u003d\u003e (forall se3:SimulationEvent \u0026 ((se3 \u003d get_enabled_simevent_synch(tromporttuple, tc)) \u003d\u003e (forall i in set (inds SIMULATIONEVENTLIST~) \u0026 (i in set (inds SIMULATIONEVENTLIST~)))))))))))))","legal sequence application obligation:((((trom.currentstate) in set (tc.disablingstates)) and (rw in set (tc.reactionwindows))) \u003d\u003e ((trom not in set (trom.reactionwindows)) \u003d\u003e (forall se2:SimulationEvent \u0026 ((se2 \u003d get_enabled_simevent(trom, tc)) \u003d\u003e ((not ((((tc.constrainedevent).type) \u003d \u003cINTERNAL\u003e) and (SIMULATIONEVENTLIST \u003d [SIMULATIONEVENTLIST~(i) | i in set (inds SIMULATIONEVENTLIST~) \u0026 (SIMULATIONEVENTLIST~(i) \u003c\u003e se2)]))) \u003d\u003e ((((tc.constrainedevent).type) \u003d \u003cOUTPUT\u003e) \u003d\u003e (forall tromporttuple:[TromPortTuple] \u0026 ((tromporttuple \u003d get_linked_tromport_tuple(mk_TromPortTuple((se2.tromlabel), (se2.portlabel)), SUBSYSTEM)) \u003d\u003e (forall se3:SimulationEvent \u0026 ((se3 \u003d get_enabled_simevent_synch(tromporttuple, tc)) \u003d\u003e (forall i in set (inds SIMULATIONEVENTLIST~) \u0026 ((SIMULATIONEVENTLIST~(i) \u003c\u003e se2) \u003d\u003e (i in set (inds SIMULATIONEVENTLIST~))))))))))))))","operation postcondition satisfiable obligation:(forall trom:Trom, se:SimulationEvent, tc:TimeConstraint, rw:ReactionWindow, oldstate:System \u0026 (pre_disable_reaction(trom, se, tc, rw, oldstate) \u003d\u003e (exists newstate:System \u0026 post_disable_reaction(trom, se, tc, rw, oldstate, newstate))))","let be st existence obligation:(((ts.label) \u003d ((tc.transition).label)) \u003d\u003e (exists rw:ReactionWindow \u0026 (rw \u003d mk_ReactionWindow((((tc.timebounds).lowertimebound) + CLOCK), (((tc.timebounds).uppertimebound) + CLOCK)))))","type compatibility obligation:(((ts.label) \u003d ((tc.transition).label)) \u003d\u003e (forall rw:ReactionWindow \u0026 inv_ReactionWindow(mk_ReactionWindow((((tc.timebounds).lowertimebound) + CLOCK), (((tc.timebounds).uppertimebound) + CLOCK)))))","let be st existence obligation:(((ts.label) \u003d ((tc.transition).label)) \u003d\u003e (forall rw:ReactionWindow \u0026 ((rw \u003d mk_ReactionWindow((((tc.timebounds).lowertimebound) + CLOCK), (((tc.timebounds).uppertimebound) + CLOCK))) \u003d\u003e (exists port:Port \u0026 (port \u003d get_lru_port((((tc.constrainedevent).porttype).portlist)))))))","legal function application obligation:(((ts.label) \u003d ((tc.transition).label)) \u003d\u003e (forall rw:ReactionWindow \u0026 ((rw \u003d mk_ReactionWindow((((tc.timebounds).lowertimebound) + CLOCK), (((tc.timebounds).uppertimebound) + CLOCK))) \u003d\u003e (forall port:Port \u0026 pre_get_lru_port((((tc.constrainedevent).porttype).portlist))))))","let be st existence obligation:(((ts.label) \u003d ((tc.transition).label)) \u003d\u003e (forall rw:ReactionWindow \u0026 ((rw \u003d mk_ReactionWindow((((tc.timebounds).lowertimebound) + CLOCK), (((tc.timebounds).uppertimebound) + CLOCK))) \u003d\u003e (forall port:Port \u0026 ((port \u003d get_lru_port((((tc.constrainedevent).porttype).portlist))) \u003d\u003e (exists occurtime:nat \u0026 (occurtime \u003d get_random_time_within_rw(rw))))))))","let be st existence obligation:(((ts.label) \u003d ((tc.transition).label)) \u003d\u003e (forall rw:ReactionWindow \u0026 ((rw \u003d mk_ReactionWindow((((tc.timebounds).lowertimebound) + CLOCK), (((tc.timebounds).uppertimebound) + CLOCK))) \u003d\u003e (forall port:Port \u0026 ((port \u003d get_lru_port((((tc.constrainedevent).porttype).portlist))) \u003d\u003e (forall occurtime:nat \u0026 ((occurtime \u003d get_random_time_within_rw(rw)) \u003d\u003e (exists se2:SimulationEvent \u0026 (se2 \u003d mk_SimulationEvent(((tc.constrainedevent).label), (trom.label), (port.label), occurtime, nil))))))))))","let be st existence obligation:(((ts.label) \u003d ((tc.transition).label)) \u003d\u003e (forall rw:ReactionWindow \u0026 ((rw \u003d mk_ReactionWindow((((tc.timebounds).lowertimebound) + CLOCK), (((tc.timebounds).uppertimebound) + CLOCK))) \u003d\u003e (forall port:Port \u0026 ((port \u003d get_lru_port((((tc.constrainedevent).porttype).portlist))) \u003d\u003e (forall occurtime:nat \u0026 ((occurtime \u003d get_random_time_within_rw(rw)) \u003d\u003e (forall se2:SimulationEvent \u0026 ((se2 \u003d mk_SimulationEvent(((tc.constrainedevent).label), (trom.label), (port.label), occurtime, nil)) \u003d\u003e ((rw in set (tc.reactionwindows)) \u003d\u003e ((se2 in set (elems SIMULATIONEVENTLIST)) \u003d\u003e ((((tc.constrainedevent).type) \u003d \u003cOUTPUT\u003e) \u003d\u003e (exists tromporttuple:[TromPortTuple] \u0026 (tromporttuple \u003d get_linked_tromport_tuple(mk_TromPortTuple((se2.tromlabel), (se2.portlabel)), SUBSYSTEM)))))))))))))))","let be st existence obligation:(((ts.label) \u003d ((tc.transition).label)) \u003d\u003e (forall rw:ReactionWindow \u0026 ((rw \u003d mk_ReactionWindow((((tc.timebounds).lowertimebound) + CLOCK), (((tc.timebounds).uppertimebound) + CLOCK))) \u003d\u003e (forall port:Port \u0026 ((port \u003d get_lru_port((((tc.constrainedevent).porttype).portlist))) \u003d\u003e (forall occurtime:nat \u0026 ((occurtime \u003d get_random_time_within_rw(rw)) \u003d\u003e (forall se2:SimulationEvent \u0026 ((se2 \u003d mk_SimulationEvent(((tc.constrainedevent).label), (trom.label), (port.label), occurtime, nil)) \u003d\u003e ((rw in set (tc.reactionwindows)) \u003d\u003e ((se2 in set (elems SIMULATIONEVENTLIST)) \u003d\u003e ((((tc.constrainedevent).type) \u003d \u003cOUTPUT\u003e) \u003d\u003e (forall tromporttuple:[TromPortTuple] \u0026 ((tromporttuple \u003d get_linked_tromport_tuple(mk_TromPortTuple((se2.tromlabel), (se2.portlabel)), SUBSYSTEM)) \u003d\u003e ((tromporttuple \u003c\u003e nil) \u003d\u003e (exists se3:SimulationEvent \u0026 (se3 \u003d mk_SimulationEvent((se2.eventlabel), (tromporttuple.tromlabel), (tromporttuple.portlabel), (se2.occurtime), nil))))))))))))))))))","operation postcondition satisfiable obligation:(forall trom:Trom, se:SimulationEvent, tc:TimeConstraint, ts:TransitionSpec, oldstate:System \u0026 (pre_enable_reaction(trom, se, tc, ts, oldstate) \u003d\u003e (exists newstate:System \u0026 post_enable_reaction(trom, se, tc, ts, oldstate, newstate))))","operation postcondition satisfiable obligation:(forall trom:Trom, tc:TimeConstraint, oldstate:System \u0026 (pre_get_enabled_simevent(trom, tc, oldstate) \u003d\u003e (exists se:SimulationEvent \u0026 post_get_enabled_simevent(trom, tc, oldstate, se, oldstate, newstate))))","operation postcondition satisfiable obligation:(forall tromporttuple:TromPortTuple, tc:TimeConstraint, oldstate:System \u0026 (exists se:SimulationEvent \u0026 post_get_enabled_simevent_synch(tromporttuple, tc, oldstate, se, oldstate, newstate)))","finite set obligation:((CLOCK \u003d 0) \u003d\u003e ((CLOCK \u003d 0) \u003d\u003e (exists finmap1:map (nat) to (Trom) \u0026 (forall trom:Trom \u0026 (exists_in_subsystem(trom, SUBSYSTEM) \u003d\u003e (exists findex2 in set (dom finmap1) \u0026 (finmap1(findex2) \u003d trom)))))))","legal function application obligation:((CLOCK \u003d 0) \u003d\u003e ((CLOCK \u003d 0) \u003d\u003e (forall trom:Trom \u0026 pre_exists_in_subsystem(trom, SUBSYSTEM))))","let be st existence obligation:((CLOCK \u003d 0) \u003d\u003e ((CLOCK \u003d 0) \u003d\u003e (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 let event:[Event] \u003d get_unconstrained_internal_event(trom) in ((event \u003c\u003e nil) \u003d\u003e (exists se:SimulationEvent \u0026 (se \u003d mk_SimulationEvent((event.label), (trom.label), \"NULLPORT\", CLOCK, nil)))))))","let be st existence obligation:((CLOCK \u003d 0) \u003d\u003e ((CLOCK \u003d 0) \u003d\u003e (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 let event:[Event] \u003d get_unconstrained_internal_event(trom) in ((event \u003c\u003e nil) \u003d\u003e (forall se:SimulationEvent \u0026 ((se \u003d mk_SimulationEvent((event.label), (trom.label), \"NULLPORT\", CLOCK, nil)) \u003d\u003e ((se in set (elems SIMULATIONEVENTLIST)) \u003d\u003e (exists i:nat1 \u0026 (SIMULATIONEVENTLIST(i) \u003d se)))))))))","legal sequence application obligation:((CLOCK \u003d 0) \u003d\u003e ((CLOCK \u003d 0) \u003d\u003e (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 let event:[Event] \u003d get_unconstrained_internal_event(trom) in ((event \u003c\u003e nil) \u003d\u003e (forall se:SimulationEvent \u0026 ((se \u003d mk_SimulationEvent((event.label), (trom.label), \"NULLPORT\", CLOCK, nil)) \u003d\u003e ((se in set (elems SIMULATIONEVENTLIST)) \u003d\u003e (forall i:nat1 \u0026 (i in set (inds SIMULATIONEVENTLIST))))))))))","let be st existence obligation:((CLOCK \u003d 0) \u003d\u003e ((CLOCK \u003d 0) \u003d\u003e (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 let event:[Event] \u003d get_unconstrained_internal_event(trom) in ((event \u003c\u003e nil) \u003d\u003e (forall se:SimulationEvent \u0026 ((se \u003d mk_SimulationEvent((event.label), (trom.label), \"NULLPORT\", CLOCK, nil)) \u003d\u003e ((se in set (elems SIMULATIONEVENTLIST)) \u003d\u003e (forall i:nat1 \u0026 ((SIMULATIONEVENTLIST(i) \u003d se) \u003d\u003e (forall se2 in set (elems SIMULATIONEVENTLIST~) \u0026 (exists j:nat1 \u0026 (SIMULATIONEVENTLIST(j) \u003d se2))))))))))))","legal sequence application obligation:((CLOCK \u003d 0) \u003d\u003e ((CLOCK \u003d 0) \u003d\u003e (forall trom in set {trom | trom:Trom \u0026 exists_in_subsystem(trom, SUBSYSTEM)} \u0026 let event:[Event] \u003d get_unconstrained_internal_event(trom) in ((event \u003c\u003e nil) \u003d\u003e (forall se:SimulationEvent \u0026 ((se \u003d mk_SimulationEvent((event.label), (trom.label), \"NULLPORT\", CLOCK, nil)) \u003d\u003e ((se in set (elems SIMULATIONEVENTLIST)) \u003d\u003e (forall i:nat1 \u0026 ((SIMULATIONEVENTLIST(i) \u003d se) \u003d\u003e (forall se2 in set (elems SIMULATIONEVENTLIST~) \u0026 (forall j:nat1 \u0026 (j in set (inds SIMULATIONEVENTLIST)))))))))))))","operation postcondition satisfiable obligation:(pre_schedule_unconstrained_internal_events_from_initial_state(oldstate) \u003d\u003e (exists newstate:System \u0026 post_schedule_unconstrained_internal_events_from_initial_state(oldstate, newstate)))","let be st existence obligation:(((se in set (elems SIMULATIONEVENTLIST)) and ((se.tromlabel) \u003d (trom.label))) \u003d\u003e let event:[Event] \u003d get_unconstrained_internal_event(trom) in ((event \u003c\u003e nil) \u003d\u003e (exists j:nat1 \u0026 (j \u003d get_simevent_index(se, SIMULATIONEVENTLIST)))))","legal function application obligation:(((se in set (elems SIMULATIONEVENTLIST)) and ((se.tromlabel) \u003d (trom.label))) \u003d\u003e let event:[Event] \u003d get_unconstrained_internal_event(trom) in ((event \u003c\u003e nil) \u003d\u003e (forall j:nat1 \u0026 pre_get_simevent_index(se, SIMULATIONEVENTLIST))))","let be st existence obligation:(((se in set (elems SIMULATIONEVENTLIST)) and ((se.tromlabel) \u003d (trom.label))) \u003d\u003e let event:[Event] \u003d get_unconstrained_internal_event(trom) in ((event \u003c\u003e nil) \u003d\u003e (forall j:nat1 \u0026 ((j \u003d get_simevent_index(se, SIMULATIONEVENTLIST)) \u003d\u003e (exists se2:SimulationEvent \u0026 (se2 \u003d mk_SimulationEvent((event.label), (trom.label), \"NULLPORT\", CLOCK, nil)))))))","legal sequence application obligation:(((se in set (elems SIMULATIONEVENTLIST)) and ((se.tromlabel) \u003d (trom.label))) \u003d\u003e let event:[Event] \u003d get_unconstrained_internal_event(trom) in ((event \u003c\u003e nil) \u003d\u003e (forall j:nat1 \u0026 ((j \u003d get_simevent_index(se, SIMULATIONEVENTLIST)) \u003d\u003e (forall se2:SimulationEvent \u0026 ((se2 \u003d mk_SimulationEvent((event.label), (trom.label), \"NULLPORT\", CLOCK, nil)) \u003d\u003e (forall i in set (inds SIMULATIONEVENTLIST~) \u0026 ((i \u003c\u003d j) \u003d\u003e (i in set (inds SIMULATIONEVENTLIST~))))))))))","legal sequence application obligation:(((se in set (elems SIMULATIONEVENTLIST)) and ((se.tromlabel) \u003d (trom.label))) \u003d\u003e let event:[Event] \u003d get_unconstrained_internal_event(trom) in ((event \u003c\u003e nil) \u003d\u003e (forall j:nat1 \u0026 ((j \u003d get_simevent_index(se, SIMULATIONEVENTLIST)) \u003d\u003e (forall se2:SimulationEvent \u0026 ((se2 \u003d mk_SimulationEvent((event.label), (trom.label), \"NULLPORT\", CLOCK, nil)) \u003d\u003e (forall i in set (inds SIMULATIONEVENTLIST~) \u0026 ((i \u003e j) \u003d\u003e (i in set (inds SIMULATIONEVENTLIST~))))))))))","operation postcondition satisfiable obligation:(forall trom:Trom, se:SimulationEvent, oldstate:System \u0026 (pre_schedule_unconstrained_internal_event(trom, se, oldstate) \u003d\u003e (exists newstate:System \u0026 post_schedule_unconstrained_internal_event(trom, se, oldstate, newstate))))","operation postcondition satisfiable obligation:(exists newstate:System \u0026 post_initialize_simulation_clock(oldstate, newstate))","operation postcondition satisfiable obligation:(exists newstate:System \u0026 post_update_simulation_clock(oldstate, newstate))"] \ No newline at end of file diff --git a/core/pog/src/test/resources/examples/trayallocationPP.result b/core/pog/src/test/resources/examples/trayallocationPP.result index 02c2103288..08d6cabe83 100644 --- a/core/pog/src/test/resources/examples/trayallocationPP.result +++ b/core/pog/src/test/resources/examples/trayallocationPP.result @@ -1 +1 @@ -["legal function application obligation:(forall fname:seq1 of (char) \u0026 pre_(((io.freadval))[InputTP]fname))","type compatibility obligation:(forall fname:seq1 of (char) \u0026 (timeval \u003e\u003d 0))","type compatibility obligation:inv_UID(0)","comprehension map injectivity obligation:(forall e:SorterEnviroment \u0026 (forall m1, m2 in set {{num |-\u003e new Tray(num)} | num in set {1, ... ,NumOfTrays}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4))))))","type compatibility obligation:(forall e:SorterEnviroment \u0026 is_({num |-\u003e new Tray(num) | num in set {1, ... ,NumOfTrays}}, inmap (UID) to (Tray)))","state invariant holds obligation:(forall e:SorterEnviroment \u0026 ((((((NumOfTrays \u003e (InductionSeperation * NumOfInductions)) and ((len [new InductionController(self, num) | num in set {1, ... ,NumOfInductions}]) \u003d NumOfInductions)) and (forall id in set (inds inductionGroup) \u0026 ((inductionGroup(id).GetId)() \u003d id))) and ((card (dom {num |-\u003e new Tray(num) | num in set {1, ... ,NumOfTrays}})) \u003d NumOfTrays)) and (forall id in set (dom sorterRing) \u0026 ((sorterRing(id).GetId)() \u003d id))) and ((trayAtCardReader \u003e 0) \u003d\u003e (trayAtCardReader in set (dom {num |-\u003e new Tray(num) | num in set {1, ... ,NumOfTrays}})))))","state invariant holds obligation:(forall uid:UID, state:State \u0026 ((uid in set (dom sorterRing)) \u003d\u003e (((((((NumOfTrays \u003e (InductionSeperation * NumOfInductions)) and ((len inductionGroup) \u003d NumOfInductions)) and (forall id in set (inds inductionGroup) \u0026 ((inductionGroup(id).GetId)() \u003d id))) and ((card (dom sorterRing)) \u003d NumOfTrays)) and (forall id in set (dom sorterRing) \u0026 ((sorterRing(id).GetId)() \u003d id))) and ((trayAtCardReader \u003e 0) \u003d\u003e (trayAtCardReader in set (dom sorterRing)))) \u003d\u003e ((((((NumOfTrays \u003e (InductionSeperation * NumOfInductions)) and ((len inductionGroup) \u003d NumOfInductions)) and (forall id in set (inds inductionGroup) \u0026 ((inductionGroup(id).GetId)() \u003d id))) and ((card (dom sorterRing)) \u003d NumOfTrays)) and (forall id in set (dom sorterRing) \u0026 ((sorterRing(id).GetId)() \u003d id))) and ((uid \u003e 0) \u003d\u003e (uid in set (dom sorterRing)))))))","state invariant holds obligation:(forall uid:UID, state:State \u0026 ((uid in set (dom sorterRing)) \u003d\u003e (((((((NumOfTrays \u003e (InductionSeperation * NumOfInductions)) and ((len inductionGroup) \u003d NumOfInductions)) and (forall id in set (inds inductionGroup) \u0026 ((inductionGroup(id).GetId)() \u003d id))) and ((card (dom sorterRing)) \u003d NumOfTrays)) and (forall id in set (dom sorterRing) \u0026 ((sorterRing(id).GetId)() \u003d id))) and ((uid \u003e 0) \u003d\u003e (uid in set (dom sorterRing)))) \u003d\u003e ((((((NumOfTrays \u003e (InductionSeperation * NumOfInductions)) and ((len inductionGroup) \u003d NumOfInductions)) and (forall id in set (inds inductionGroup) \u0026 ((inductionGroup(id).GetId)() \u003d id))) and ((card (dom sorterRing)) \u003d NumOfTrays)) and (forall id in set (dom sorterRing) \u0026 ((sorterRing(id).GetId)() \u003d id))) and ((uid \u003e 0) \u003d\u003e (uid in set (dom sorterRing)))))))","state invariant holds obligation:(forall ic:InductionController, item:Item \u0026 (((ic in set (elems inductionGroup)) and ((item.GetSizeOfTrays)() \u003c\u003d 2)) \u003d\u003e (((((((NumOfTrays \u003e (InductionSeperation * NumOfInductions)) and ((len inductionGroup) \u003d NumOfInductions)) and (forall id in set (inds inductionGroup) \u0026 ((inductionGroup(id).GetId)() \u003d id))) and ((card (dom sorterRing)) \u003d NumOfTrays)) and (forall id in set (dom sorterRing) \u0026 ((sorterRing(id).GetId)() \u003d id))) and ((trayAtCardReader \u003e 0) \u003d\u003e (trayAtCardReader in set (dom sorterRing)))) \u003d\u003e ((((((NumOfTrays \u003e (InductionSeperation * NumOfInductions)) and ((len inductionGroup) \u003d NumOfInductions)) and (forall id in set (inds inductionGroup) \u0026 ((inductionGroup(id).GetId)() \u003d id))) and ((card (dom sorterRing)) \u003d NumOfTrays)) and (forall id in set (dom sorterRing) \u0026 ((sorterRing(id).GetId)() \u003d id))) and ((trayAtCardReader \u003e 0) \u003d\u003e (trayAtCardReader in set (dom sorterRing)))))))","state invariant holds obligation:(forall ic:InductionController, item:Item \u0026 (((ic in set (elems inductionGroup)) and ((item.GetSizeOfTrays)() \u003c\u003d 2)) \u003d\u003e (((((((NumOfTrays \u003e (InductionSeperation * NumOfInductions)) and ((len inductionGroup) \u003d NumOfInductions)) and (forall id in set (inds inductionGroup) \u0026 ((inductionGroup(id).GetId)() \u003d id))) and ((card (dom sorterRing)) \u003d NumOfTrays)) and (forall id in set (dom sorterRing) \u0026 ((sorterRing(id).GetId)() \u003d id))) and ((trayAtCardReader \u003e 0) \u003d\u003e (trayAtCardReader in set (dom sorterRing)))) \u003d\u003e ((((((NumOfTrays \u003e (InductionSeperation * NumOfInductions)) and ((len inductionGroup) \u003d NumOfInductions)) and (forall id in set (inds inductionGroup) \u0026 ((inductionGroup(id).GetId)() \u003d id))) and ((card (dom sorterRing)) \u003d NumOfTrays)) and (forall id in set (dom sorterRing) \u0026 ((sorterRing(id).GetId)() \u003d id))) and ((trayAtCardReader \u003e 0) \u003d\u003e (trayAtCardReader in set (dom sorterRing)))))))","state invariant holds obligation:(forall ic:InductionController, item:Item \u0026 (((ic in set (elems inductionGroup)) and ((item.GetSizeOfTrays)() \u003c\u003d 2)) \u003d\u003e (((((((NumOfTrays \u003e (InductionSeperation * NumOfInductions)) and ((len inductionGroup) \u003d NumOfInductions)) and (forall id in set (inds inductionGroup) \u0026 ((inductionGroup(id).GetId)() \u003d id))) and ((card (dom sorterRing)) \u003d NumOfTrays)) and (forall id in set (dom sorterRing) \u0026 ((sorterRing(id).GetId)() \u003d id))) and ((trayAtCardReader \u003e 0) \u003d\u003e (trayAtCardReader in set (dom sorterRing)))) \u003d\u003e ((((((NumOfTrays \u003e (InductionSeperation * NumOfInductions)) and ((len inductionGroup) \u003d NumOfInductions)) and (forall id in set (inds inductionGroup) \u0026 ((inductionGroup(id).GetId)() \u003d id))) and ((card (dom sorterRing)) \u003d NumOfTrays)) and (forall id in set (dom sorterRing) \u0026 ((sorterRing(id).GetId)() \u003d id))) and ((trayAtCardReader \u003e 0) \u003d\u003e (trayAtCardReader in set (dom sorterRing)))))))","operation call obligation:(forall ic:InductionController, item:Item \u0026 (((ic in set (elems inductionGroup)) and ((item.GetSizeOfTrays)() \u003c\u003d 2)) \u003d\u003e (true \u003d\u003e ((item \u003c\u003e {}) and (forall t in set trays \u0026 (t.IsTrayEmpty)())))))","legal map application obligation:(forall id in set (dom sorterRing) \u0026 (id in set (dom sorterRing)))","non-zero obligation:(forall steps:nat, trays:set of (Tray), items:nat \u0026 ((trays \u003c\u003e {}) \u003d\u003e (SorterEnviroment`Speed \u003c\u003e 0)))","non-zero obligation:(forall steps:nat, trays:set of (Tray), items:nat \u0026 ((trays \u003c\u003e {}) \u003d\u003e (runTime \u003c\u003e 0)))","legal map application obligation:(forall icid:nat \u0026 ((icid in set (inds (trayAllocator.inductionGroup))) \u003d\u003e (posTray in set (dom (trayAllocator.sorterRing)))))","legal map application obligation:(forall icid:nat \u0026 ((icid in set (inds (trayAllocator.inductionGroup))) \u003d\u003e (((trayAllocator.sorterRing)(posTray).IsTrayEmpty)() \u003d\u003e (posTrayNext in set (dom (trayAllocator.sorterRing))))))","type compatibility obligation:(forall icid:nat \u0026 ((icid in set (inds (trayAllocator.inductionGroup))) \u003d\u003e (((trayAllocator.sorterRing)(posTray).IsTrayEmpty)() \u003d\u003e (inv_UID(posTrayNext) and is_(posTrayNext, nat)))))","legal map application obligation:(forall icid:nat \u0026 ((icid in set (inds (trayAllocator.inductionGroup))) \u003d\u003e (posTray in set (dom (trayAllocator.sorterRing)))))","legal map application obligation:(forall icid:nat \u0026 ((icid in set (inds (trayAllocator.inductionGroup))) \u003d\u003e (posTrayNext in set (dom (trayAllocator.sorterRing)))))","type compatibility obligation:(forall icid:nat \u0026 ((icid in set (inds (trayAllocator.inductionGroup))) \u003d\u003e (inv_UID(posTrayNext) and is_(posTrayNext, nat))))","legal sequence application obligation:(test in set (inds testfiles))","legal sequence application obligation:(true \u003d\u003e (test in set (inds testfiles)))","while loop termination obligation:NotYetImplemented","type compatibility obligation:(forall val:nat \u0026 (((x1 mod 10) + 1) \u003e\u003d 0))","legal sequence application obligation:(forall val:nat \u0026 (((x1 mod 10) + 1) in set (inds numeric)))","type compatibility obligation:(forall val:nat \u0026 ((x1 div 10) \u003e\u003d 0))","type invariant satisfiable obligation:(exists u:UID \u0026 (u \u003c\u003d TrayAllocator`NumOfTrays))","state invariant holds obligation:(forall i:UID \u0026 ((item \u003c\u003e nil) \u003d\u003e (state \u003d \u003cFull\u003e)))","state invariant holds obligation:(forall s:State \u0026 (((item \u003c\u003e nil) \u003d\u003e (state \u003d \u003cFull\u003e)) \u003d\u003e ((nil \u003c\u003e nil) \u003d\u003e (state \u003d \u003cFull\u003e))))","state invariant holds obligation:(forall s:State \u0026 (((nil \u003c\u003e nil) \u003d\u003e (state \u003d \u003cFull\u003e)) \u003d\u003e ((nil \u003c\u003e nil) \u003d\u003e (s \u003d \u003cFull\u003e))))","state invariant holds obligation:(((item \u003c\u003e nil) \u003d\u003e (state \u003d \u003cFull\u003e)) \u003d\u003e ((i \u003c\u003e nil) \u003d\u003e (\u003cFull\u003e \u003d \u003cFull\u003e)))","type invariant satisfiable obligation:(exists it:ItemTraySize \u0026 (it \u003c\u003d ItemMaxTrays))","non-zero obligation:(forall s:nat1, i:nat \u0026 (Tray`TraySize \u003c\u003e 0))","type compatibility obligation:(forall s:nat1, i:nat \u0026 (inv_ItemTraySize(((size div Tray`TraySize) + 1)) and is_(((size div Tray`TraySize) + 1), nat1)))","state invariant holds obligation:(forall s:nat1, i:nat \u0026 ((s \u003e\u003d ItemMinSize) and (s \u003c\u003d ItemMaxSize)))","state invariant holds obligation:(forall tray:Tray \u0026 (((size \u003e\u003d ItemMinSize) and (size \u003c\u003d ItemMaxSize)) \u003d\u003e ((size \u003e\u003d ItemMinSize) and (size \u003c\u003d ItemMaxSize))))","operation postcondition satisfiable obligation:(exists newself:Item \u0026 post_RemoveItemFromTray(oldself, newself))","type compatibility obligation:(forall a:TrayAllocator, n:nat \u0026 (n \u003e 0))","state invariant holds obligation:(forall a:TrayAllocator, n:nat \u0026 ((priority \u003e 0) \u003d\u003e ((len items) \u003e 0)))","non-empty sequence obligation:(items \u003c\u003e [])","state invariant holds obligation:(forall i:Item \u0026 (((priority \u003e 0) \u003d\u003e ((len items) \u003e 0)) \u003d\u003e ((priority \u003e 0) \u003d\u003e ((len (items ^ [i])) \u003e 0))))","state invariant holds obligation:(((priority \u003e 0) \u003d\u003e ((len items) \u003e 0)) \u003d\u003e ((priority \u003e 0) \u003d\u003e ((len items) \u003e 0)))","state invariant holds obligation:(forall priority6:nat, id7:nat1, allocator8:TrayAllocator, items9:seq of (Item), stepCount10:nat \u0026 (((priority6 \u003e 0) \u003d\u003e ((len items9) \u003e 0)) \u003d\u003e (((priority6 \u003e 0) \u003d\u003e ((len items9) \u003e 0)) \u003d\u003e ((priority6 \u003e 0) \u003d\u003e ((len items9) \u003e 0)))))","non-empty sequence obligation:(items \u003c\u003e [])","state invariant holds obligation:(((priority \u003e 0) \u003d\u003e ((len items) \u003e 0)) \u003d\u003e ((0 \u003e 0) \u003d\u003e ((len (tl items)) \u003e 0)))","state invariant holds obligation:(((0 \u003e 0) \u003d\u003e ((len (tl items)) \u003e 0)) \u003d\u003e (((0 + 1) \u003e 0) \u003d\u003e ((len (tl items)) \u003e 0)))","type compatibility obligation:(forall trayAtCardReader:UID, icid:nat \u0026 (inv_UID((((trayAtCardReader + (icid * TrayAllocator`InductionSeperation)) mod TrayAllocator`NumOfTrays) + 1)) and is_((((trayAtCardReader + (icid * TrayAllocator`InductionSeperation)) mod TrayAllocator`NumOfTrays) + 1), nat)))","legal map application obligation:(forall icid:nat \u0026 ((icid in set (inds (trayAllocator.inductionGroup))) \u003d\u003e (posTray in set (dom (trayAllocator.sorterRing)))))","legal map application obligation:(forall icid:nat \u0026 ((icid in set (inds (trayAllocator.inductionGroup))) \u003d\u003e (posTray in set (dom (trayAllocator.sorterRing)))))","operation call obligation:(forall text:seq of (char) \u0026 ((\"\" \u003d \"\") \u003c\u003d\u003e (\"\" \u003d nil)))"] \ No newline at end of file +["legal function application obligation:(forall fname:seq1 of (char) \u0026 pre_(((io.freadval))[InputTP]fname))","type compatibility obligation:(forall fname:seq1 of (char) \u0026 (timeval \u003e\u003d 0))","type compatibility obligation:inv_UID(0)","comprehension map injectivity obligation:(forall e:SorterEnviroment \u0026 (forall m1, m2 in set {{num |-\u003e new Tray(num)} | num in set {1, ... ,NumOfTrays}} \u0026 (forall d3 in set (dom m1), d4 in set (dom m2) \u0026 ((d3 \u003d d4) \u003d\u003e (m1(d3) \u003d m2(d4))))))","type compatibility obligation:(forall e:SorterEnviroment \u0026 is_({num |-\u003e new Tray(num) | num in set {1, ... ,NumOfTrays}}, inmap (UID) to (Tray)))","state invariant holds obligation:(forall e:SorterEnviroment \u0026 ((((((NumOfTrays \u003e (InductionSeperation * NumOfInductions)) and ((len [new InductionController(self, num) | num in set {1, ... ,NumOfInductions}]) \u003d NumOfInductions)) and (forall id in set (inds inductionGroup) \u0026 ((inductionGroup(id).GetId)() \u003d id))) and ((card (dom {num |-\u003e new Tray(num) | num in set {1, ... ,NumOfTrays}})) \u003d NumOfTrays)) and (forall id in set (dom sorterRing) \u0026 ((sorterRing(id).GetId)() \u003d id))) and ((trayAtCardReader \u003e 0) \u003d\u003e (trayAtCardReader in set (dom {num |-\u003e new Tray(num) | num in set {1, ... ,NumOfTrays}})))))","state invariant holds obligation:(forall uid:UID, state:State \u0026 ((uid in set (dom sorterRing)) \u003d\u003e (((((((NumOfTrays \u003e (InductionSeperation * NumOfInductions)) and ((len inductionGroup) \u003d NumOfInductions)) and (forall id in set (inds inductionGroup) \u0026 ((inductionGroup(id).GetId)() \u003d id))) and ((card (dom sorterRing)) \u003d NumOfTrays)) and (forall id in set (dom sorterRing) \u0026 ((sorterRing(id).GetId)() \u003d id))) and ((trayAtCardReader \u003e 0) \u003d\u003e (trayAtCardReader in set (dom sorterRing)))) \u003d\u003e ((((((NumOfTrays \u003e (InductionSeperation * NumOfInductions)) and ((len inductionGroup) \u003d NumOfInductions)) and (forall id in set (inds inductionGroup) \u0026 ((inductionGroup(id).GetId)() \u003d id))) and ((card (dom sorterRing)) \u003d NumOfTrays)) and (forall id in set (dom sorterRing) \u0026 ((sorterRing(id).GetId)() \u003d id))) and ((uid \u003e 0) \u003d\u003e (uid in set (dom sorterRing)))))))","state invariant holds obligation:(forall uid:UID, state:State \u0026 ((uid in set (dom sorterRing)) \u003d\u003e (((((((NumOfTrays \u003e (InductionSeperation * NumOfInductions)) and ((len inductionGroup) \u003d NumOfInductions)) and (forall id in set (inds inductionGroup) \u0026 ((inductionGroup(id).GetId)() \u003d id))) and ((card (dom sorterRing)) \u003d NumOfTrays)) and (forall id in set (dom sorterRing) \u0026 ((sorterRing(id).GetId)() \u003d id))) and ((uid \u003e 0) \u003d\u003e (uid in set (dom sorterRing)))) \u003d\u003e ((((((NumOfTrays \u003e (InductionSeperation * NumOfInductions)) and ((len inductionGroup) \u003d NumOfInductions)) and (forall id in set (inds inductionGroup) \u0026 ((inductionGroup(id).GetId)() \u003d id))) and ((card (dom sorterRing)) \u003d NumOfTrays)) and (forall id in set (dom sorterRing) \u0026 ((sorterRing(id).GetId)() \u003d id))) and ((uid \u003e 0) \u003d\u003e (uid in set (dom sorterRing)))))))","state invariant holds obligation:(forall ic:InductionController, item:Item \u0026 (((ic in set (elems inductionGroup)) and ((item.GetSizeOfTrays)() \u003c\u003d 2)) \u003d\u003e (((((((NumOfTrays \u003e (InductionSeperation * NumOfInductions)) and ((len inductionGroup) \u003d NumOfInductions)) and (forall id in set (inds inductionGroup) \u0026 ((inductionGroup(id).GetId)() \u003d id))) and ((card (dom sorterRing)) \u003d NumOfTrays)) and (forall id in set (dom sorterRing) \u0026 ((sorterRing(id).GetId)() \u003d id))) and ((trayAtCardReader \u003e 0) \u003d\u003e (trayAtCardReader in set (dom sorterRing)))) \u003d\u003e ((((((NumOfTrays \u003e (InductionSeperation * NumOfInductions)) and ((len inductionGroup) \u003d NumOfInductions)) and (forall id in set (inds inductionGroup) \u0026 ((inductionGroup(id).GetId)() \u003d id))) and ((card (dom sorterRing)) \u003d NumOfTrays)) and (forall id in set (dom sorterRing) \u0026 ((sorterRing(id).GetId)() \u003d id))) and ((trayAtCardReader \u003e 0) \u003d\u003e (trayAtCardReader in set (dom sorterRing)))))))","state invariant holds obligation:(forall ic:InductionController, item:Item \u0026 (((ic in set (elems inductionGroup)) and ((item.GetSizeOfTrays)() \u003c\u003d 2)) \u003d\u003e (((((((NumOfTrays \u003e (InductionSeperation * NumOfInductions)) and ((len inductionGroup) \u003d NumOfInductions)) and (forall id in set (inds inductionGroup) \u0026 ((inductionGroup(id).GetId)() \u003d id))) and ((card (dom sorterRing)) \u003d NumOfTrays)) and (forall id in set (dom sorterRing) \u0026 ((sorterRing(id).GetId)() \u003d id))) and ((trayAtCardReader \u003e 0) \u003d\u003e (trayAtCardReader in set (dom sorterRing)))) \u003d\u003e ((((((NumOfTrays \u003e (InductionSeperation * NumOfInductions)) and ((len inductionGroup) \u003d NumOfInductions)) and (forall id in set (inds inductionGroup) \u0026 ((inductionGroup(id).GetId)() \u003d id))) and ((card (dom sorterRing)) \u003d NumOfTrays)) and (forall id in set (dom sorterRing) \u0026 ((sorterRing(id).GetId)() \u003d id))) and ((trayAtCardReader \u003e 0) \u003d\u003e (trayAtCardReader in set (dom sorterRing)))))))","state invariant holds obligation:(forall ic:InductionController, item:Item \u0026 (((ic in set (elems inductionGroup)) and ((item.GetSizeOfTrays)() \u003c\u003d 2)) \u003d\u003e (((((((NumOfTrays \u003e (InductionSeperation * NumOfInductions)) and ((len inductionGroup) \u003d NumOfInductions)) and (forall id in set (inds inductionGroup) \u0026 ((inductionGroup(id).GetId)() \u003d id))) and ((card (dom sorterRing)) \u003d NumOfTrays)) and (forall id in set (dom sorterRing) \u0026 ((sorterRing(id).GetId)() \u003d id))) and ((trayAtCardReader \u003e 0) \u003d\u003e (trayAtCardReader in set (dom sorterRing)))) \u003d\u003e ((((((NumOfTrays \u003e (InductionSeperation * NumOfInductions)) and ((len inductionGroup) \u003d NumOfInductions)) and (forall id in set (inds inductionGroup) \u0026 ((inductionGroup(id).GetId)() \u003d id))) and ((card (dom sorterRing)) \u003d NumOfTrays)) and (forall id in set (dom sorterRing) \u0026 ((sorterRing(id).GetId)() \u003d id))) and ((trayAtCardReader \u003e 0) \u003d\u003e (trayAtCardReader in set (dom sorterRing)))))))","operation call obligation:(forall ic:InductionController, item:Item \u0026 (((ic in set (elems inductionGroup)) and ((item.GetSizeOfTrays)() \u003c\u003d 2)) \u003d\u003e (true \u003d\u003e ((item \u003c\u003e {}) and (forall t in set trays \u0026 (t.IsTrayEmpty)())))))","legal map application obligation:(forall id in set (dom sorterRing) \u0026 (id in set (dom sorterRing)))","non-zero obligation:(forall steps:nat, trays:set of (Tray), items:nat \u0026 ((trays \u003c\u003e {}) \u003d\u003e (SorterEnviroment`Speed \u003c\u003e 0)))","non-zero obligation:(forall steps:nat, trays:set of (Tray), items:nat \u0026 ((trays \u003c\u003e {}) \u003d\u003e (runTime \u003c\u003e 0)))","legal map application obligation:(forall icid:nat \u0026 ((icid in set (inds (trayAllocator.inductionGroup))) \u003d\u003e (posTray in set (dom (trayAllocator.sorterRing)))))","legal map application obligation:(forall icid:nat \u0026 ((icid in set (inds (trayAllocator.inductionGroup))) \u003d\u003e (((trayAllocator.sorterRing)(posTray).IsTrayEmpty)() \u003d\u003e (posTrayNext in set (dom (trayAllocator.sorterRing))))))","type compatibility obligation:(forall icid:nat \u0026 ((icid in set (inds (trayAllocator.inductionGroup))) \u003d\u003e (((trayAllocator.sorterRing)(posTray).IsTrayEmpty)() \u003d\u003e (inv_UID(posTrayNext) and is_(posTrayNext, nat)))))","legal map application obligation:(forall icid:nat \u0026 ((icid in set (inds (trayAllocator.inductionGroup))) \u003d\u003e (posTray in set (dom (trayAllocator.sorterRing)))))","legal map application obligation:(forall icid:nat \u0026 ((icid in set (inds (trayAllocator.inductionGroup))) \u003d\u003e (posTrayNext in set (dom (trayAllocator.sorterRing)))))","type compatibility obligation:(forall icid:nat \u0026 ((icid in set (inds (trayAllocator.inductionGroup))) \u003d\u003e (inv_UID(posTrayNext) and is_(posTrayNext, nat))))","legal sequence application obligation:(test in set (inds testfiles))","legal sequence application obligation:(true \u003d\u003e (test in set (inds testfiles)))","while loop termination obligation:...","type compatibility obligation:(forall val:nat \u0026 (((x1 mod 10) + 1) \u003e\u003d 0))","legal sequence application obligation:(forall val:nat \u0026 (((x1 mod 10) + 1) in set (inds numeric)))","type compatibility obligation:(forall val:nat \u0026 ((x1 div 10) \u003e\u003d 0))","type invariant satisfiable obligation:(exists u:UID \u0026 (u \u003c\u003d TrayAllocator`NumOfTrays))","state invariant holds obligation:(forall i:UID \u0026 ((item \u003c\u003e nil) \u003d\u003e (state \u003d \u003cFull\u003e)))","state invariant holds obligation:(forall s:State \u0026 (((item \u003c\u003e nil) \u003d\u003e (state \u003d \u003cFull\u003e)) \u003d\u003e ((nil \u003c\u003e nil) \u003d\u003e (state \u003d \u003cFull\u003e))))","state invariant holds obligation:(forall s:State \u0026 (((nil \u003c\u003e nil) \u003d\u003e (state \u003d \u003cFull\u003e)) \u003d\u003e ((nil \u003c\u003e nil) \u003d\u003e (s \u003d \u003cFull\u003e))))","state invariant holds obligation:(((item \u003c\u003e nil) \u003d\u003e (state \u003d \u003cFull\u003e)) \u003d\u003e ((i \u003c\u003e nil) \u003d\u003e (\u003cFull\u003e \u003d \u003cFull\u003e)))","type invariant satisfiable obligation:(exists it:ItemTraySize \u0026 (it \u003c\u003d ItemMaxTrays))","non-zero obligation:(forall s:nat1, i:nat \u0026 (Tray`TraySize \u003c\u003e 0))","type compatibility obligation:(forall s:nat1, i:nat \u0026 (inv_ItemTraySize(((size div Tray`TraySize) + 1)) and is_(((size div Tray`TraySize) + 1), nat1)))","state invariant holds obligation:(forall s:nat1, i:nat \u0026 ((s \u003e\u003d ItemMinSize) and (s \u003c\u003d ItemMaxSize)))","state invariant holds obligation:(forall tray:Tray \u0026 (((size \u003e\u003d ItemMinSize) and (size \u003c\u003d ItemMaxSize)) \u003d\u003e ((size \u003e\u003d ItemMinSize) and (size \u003c\u003d ItemMaxSize))))","operation postcondition satisfiable obligation:(exists newself:Item \u0026 post_RemoveItemFromTray(oldself, newself))","type compatibility obligation:(forall a:TrayAllocator, n:nat \u0026 (n \u003e 0))","state invariant holds obligation:(forall a:TrayAllocator, n:nat \u0026 ((priority \u003e 0) \u003d\u003e ((len items) \u003e 0)))","non-empty sequence obligation:(items \u003c\u003e [])","state invariant holds obligation:(forall i:Item \u0026 (((priority \u003e 0) \u003d\u003e ((len items) \u003e 0)) \u003d\u003e ((priority \u003e 0) \u003d\u003e ((len (items ^ [i])) \u003e 0))))","state invariant holds obligation:(((priority \u003e 0) \u003d\u003e ((len items) \u003e 0)) \u003d\u003e ((priority \u003e 0) \u003d\u003e ((len items) \u003e 0)))","state invariant holds obligation:(forall priority6:nat, id7:nat1, allocator8:TrayAllocator, items9:seq of (Item), stepCount10:nat \u0026 (((priority6 \u003e 0) \u003d\u003e ((len items9) \u003e 0)) \u003d\u003e (((priority6 \u003e 0) \u003d\u003e ((len items9) \u003e 0)) \u003d\u003e ((priority6 \u003e 0) \u003d\u003e ((len items9) \u003e 0)))))","non-empty sequence obligation:(items \u003c\u003e [])","state invariant holds obligation:(((priority \u003e 0) \u003d\u003e ((len items) \u003e 0)) \u003d\u003e ((0 \u003e 0) \u003d\u003e ((len (tl items)) \u003e 0)))","state invariant holds obligation:(((0 \u003e 0) \u003d\u003e ((len (tl items)) \u003e 0)) \u003d\u003e (((0 + 1) \u003e 0) \u003d\u003e ((len (tl items)) \u003e 0)))","type compatibility obligation:(forall trayAtCardReader:UID, icid:nat \u0026 (inv_UID((((trayAtCardReader + (icid * TrayAllocator`InductionSeperation)) mod TrayAllocator`NumOfTrays) + 1)) and is_((((trayAtCardReader + (icid * TrayAllocator`InductionSeperation)) mod TrayAllocator`NumOfTrays) + 1), nat)))","legal map application obligation:(forall icid:nat \u0026 ((icid in set (inds (trayAllocator.inductionGroup))) \u003d\u003e (posTray in set (dom (trayAllocator.sorterRing)))))","legal map application obligation:(forall icid:nat \u0026 ((icid in set (inds (trayAllocator.inductionGroup))) \u003d\u003e (posTray in set (dom (trayAllocator.sorterRing)))))","operation call obligation:(forall text:seq of (char) \u0026 ((\"\" \u003d \"\") \u003c\u003d\u003e (\"\" \u003d nil)))"] \ No newline at end of file diff --git a/core/pog/src/test/resources/examples/treePP.result b/core/pog/src/test/resources/examples/treePP.result index d2f42cf40c..6876a44e42 100644 --- a/core/pog/src/test/resources/examples/treePP.result +++ b/core/pog/src/test/resources/examples/treePP.result @@ -1 +1 @@ -["while loop termination obligation:NotYetImplemented","non-empty sequence obligation:((not isEmpty()) \u003d\u003e (vals \u003c\u003e []))","non-empty sequence obligation:((not isEmpty()) \u003d\u003e (vals \u003c\u003e []))","cases exhaustive obligation:(forall t:tree \u0026 ((t \u003d \u003cEmpty\u003e) or (exists mk_node(lt, v, rt):tree \u0026 (t \u003d mk_node(lt, v, rt)))))","while loop termination obligation:NotYetImplemented"] \ No newline at end of file +["while loop termination obligation:...","non-empty sequence obligation:((not isEmpty()) \u003d\u003e (vals \u003c\u003e []))","non-empty sequence obligation:((not isEmpty()) \u003d\u003e (vals \u003c\u003e []))","cases exhaustive obligation:(forall t:tree \u0026 ((t \u003d \u003cEmpty\u003e) or (exists mk_node(lt, v, rt):tree \u0026 (t \u003d mk_node(lt, v, rt)))))","while loop termination obligation:..."] \ No newline at end of file diff --git a/core/pog/src/test/resources/old/direct/pp/DiningPP.vdmpp.result b/core/pog/src/test/resources/old/direct/pp/DiningPP.vdmpp.result index 10bc093ef2..46e0f77b46 100644 --- a/core/pog/src/test/resources/old/direct/pp/DiningPP.vdmpp.result +++ b/core/pog/src/test/resources/old/direct/pp/DiningPP.vdmpp.result @@ -1 +1 @@ -["type compatibility obligation:((turns - 1) \u003e\u003d 0)","while loop termination obligation:NotYetImplemented","type compatibility obligation:((forks - 1) \u003e\u003d 0)"] \ No newline at end of file +["type compatibility obligation:((turns - 1) \u003e\u003d 0)","while loop termination obligation:...","type compatibility obligation:((forks - 1) \u003e\u003d 0)"] \ No newline at end of file diff --git a/core/pog/src/test/resources/old/direct/pp/HomeAutomationConcPP.vdmpp.result b/core/pog/src/test/resources/old/direct/pp/HomeAutomationConcPP.vdmpp.result index e663067c63..51c65b9287 100644 --- a/core/pog/src/test/resources/old/direct/pp/HomeAutomationConcPP.vdmpp.result +++ b/core/pog/src/test/resources/old/direct/pp/HomeAutomationConcPP.vdmpp.result @@ -1 +1 @@ -["legal function application obligation:(forall fname:seq of (char) \u0026 pre_(((io.freadval))[(nat * seq of (inline))]fname))","non-empty sequence obligation:(inlines \u003c\u003e [])","non-empty sequence obligation:(true \u003d\u003e (true \u003d\u003e (inlines \u003c\u003e [])))","operation establishes postcondition obligation:(forall id:nat, type:nodeType \u0026 ((id not in set (dom NodeList)) \u003d\u003e (forall finished1:bool, print2:bool, TargetTemp3:nat, Temp4:nat, TargetHumid5:nat, Humid6:nat, NodeList7:map (nat) to (nodeType), Algo8:algType \u0026 (true \u003d\u003e ((card (dom NodeList7)) \u003d ((card (dom NodeList)) + 1))))))","legal map application obligation:(forall id:nat, type:nodeType \u0026 ((id in set (dom NodeList)) \u003d\u003e (id in set (dom NodeList))))","operation establishes postcondition obligation:(forall id:nat, type:nodeType \u0026 ((id in set (dom NodeList)) \u003d\u003e ((card (dom ({id} \u003c-: NodeList))) \u003d ((card (dom NodeList)) - 1))))","operation call obligation:(forall text:seq of (char) \u0026 ((\"\" \u003d \"\") \u003c\u003d\u003e (\"\" \u003d nil)))","type compatibility obligation:((envTemp - 1) \u003e\u003d 0)","type compatibility obligation:((envHumid - 1) \u003e\u003d 0)","while loop termination obligation:NotYetImplemented","legal map application obligation:(forall th in set (dom wakeUpMap) \u0026 (th in set (dom wakeUpMap)))","legal map application obligation:(forall th in set (dom wakeUpMap) \u0026 ((wakeUpMap(th) \u003c\u003e nil) \u003d\u003e (th in set (dom wakeUpMap))))","operation establishes postcondition obligation:(forall x in set (rng wakeUpMap) \u0026 ((x \u003d nil) or (x \u003e\u003d currentTime)))"] \ No newline at end of file +["legal function application obligation:(forall fname:seq of (char) \u0026 pre_(((io.freadval))[(nat * seq of (inline))]fname))","non-empty sequence obligation:(inlines \u003c\u003e [])","non-empty sequence obligation:(true \u003d\u003e (true \u003d\u003e (inlines \u003c\u003e [])))","operation establishes postcondition obligation:(forall id:nat, type:nodeType \u0026 ((id not in set (dom NodeList)) \u003d\u003e (forall finished1:bool, print2:bool, TargetTemp3:nat, Temp4:nat, TargetHumid5:nat, Humid6:nat, NodeList7:map (nat) to (nodeType), Algo8:algType \u0026 (true \u003d\u003e ((card (dom NodeList7)) \u003d ((card (dom NodeList)) + 1))))))","legal map application obligation:(forall id:nat, type:nodeType \u0026 ((id in set (dom NodeList)) \u003d\u003e (id in set (dom NodeList))))","operation establishes postcondition obligation:(forall id:nat, type:nodeType \u0026 ((id in set (dom NodeList)) \u003d\u003e ((card (dom ({id} \u003c-: NodeList))) \u003d ((card (dom NodeList)) - 1))))","operation call obligation:(forall text:seq of (char) \u0026 ((\"\" \u003d \"\") \u003c\u003d\u003e (\"\" \u003d nil)))","type compatibility obligation:((envTemp - 1) \u003e\u003d 0)","type compatibility obligation:((envHumid - 1) \u003e\u003d 0)","while loop termination obligation:...","legal map application obligation:(forall th in set (dom wakeUpMap) \u0026 (th in set (dom wakeUpMap)))","legal map application obligation:(forall th in set (dom wakeUpMap) \u0026 ((wakeUpMap(th) \u003c\u003e nil) \u003d\u003e (th in set (dom wakeUpMap))))","operation establishes postcondition obligation:(forall x in set (rng wakeUpMap) \u0026 ((x \u003d nil) or (x \u003e\u003d currentTime)))"] \ No newline at end of file diff --git a/core/pog/src/test/resources/old/direct/sl/LUPSLSL.vdmsl.result b/core/pog/src/test/resources/old/direct/sl/LUPSLSL.vdmsl.result index 27856dc08a..0262e605c4 100644 --- a/core/pog/src/test/resources/old/direct/sl/LUPSLSL.vdmsl.result +++ b/core/pog/src/test/resources/old/direct/sl/LUPSLSL.vdmsl.result @@ -1 +1 @@ -["function establishes postcondition obligation:(forall s:set of (int) \u0026 (pre_MaxOfSet(s) \u003d\u003e post_MaxOfSet(s, let e in set s in (if ((card s) \u003d 1)\nthen e\nelse let mr:int \u003d MaxOfSet((s \\ {e})) in (if (e \u003e mr)\nthen e\nelse mr)))))","let be st existence obligation:(forall s:set of (int) \u0026 ((s \u003c\u003e {}) \u003d\u003e (exists e in set s \u0026 true)))","legal function application obligation:(forall s:set of (int) \u0026 ((s \u003c\u003e {}) \u003d\u003e (forall e in set s \u0026 ((not ((card s) \u003d 1)) \u003d\u003e pre_MaxOfSet((s \\ {e}))))))","recursive function obligation:(forall s:set of (int) \u0026 ((s \u003c\u003e {}) \u003d\u003e (forall e in set s \u0026 ((not ((card s) \u003d 1)) \u003d\u003e (CardInt(s) \u003e CardInt((s \\ {e})))))))","legal sequence application obligation:(forall a:array, k:nat1 \u0026 (forall j in set {1, ... ,(k - 1)} \u0026 (j in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1 \u0026 (forall j in set {1, ... ,(k - 1)} \u0026 (k in set (inds a))))","legal function application obligation:(forall a:array, k:nat1 \u0026 let compatible:set of (nat) \u003d {lupsltok(a, j) | j in set {1, ... ,(k - 1)} \u0026 (a(j) \u003c\u003d a(k))} in ((not (compatible \u003d {})) \u003d\u003e pre_MaxOfSet(compatible)))","type compatibility obligation:(forall a:array, k:nat1 \u0026 (let compatible:set of (nat) \u003d {lupsltok(a, j) | j in set {1, ... ,(k - 1)} \u0026 (a(j) \u003c\u003d a(k))} in (if (compatible \u003d {})\nthen 1\nelse (MaxOfSet(compatible) + 1)) \u003e\u003d 0))","legal function application obligation:(forall a:array \u0026 pre_MaxOfSet({lupsltok(a, j) | j in set (inds a)}))","type compatibility obligation:(forall a:array \u0026 (MaxOfSet({lupsltok(a, j) | j in set (inds a)}) \u003e\u003d 0))","legal sequence application obligation:(forall a:array, s:set of (int) \u0026 ((s subset (inds a)) \u003d\u003e (forall i, j in set s \u0026 ((i \u003c j) \u003d\u003e (i in set (inds a))))))","legal sequence application obligation:(forall a:array, s:set of (int) \u0026 ((s subset (inds a)) \u003d\u003e (forall i, j in set s \u0026 ((i \u003c j) \u003d\u003e (j in set (inds a))))))","legal function application obligation:(forall a:array \u0026 pre_MaxOfSet({(card s) | s in set (power (inds a)) \u0026 ascending(a, s)}))","legal function application obligation:(forall a:array \u0026 (forall s in set (power (inds a)) \u0026 pre_ascending(a, s)))","legal function application obligation:(forall a:array, oldstate:lups \u0026 pre_MaxOfSet(lupsls))","type compatibility obligation:(forall a:array, oldstate:lups \u0026 (RESULT \u003e\u003d 0))","operation establishes postcondition obligation:(forall a:array, oldstate:lups \u0026 (lupslSpec(a) \u003d RESULT))","legal sequence application obligation:(forall a:array, oldstate:lups \u0026 (1 in set (inds a)))","operation call obligation:(forall a:array, oldstate:lups \u0026 (a in set (inds a)))","operation establishes postcondition obligation:(forall a:array, oldstate:lups \u0026 (true \u003d\u003e (lupslSpec(a) \u003d RESULT)))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e ((len lupslarr) in set (inds lupslarr))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","unique existence binding obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (exists1 x in set {1, ... ,(len lupslarr)} \u0026 ((lupslarr(x) \u003e a(k)) and (forall j in set {1, ... ,(x - 1)} \u0026 (lupslarr(j) \u003c\u003d a(k)))))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (forall x in set {1, ... ,(len lupslarr)} \u0026 (x in set (inds lupslarr)))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (forall x in set {1, ... ,(len lupslarr)} \u0026 (k in set (inds a)))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (forall x in set {1, ... ,(len lupslarr)} \u0026 ((lupslarr(x) \u003e a(k)) \u003d\u003e (forall j in set {1, ... ,(x - 1)} \u0026 (j in set (inds lupslarr)))))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (forall x in set {1, ... ,(len lupslarr)} \u0026 ((lupslarr(x) \u003e a(k)) \u003d\u003e (forall j in set {1, ... ,(x - 1)} \u0026 (k in set (inds a)))))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (((iota x in set {1, ... ,(len lupslarr)} \u0026 ((lupslarr(x) \u003e a(k)) and (forall j in set {1, ... ,(x - 1)} \u0026 (lupslarr(j) \u003c\u003d a(k))))) \u003e 0) and ((iota x in set {1, ... ,(len lupslarr)} \u0026 ((lupslarr(x) \u003e a(k)) and (forall j in set {1, ... ,(x - 1)} \u0026 (lupslarr(j) \u003c\u003d a(k))))) \u003c\u003d ((len (lupslarr ^ [a(k)])) + 1)))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","operation establishes postcondition obligation:(forall a:array, oldstate:lups \u0026 (lupslSpec(a) \u003d RESULT))","legal sequence application obligation:(forall a:array, oldstate:lups \u0026 (1 in set (inds a)))","operation call obligation:(forall a:array, oldstate:lups \u0026 (a in set (inds a)))","operation establishes postcondition obligation:(forall a:array, oldstate:lups \u0026 (true \u003d\u003e (lupslSpec(a) \u003d RESULT)))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e ((len lupslarr) in set (inds lupslarr))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","while loop termination obligation:NotYetImplemented","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (1 in set (inds (lupslarr ^ [a(k)])))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (((1 + 1) \u003e 0) and ((1 + 1) \u003c\u003d ((len (lupslarr ^ [a(k)])) + 1)))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","operation establishes postcondition obligation:(forall a:array, oldstate:lups \u0026 (lupslSpec(a) \u003d RESULT))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (j in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (j in set (inds lupslarr))))","legal function application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e pre_MaxOfSet(compatible)))","type compatibility obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (RESULT \u003e\u003d 0)))","legal sequence application obligation:(forall a:array, oldstate:lups \u0026 (1 in set (inds a)))","operation call obligation:(forall a:array, oldstate:lups \u0026 (a in set (inds a)))","operation establishes postcondition obligation:(forall a:array, oldstate:lups \u0026 (true \u003d\u003e (lupslSpec(a) \u003d RESULT)))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e ((len lupslarr) in set (inds lupslarr))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (1 in set (inds (lupslarr ^ [a(k)])))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e ((1 \u003e 0) and (1 \u003c\u003d ((len (lupslarr ^ [a(k)])) + 1)))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","while loop termination obligation:NotYetImplemented","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (((1 + (len (lupslarr ^ [a(k)]))) div 2) in set (inds (lupslarr ^ [a(k)])))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e ((((1 + (len (lupslarr ^ [a(k)]))) div 2) \u003e 0) and (((1 + (len (lupslarr ^ [a(k)]))) div 2) \u003c\u003d ((len (lupslarr ^ [a(k)])) + 1)))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","operation establishes postcondition obligation:(forall a:array, oldstate:lups \u0026 (lupslSpec(a) \u003d RESULT))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (j in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (j in set (inds lupslarr))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (j in set (inds lupslarr))))","type compatibility obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (RESULT \u003e\u003d 0)))"] \ No newline at end of file +["function establishes postcondition obligation:(forall s:set of (int) \u0026 (pre_MaxOfSet(s) \u003d\u003e post_MaxOfSet(s, let e in set s in (if ((card s) \u003d 1)\nthen e\nelse let mr:int \u003d MaxOfSet((s \\ {e})) in (if (e \u003e mr)\nthen e\nelse mr)))))","let be st existence obligation:(forall s:set of (int) \u0026 ((s \u003c\u003e {}) \u003d\u003e (exists e in set s \u0026 true)))","legal function application obligation:(forall s:set of (int) \u0026 ((s \u003c\u003e {}) \u003d\u003e (forall e in set s \u0026 ((not ((card s) \u003d 1)) \u003d\u003e pre_MaxOfSet((s \\ {e}))))))","recursive function obligation:(forall s:set of (int) \u0026 ((s \u003c\u003e {}) \u003d\u003e (forall e in set s \u0026 ((not ((card s) \u003d 1)) \u003d\u003e (CardInt(s) \u003e CardInt((s \\ {e})))))))","legal sequence application obligation:(forall a:array, k:nat1 \u0026 (forall j in set {1, ... ,(k - 1)} \u0026 (j in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1 \u0026 (forall j in set {1, ... ,(k - 1)} \u0026 (k in set (inds a))))","legal function application obligation:(forall a:array, k:nat1 \u0026 let compatible:set of (nat) \u003d {lupsltok(a, j) | j in set {1, ... ,(k - 1)} \u0026 (a(j) \u003c\u003d a(k))} in ((not (compatible \u003d {})) \u003d\u003e pre_MaxOfSet(compatible)))","type compatibility obligation:(forall a:array, k:nat1 \u0026 (let compatible:set of (nat) \u003d {lupsltok(a, j) | j in set {1, ... ,(k - 1)} \u0026 (a(j) \u003c\u003d a(k))} in (if (compatible \u003d {})\nthen 1\nelse (MaxOfSet(compatible) + 1)) \u003e\u003d 0))","legal function application obligation:(forall a:array \u0026 pre_MaxOfSet({lupsltok(a, j) | j in set (inds a)}))","type compatibility obligation:(forall a:array \u0026 (MaxOfSet({lupsltok(a, j) | j in set (inds a)}) \u003e\u003d 0))","legal sequence application obligation:(forall a:array, s:set of (int) \u0026 ((s subset (inds a)) \u003d\u003e (forall i, j in set s \u0026 ((i \u003c j) \u003d\u003e (i in set (inds a))))))","legal sequence application obligation:(forall a:array, s:set of (int) \u0026 ((s subset (inds a)) \u003d\u003e (forall i, j in set s \u0026 ((i \u003c j) \u003d\u003e (j in set (inds a))))))","legal function application obligation:(forall a:array \u0026 pre_MaxOfSet({(card s) | s in set (power (inds a)) \u0026 ascending(a, s)}))","legal function application obligation:(forall a:array \u0026 (forall s in set (power (inds a)) \u0026 pre_ascending(a, s)))","legal function application obligation:(forall a:array, oldstate:lups \u0026 pre_MaxOfSet(lupsls))","type compatibility obligation:(forall a:array, oldstate:lups \u0026 (RESULT \u003e\u003d 0))","operation establishes postcondition obligation:(forall a:array, oldstate:lups \u0026 (lupslSpec(a) \u003d RESULT))","legal sequence application obligation:(forall a:array, oldstate:lups \u0026 (1 in set (inds a)))","operation call obligation:(forall a:array, oldstate:lups \u0026 (a in set (inds a)))","operation establishes postcondition obligation:(forall a:array, oldstate:lups \u0026 (true \u003d\u003e (lupslSpec(a) \u003d RESULT)))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e ((len lupslarr) in set (inds lupslarr))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","unique existence binding obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (exists1 x in set {1, ... ,(len lupslarr)} \u0026 ((lupslarr(x) \u003e a(k)) and (forall j in set {1, ... ,(x - 1)} \u0026 (lupslarr(j) \u003c\u003d a(k)))))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (forall x in set {1, ... ,(len lupslarr)} \u0026 (x in set (inds lupslarr)))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (forall x in set {1, ... ,(len lupslarr)} \u0026 (k in set (inds a)))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (forall x in set {1, ... ,(len lupslarr)} \u0026 ((lupslarr(x) \u003e a(k)) \u003d\u003e (forall j in set {1, ... ,(x - 1)} \u0026 (j in set (inds lupslarr)))))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (forall x in set {1, ... ,(len lupslarr)} \u0026 ((lupslarr(x) \u003e a(k)) \u003d\u003e (forall j in set {1, ... ,(x - 1)} \u0026 (k in set (inds a)))))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (((iota x in set {1, ... ,(len lupslarr)} \u0026 ((lupslarr(x) \u003e a(k)) and (forall j in set {1, ... ,(x - 1)} \u0026 (lupslarr(j) \u003c\u003d a(k))))) \u003e 0) and ((iota x in set {1, ... ,(len lupslarr)} \u0026 ((lupslarr(x) \u003e a(k)) and (forall j in set {1, ... ,(x - 1)} \u0026 (lupslarr(j) \u003c\u003d a(k))))) \u003c\u003d ((len (lupslarr ^ [a(k)])) + 1)))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","operation establishes postcondition obligation:(forall a:array, oldstate:lups \u0026 (lupslSpec(a) \u003d RESULT))","legal sequence application obligation:(forall a:array, oldstate:lups \u0026 (1 in set (inds a)))","operation call obligation:(forall a:array, oldstate:lups \u0026 (a in set (inds a)))","operation establishes postcondition obligation:(forall a:array, oldstate:lups \u0026 (true \u003d\u003e (lupslSpec(a) \u003d RESULT)))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e ((len lupslarr) in set (inds lupslarr))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","while loop termination obligation:...","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (1 in set (inds (lupslarr ^ [a(k)])))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (((1 + 1) \u003e 0) and ((1 + 1) \u003c\u003d ((len (lupslarr ^ [a(k)])) + 1)))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","operation establishes postcondition obligation:(forall a:array, oldstate:lups \u0026 (lupslSpec(a) \u003d RESULT))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (j in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (j in set (inds lupslarr))))","legal function application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e pre_MaxOfSet(compatible)))","type compatibility obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (RESULT \u003e\u003d 0)))","legal sequence application obligation:(forall a:array, oldstate:lups \u0026 (1 in set (inds a)))","operation call obligation:(forall a:array, oldstate:lups \u0026 (a in set (inds a)))","operation establishes postcondition obligation:(forall a:array, oldstate:lups \u0026 (true \u003d\u003e (lupslSpec(a) \u003d RESULT)))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e ((len lupslarr) in set (inds lupslarr))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (1 in set (inds (lupslarr ^ [a(k)])))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e ((1 \u003e 0) and (1 \u003c\u003d ((len (lupslarr ^ [a(k)])) + 1)))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","while loop termination obligation:...","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (((1 + (len (lupslarr ^ [a(k)]))) div 2) in set (inds (lupslarr ^ [a(k)])))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e ((((1 + (len (lupslarr ^ [a(k)]))) div 2) \u003e 0) and (((1 + (len (lupslarr ^ [a(k)]))) div 2) \u003c\u003d ((len (lupslarr ^ [a(k)])) + 1)))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","operation establishes postcondition obligation:(forall a:array, oldstate:lups \u0026 (lupslSpec(a) \u003d RESULT))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (j in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (k in set (inds a))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (j in set (inds lupslarr))))","legal sequence application obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (j in set (inds lupslarr))))","type compatibility obligation:(forall a:array, k:nat1, oldstate:lups \u0026 ((k in set (inds a)) \u003d\u003e (RESULT \u003e\u003d 0)))"] \ No newline at end of file diff --git a/core/pog/src/test/resources/old/direct/sl/librarySL.vdmsl.result b/core/pog/src/test/resources/old/direct/sl/librarySL.vdmsl.result index 3ac29c63d4..071dcdc2af 100644 --- a/core/pog/src/test/resources/old/direct/sl/librarySL.vdmsl.result +++ b/core/pog/src/test/resources/old/direct/sl/librarySL.vdmsl.result @@ -1 +1 @@ -["type invariant satisfiable obligation:(exists e:Edition \u0026 (e in set ({1, ... ,50} union {\u003cnil\u003e})))","type invariant satisfiable obligation:(exists e:Month \u0026 (e in set ({1, ... ,12} union {\u003cnil\u003e})))","type invariant satisfiable obligation:(exists e:Year \u0026 (e in set ({1800, ... ,1998} union {\u003cnil\u003e})))","function establishes postcondition obligation:(forall rt:Recordtype \u0026 post_field(rt, (required(rt) union optional(rt))))","function establishes postcondition obligation:(forall dB:set of (Record), i:Id \u0026 (pre_get(dB, i) \u003d\u003e post_get(dB, i, let record in set dB in (if ((record.id) \u003d i)\nthen record\nelse get((dB \\ {record}), i)))))","let be st existence obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e (exists record in set dB \u0026 true)))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e (forall record in set dB \u0026 ((not ((record.id) \u003d i)) \u003d\u003e pre_get((dB \\ {record}), i)))))","recursive function obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e (forall record in set dB \u0026 ((not ((record.id) \u003d i)) \u003d\u003e (CardDb(dB, i) \u003e CardDb((dB \\ {record}), i))))))","function establishes postcondition obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (pre_getvalue(valuetype, dB, i) \u003d\u003e post_getvalue(valuetype, dB, i, (cases valuetype :\n\u003ctitle\u003e -\u003e (get(dB, i).title),\n\u003cauthor\u003e -\u003e (get(dB, i).author),\n\u003cjournal\u003e -\u003e (get(dB, i).journal),\n\u003cyear\u003e -\u003e (get(dB, i).year),\n\u003cbooktitle\u003e -\u003e (get(dB, i).booktitle),\n\u003cinstitution\u003e -\u003e (get(dB, i).institution),\n\u003cpublisher\u003e -\u003e (get(dB, i).publisher)\n end))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e let RESULT \u003d (cases valuetype :\n\u003ctitle\u003e -\u003e (get(dB, i).title),\n\u003cauthor\u003e -\u003e (get(dB, i).author),\n\u003cjournal\u003e -\u003e (get(dB, i).journal),\n\u003cyear\u003e -\u003e (get(dB, i).year),\n\u003cbooktitle\u003e -\u003e (get(dB, i).booktitle),\n\u003cinstitution\u003e -\u003e (get(dB, i).institution),\n\u003cpublisher\u003e -\u003e (get(dB, i).publisher)\n end) in ((valuetype \u003d \u003ctitle\u003e) \u003d\u003e pre_get(dB, i))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e let RESULT \u003d (cases valuetype :\n\u003ctitle\u003e -\u003e (get(dB, i).title),\n\u003cauthor\u003e -\u003e (get(dB, i).author),\n\u003cjournal\u003e -\u003e (get(dB, i).journal),\n\u003cyear\u003e -\u003e (get(dB, i).year),\n\u003cbooktitle\u003e -\u003e (get(dB, i).booktitle),\n\u003cinstitution\u003e -\u003e (get(dB, i).institution),\n\u003cpublisher\u003e -\u003e (get(dB, i).publisher)\n end) in ((not ((valuetype \u003d \u003ctitle\u003e) and (RESULT \u003d (get(dB, i).title)))) \u003d\u003e ((valuetype \u003d \u003cauthor\u003e) \u003d\u003e pre_get(dB, i)))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e let RESULT \u003d (cases valuetype :\n\u003ctitle\u003e -\u003e (get(dB, i).title),\n\u003cauthor\u003e -\u003e (get(dB, i).author),\n\u003cjournal\u003e -\u003e (get(dB, i).journal),\n\u003cyear\u003e -\u003e (get(dB, i).year),\n\u003cbooktitle\u003e -\u003e (get(dB, i).booktitle),\n\u003cinstitution\u003e -\u003e (get(dB, i).institution),\n\u003cpublisher\u003e -\u003e (get(dB, i).publisher)\n end) in ((not ((valuetype \u003d \u003ctitle\u003e) and (RESULT \u003d (get(dB, i).title)))) \u003d\u003e ((not ((valuetype \u003d \u003cauthor\u003e) and (RESULT \u003d (get(dB, i).author)))) \u003d\u003e ((valuetype \u003d \u003cjournal\u003e) \u003d\u003e pre_get(dB, i))))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e let RESULT \u003d (cases valuetype :\n\u003ctitle\u003e -\u003e (get(dB, i).title),\n\u003cauthor\u003e -\u003e (get(dB, i).author),\n\u003cjournal\u003e -\u003e (get(dB, i).journal),\n\u003cyear\u003e -\u003e (get(dB, i).year),\n\u003cbooktitle\u003e -\u003e (get(dB, i).booktitle),\n\u003cinstitution\u003e -\u003e (get(dB, i).institution),\n\u003cpublisher\u003e -\u003e (get(dB, i).publisher)\n end) in ((not ((valuetype \u003d \u003ctitle\u003e) and (RESULT \u003d (get(dB, i).title)))) \u003d\u003e ((not ((valuetype \u003d \u003cauthor\u003e) and (RESULT \u003d (get(dB, i).author)))) \u003d\u003e ((not ((valuetype \u003d \u003cjournal\u003e) and (RESULT \u003d (get(dB, i).journal)))) \u003d\u003e ((valuetype \u003d \u003cyear\u003e) \u003d\u003e pre_get(dB, i)))))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e let RESULT \u003d (cases valuetype :\n\u003ctitle\u003e -\u003e (get(dB, i).title),\n\u003cauthor\u003e -\u003e (get(dB, i).author),\n\u003cjournal\u003e -\u003e (get(dB, i).journal),\n\u003cyear\u003e -\u003e (get(dB, i).year),\n\u003cbooktitle\u003e -\u003e (get(dB, i).booktitle),\n\u003cinstitution\u003e -\u003e (get(dB, i).institution),\n\u003cpublisher\u003e -\u003e (get(dB, i).publisher)\n end) in ((not ((valuetype \u003d \u003ctitle\u003e) and (RESULT \u003d (get(dB, i).title)))) \u003d\u003e ((not ((valuetype \u003d \u003cauthor\u003e) and (RESULT \u003d (get(dB, i).author)))) \u003d\u003e ((not ((valuetype \u003d \u003cjournal\u003e) and (RESULT \u003d (get(dB, i).journal)))) \u003d\u003e ((not ((valuetype \u003d \u003cyear\u003e) and (RESULT \u003d (get(dB, i).year)))) \u003d\u003e ((valuetype \u003d \u003cbooktitle\u003e) \u003d\u003e pre_get(dB, i))))))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e let RESULT \u003d (cases valuetype :\n\u003ctitle\u003e -\u003e (get(dB, i).title),\n\u003cauthor\u003e -\u003e (get(dB, i).author),\n\u003cjournal\u003e -\u003e (get(dB, i).journal),\n\u003cyear\u003e -\u003e (get(dB, i).year),\n\u003cbooktitle\u003e -\u003e (get(dB, i).booktitle),\n\u003cinstitution\u003e -\u003e (get(dB, i).institution),\n\u003cpublisher\u003e -\u003e (get(dB, i).publisher)\n end) in ((not ((valuetype \u003d \u003ctitle\u003e) and (RESULT \u003d (get(dB, i).title)))) \u003d\u003e ((not ((valuetype \u003d \u003cauthor\u003e) and (RESULT \u003d (get(dB, i).author)))) \u003d\u003e ((not ((valuetype \u003d \u003cjournal\u003e) and (RESULT \u003d (get(dB, i).journal)))) \u003d\u003e ((not ((valuetype \u003d \u003cyear\u003e) and (RESULT \u003d (get(dB, i).year)))) \u003d\u003e ((not ((valuetype \u003d \u003cbooktitle\u003e) and (RESULT \u003d (get(dB, i).booktitle)))) \u003d\u003e ((valuetype \u003d \u003cinstitution\u003e) \u003d\u003e pre_get(dB, i)))))))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e let RESULT \u003d (cases valuetype :\n\u003ctitle\u003e -\u003e (get(dB, i).title),\n\u003cauthor\u003e -\u003e (get(dB, i).author),\n\u003cjournal\u003e -\u003e (get(dB, i).journal),\n\u003cyear\u003e -\u003e (get(dB, i).year),\n\u003cbooktitle\u003e -\u003e (get(dB, i).booktitle),\n\u003cinstitution\u003e -\u003e (get(dB, i).institution),\n\u003cpublisher\u003e -\u003e (get(dB, i).publisher)\n end) in ((not ((valuetype \u003d \u003ctitle\u003e) and (RESULT \u003d (get(dB, i).title)))) \u003d\u003e ((not ((valuetype \u003d \u003cauthor\u003e) and (RESULT \u003d (get(dB, i).author)))) \u003d\u003e ((not ((valuetype \u003d \u003cjournal\u003e) and (RESULT \u003d (get(dB, i).journal)))) \u003d\u003e ((not ((valuetype \u003d \u003cyear\u003e) and (RESULT \u003d (get(dB, i).year)))) \u003d\u003e ((not ((valuetype \u003d \u003cbooktitle\u003e) and (RESULT \u003d (get(dB, i).booktitle)))) \u003d\u003e ((not ((valuetype \u003d \u003cinstitution\u003e) and (RESULT \u003d (get(dB, i).institution)))) \u003d\u003e ((valuetype \u003d \u003cpublisher\u003e) \u003d\u003e pre_get(dB, i))))))))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e ((\u003ctitle\u003e \u003d valuetype) \u003d\u003e pre_get(dB, i))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e ((not (\u003ctitle\u003e \u003d valuetype)) \u003d\u003e ((\u003cauthor\u003e \u003d valuetype) \u003d\u003e pre_get(dB, i)))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e ((not (\u003ctitle\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cauthor\u003e \u003d valuetype)) \u003d\u003e ((\u003cjournal\u003e \u003d valuetype) \u003d\u003e pre_get(dB, i))))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e ((not (\u003ctitle\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cauthor\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cjournal\u003e \u003d valuetype)) \u003d\u003e ((\u003cyear\u003e \u003d valuetype) \u003d\u003e pre_get(dB, i)))))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e ((not (\u003ctitle\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cauthor\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cjournal\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cyear\u003e \u003d valuetype)) \u003d\u003e ((\u003cbooktitle\u003e \u003d valuetype) \u003d\u003e pre_get(dB, i))))))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e ((not (\u003ctitle\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cauthor\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cjournal\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cyear\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cbooktitle\u003e \u003d valuetype)) \u003d\u003e ((\u003cinstitution\u003e \u003d valuetype) \u003d\u003e pre_get(dB, i)))))))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e ((not (\u003ctitle\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cauthor\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cjournal\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cyear\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cbooktitle\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cinstitution\u003e \u003d valuetype)) \u003d\u003e ((\u003cpublisher\u003e \u003d valuetype) \u003d\u003e pre_get(dB, i))))))))))","cases exhaustive obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e (((((((valuetype \u003d \u003ctitle\u003e) or (valuetype \u003d \u003cauthor\u003e)) or (valuetype \u003d \u003cjournal\u003e)) or (valuetype \u003d \u003cyear\u003e)) or (valuetype \u003d \u003cbooktitle\u003e)) or (valuetype \u003d \u003cinstitution\u003e)) or (valuetype \u003d \u003cpublisher\u003e))))","function establishes postcondition obligation:(forall dB:set of (Record), i:Id \u0026 (pre_iscomplete(dB, i) \u003d\u003e post_iscomplete(dB, i, (required(recordtype(dB, i)) \u003d {f | f in set required(recordtype(dB, i)) \u0026 (not isempty(getvalue(f, dB, i)))}))))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e let RESULT \u003d (required(recordtype(dB, i)) \u003d {f | f in set required(recordtype(dB, i)) \u0026 (not isempty(getvalue(f, dB, i)))}) in pre_recordtype(dB, i)))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e let RESULT \u003d (required(recordtype(dB, i)) \u003d {f | f in set required(recordtype(dB, i)) \u0026 (not isempty(getvalue(f, dB, i)))}) in (forall x in set required(recordtype(dB, i)) \u0026 pre_getvalue(x, dB, i))))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e pre_recordtype(dB, i)))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e pre_recordtype(dB, i)))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e (forall f in set required(recordtype(dB, i)) \u0026 pre_getvalue(f, dB, i))))","function establishes postcondition obligation:(forall value:Value \u0026 post_isempty(value, (if (value \u003d \u003cnil\u003e)\nthen true\nelse false)))","function establishes postcondition obligation:(forall dB:set of (Record) \u0026 post_isidentical(dB, (if (dB \u003d {})\nthen false\nelse let record1 in set dB in (if iscomplete(dB, (record1.id))\nthen isidentical2(dB, (dB \\ {record1}), dB, record1)\nelse isidentical((dB \\ {record1}))))))","legal function application obligation:(forall dB:set of (Record) \u0026 let RESULT \u003d (if (dB \u003d {})\nthen false\nelse let record1 in set dB in (if iscomplete(dB, (record1.id))\nthen isidentical2(dB, (dB \\ {record1}), dB, record1)\nelse isidentical((dB \\ {record1})))) in (forall i, j in set usedIds(dB) \u0026 ((i \u003c\u003e j) \u003d\u003e pre_iscomplete(dB, i))))","legal function application obligation:(forall dB:set of (Record) \u0026 let RESULT \u003d (if (dB \u003d {})\nthen false\nelse let record1 in set dB in (if iscomplete(dB, (record1.id))\nthen isidentical2(dB, (dB \\ {record1}), dB, record1)\nelse isidentical((dB \\ {record1})))) in (forall i, j in set usedIds(dB) \u0026 ((i \u003c\u003e j) \u003d\u003e (iscomplete(dB, i) \u003d\u003e pre_iscomplete(dB, j)))))","legal function application obligation:(forall dB:set of (Record) \u0026 let RESULT \u003d (if (dB \u003d {})\nthen false\nelse let record1 in set dB in (if iscomplete(dB, (record1.id))\nthen isidentical2(dB, (dB \\ {record1}), dB, record1)\nelse isidentical((dB \\ {record1})))) in (forall i, j in set usedIds(dB) \u0026 ((i \u003c\u003e j) \u003d\u003e (iscomplete(dB, i) \u003d\u003e (iscomplete(dB, j) \u003d\u003e pre_recordtype(dB, i))))))","legal function application obligation:(forall dB:set of (Record) \u0026 let RESULT \u003d (if (dB \u003d {})\nthen false\nelse let record1 in set dB in (if iscomplete(dB, (record1.id))\nthen isidentical2(dB, (dB \\ {record1}), dB, record1)\nelse isidentical((dB \\ {record1})))) in (forall i, j in set usedIds(dB) \u0026 ((i \u003c\u003e j) \u003d\u003e (iscomplete(dB, i) \u003d\u003e (iscomplete(dB, j) \u003d\u003e pre_recordtype(dB, j))))))","legal function application obligation:(forall dB:set of (Record) \u0026 let RESULT \u003d (if (dB \u003d {})\nthen false\nelse let record1 in set dB in (if iscomplete(dB, (record1.id))\nthen isidentical2(dB, (dB \\ {record1}), dB, record1)\nelse isidentical((dB \\ {record1})))) in (forall i, j in set usedIds(dB) \u0026 ((i \u003c\u003e j) \u003d\u003e (iscomplete(dB, i) \u003d\u003e (iscomplete(dB, j) \u003d\u003e ((recordtype(dB, i) \u003d recordtype(dB, j)) \u003d\u003e pre_recordtype(dB, i)))))))","legal function application obligation:(forall dB:set of (Record) \u0026 let RESULT \u003d (if (dB \u003d {})\nthen false\nelse let record1 in set dB in (if iscomplete(dB, (record1.id))\nthen isidentical2(dB, (dB \\ {record1}), dB, record1)\nelse isidentical((dB \\ {record1})))) in (forall i, j in set usedIds(dB) \u0026 ((i \u003c\u003e j) \u003d\u003e (iscomplete(dB, i) \u003d\u003e (iscomplete(dB, j) \u003d\u003e ((recordtype(dB, i) \u003d recordtype(dB, j)) \u003d\u003e (forall x in set required(recordtype(dB, i)) \u0026 pre_getvalue(x, dB, i))))))))","legal function application obligation:(forall dB:set of (Record) \u0026 let RESULT \u003d (if (dB \u003d {})\nthen false\nelse let record1 in set dB in (if iscomplete(dB, (record1.id))\nthen isidentical2(dB, (dB \\ {record1}), dB, record1)\nelse isidentical((dB \\ {record1})))) in (forall i, j in set usedIds(dB) \u0026 ((i \u003c\u003e j) \u003d\u003e (iscomplete(dB, i) \u003d\u003e (iscomplete(dB, j) \u003d\u003e ((recordtype(dB, i) \u003d recordtype(dB, j)) \u003d\u003e (forall x in set required(recordtype(dB, i)) \u0026 pre_getvalue(x, dB, j))))))))","let be st existence obligation:(forall dB:set of (Record) \u0026 ((not (dB \u003d {})) \u003d\u003e (exists record1 in set dB \u0026 true)))","legal function application obligation:(forall dB:set of (Record) \u0026 ((not (dB \u003d {})) \u003d\u003e (forall record1 in set dB \u0026 pre_iscomplete(dB, (record1.id)))))","let be st existence obligation:(forall dB1:set of (Record), dB2:set of (Record), olddB:set of (Record), record1:Record \u0026 ((not (dB2 \u003d {})) \u003d\u003e (exists record2 in set dB2 \u0026 true)))","legal function application obligation:(forall dB1:set of (Record), dB2:set of (Record), olddB:set of (Record), record1:Record \u0026 ((not (dB2 \u003d {})) \u003d\u003e (forall record2 in set dB2 \u0026 pre_iscomplete(olddB, (record2.id)))))","legal function application obligation:(forall dB1:set of (Record), dB2:set of (Record), olddB:set of (Record), record1:Record \u0026 ((not (dB2 \u003d {})) \u003d\u003e (forall record2 in set dB2 \u0026 (iscomplete(olddB, (record2.id)) \u003d\u003e pre_recordtype(olddB, (record1.id))))))","let be st existence obligation:(forall dB1:set of (Record), dB2:set of (Record), olddB:set of (Record), record1:Record, record2:Record, requiredfields:set of (Valuetype) \u0026 ((not (requiredfields \u003d {})) \u003d\u003e (exists field in set requiredfields \u0026 true)))","legal function application obligation:(forall dB1:set of (Record), dB2:set of (Record), olddB:set of (Record), record1:Record, record2:Record, requiredfields:set of (Valuetype) \u0026 ((not (requiredfields \u003d {})) \u003d\u003e (forall field in set requiredfields \u0026 pre_getvalue(field, olddB, (record1.id)))))","legal function application obligation:(forall dB1:set of (Record), dB2:set of (Record), olddB:set of (Record), record1:Record, record2:Record, requiredfields:set of (Valuetype) \u0026 ((not (requiredfields \u003d {})) \u003d\u003e (forall field in set requiredfields \u0026 pre_getvalue(field, olddB, (record2.id)))))","non-empty sequence obligation:(forall v:Value \u0026 ((not is_(v, real)) \u003d\u003e ((not (v \u003d [])) \u003d\u003e (is_((hd v), char) \u003d\u003e (v \u003c\u003e [])))))","function establishes postcondition obligation:(forall string1:String, string2:String \u0026 post_issubstring(string1, string2, (if (string1 \u003d [])\nthen true\nelseif ((string2 \u003d []) or ((string1 \u003d \u003cnil\u003e) or (string2 \u003d \u003cnil\u003e)))\nthen false\nelseif ((hd string1) \u003d (hd string2))\nthen issubstring2((tl string1), (tl string2), string1)\nelse issubstring(string1, (tl string2)))))","legal function application obligation:(forall string1:String, string2:String \u0026 let RESULT \u003d (if (string1 \u003d [])\nthen true\nelseif ((string2 \u003d []) or ((string1 \u003d \u003cnil\u003e) or (string2 \u003d \u003cnil\u003e)))\nthen false\nelseif ((hd string1) \u003d (hd string2))\nthen issubstring2((tl string1), (tl string2), string1)\nelse issubstring(string1, (tl string2))) in ((not (string2 \u003d \u003cnil\u003e)) \u003d\u003e (forall i, j in set (inds string2) \u0026 pre_substring(string2, i, j))))","non-empty sequence obligation:(forall string1:String, string2:String \u0026 ((not (string1 \u003d [])) \u003d\u003e ((not ((string2 \u003d []) or ((string1 \u003d \u003cnil\u003e) or (string2 \u003d \u003cnil\u003e)))) \u003d\u003e (((hd string1) \u003d (hd string2)) \u003d\u003e (string1 \u003c\u003e [])))))","non-empty sequence obligation:(forall string1:String, string2:String \u0026 ((not (string1 \u003d [])) \u003d\u003e ((not ((string2 \u003d []) or ((string1 \u003d \u003cnil\u003e) or (string2 \u003d \u003cnil\u003e)))) \u003d\u003e (((hd string1) \u003d (hd string2)) \u003d\u003e (string2 \u003c\u003e [])))))","non-empty sequence obligation:(forall string1:String, string2:String \u0026 ((not (string1 \u003d [])) \u003d\u003e ((not ((string2 \u003d []) or ((string1 \u003d \u003cnil\u003e) or (string2 \u003d \u003cnil\u003e)))) \u003d\u003e ((not ((hd string1) \u003d (hd string2))) \u003d\u003e (string2 \u003c\u003e [])))))","non-empty sequence obligation:(forall string1:String, string2:String, oldstring1:String \u0026 ((not (string1 \u003d [])) \u003d\u003e ((not (string2 \u003d [])) \u003d\u003e (((hd string1) \u003d (hd string2)) \u003d\u003e (string1 \u003c\u003e [])))))","non-empty sequence obligation:(forall string1:String, string2:String, oldstring1:String \u0026 ((not (string1 \u003d [])) \u003d\u003e ((not (string2 \u003d [])) \u003d\u003e (((hd string1) \u003d (hd string2)) \u003d\u003e (string2 \u003c\u003e [])))))","function establishes postcondition obligation:(forall v:Value, f:Valuetype \u0026 post_isvalueoffield(v, f, (cases f :\n\u003caddress\u003e -\u003e isstring(v),\n\u003cauthor\u003e -\u003e isstring(v),\n\u003cbooktitle\u003e -\u003e isstring(v),\n\u003cedition\u003e -\u003e isedition(v),\n\u003ceditor\u003e -\u003e isstring(v),\n\u003cinstitution\u003e -\u003e isstring(v),\n\u003cjournal\u003e -\u003e isstring(v),\n\u003cmonth\u003e -\u003e ismonth(v),\n\u003cnote\u003e -\u003e isstring(v),\n\u003cnumber\u003e -\u003e isnumber(v),\n\u003corganization\u003e -\u003e isstring(v),\n\u003cpages\u003e -\u003e ispages(v),\n\u003cpublisher\u003e -\u003e isstring(v),\n\u003ctitle\u003e -\u003e isstring(v),\n\u003ctype\u003e -\u003e isstring(v),\n\u003cvolume\u003e -\u003e isvolume(v),\n\u003cyear\u003e -\u003e isyear(v)\n end)))","cases exhaustive obligation:(forall v:Value, f:Valuetype \u0026 (((((((((((((((((f \u003d \u003caddress\u003e) or (f \u003d \u003cauthor\u003e)) or (f \u003d \u003cbooktitle\u003e)) or (f \u003d \u003cedition\u003e)) or (f \u003d \u003ceditor\u003e)) or (f \u003d \u003cinstitution\u003e)) or (f \u003d \u003cjournal\u003e)) or (f \u003d \u003cmonth\u003e)) or (f \u003d \u003cnote\u003e)) or (f \u003d \u003cnumber\u003e)) or (f \u003d \u003corganization\u003e)) or (f \u003d \u003cpages\u003e)) or (f \u003d \u003cpublisher\u003e)) or (f \u003d \u003ctitle\u003e)) or (f \u003d \u003ctype\u003e)) or (f \u003d \u003cvolume\u003e)) or (f \u003d \u003cyear\u003e)))","function establishes postcondition obligation:(forall rt:Recordtype \u0026 post_optional(rt, (cases rt :\n\u003carticle\u003e -\u003e {\u003cvolume\u003e, \u003cnumber\u003e, \u003cmonth\u003e, \u003cnote\u003e},\n\u003cbook\u003e -\u003e {\u003cvolume\u003e, \u003cseries\u003e, \u003caddress\u003e, \u003cedition\u003e, \u003cmonth\u003e, \u003cnote\u003e, \u003cpublisher\u003e},\n\u003cinproceeding\u003e -\u003e {\u003ceditor\u003e, \u003cpages\u003e, \u003corganization\u003e, \u003cpublisher\u003e, \u003caddress\u003e, \u003cpages\u003e, \u003corganization\u003e},\n\u003cmanual\u003e -\u003e {\u003cedition\u003e, \u003cnote\u003e, \u003corganization\u003e, \u003cmonth\u003e, \u003caddress\u003e, \u003cauthor\u003e, \u003corganization\u003e, \u003cyear\u003e},\n\u003ctechreport\u003e -\u003e {\u003cnumber\u003e, \u003cnote\u003e, \u003ctype\u003e, \u003cmonth\u003e, \u003caddress\u003e}\n end)))","cases exhaustive obligation:(forall rt:Recordtype \u0026 (((((rt \u003d \u003carticle\u003e) or (rt \u003d \u003cbook\u003e)) or (rt \u003d \u003cinproceeding\u003e)) or (rt \u003d \u003cmanual\u003e)) or (rt \u003d \u003ctechreport\u003e)))","function establishes postcondition obligation:(forall dB:set of (Record), i:Id \u0026 (pre_recordtype(dB, i) \u003d\u003e post_recordtype(dB, i, (if is_(get(dB, i), Article)\nthen \u003carticle\u003e\nelseif is_(get(dB, i), Book)\nthen \u003cbook\u003e\nelseif is_(get(dB, i), Inproceeding)\nthen \u003cinproceeding\u003e\nelseif is_(get(dB, i), Manual)\nthen \u003cmanual\u003e\nelse \u003ctechreport\u003e))))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e let RESULT \u003d (if is_(get(dB, i), Article)\nthen \u003carticle\u003e\nelseif is_(get(dB, i), Book)\nthen \u003cbook\u003e\nelseif is_(get(dB, i), Inproceeding)\nthen \u003cinproceeding\u003e\nelseif is_(get(dB, i), Manual)\nthen \u003cmanual\u003e\nelse \u003ctechreport\u003e) in pre_get(dB, i)))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e let RESULT \u003d (if is_(get(dB, i), Article)\nthen \u003carticle\u003e\nelseif is_(get(dB, i), Book)\nthen \u003cbook\u003e\nelseif is_(get(dB, i), Inproceeding)\nthen \u003cinproceeding\u003e\nelseif is_(get(dB, i), Manual)\nthen \u003cmanual\u003e\nelse \u003ctechreport\u003e) in ((not (is_(get(dB, i), Article) and (RESULT \u003d \u003carticle\u003e))) \u003d\u003e pre_get(dB, i))))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e let RESULT \u003d (if is_(get(dB, i), Article)\nthen \u003carticle\u003e\nelseif is_(get(dB, i), Book)\nthen \u003cbook\u003e\nelseif is_(get(dB, i), Inproceeding)\nthen \u003cinproceeding\u003e\nelseif is_(get(dB, i), Manual)\nthen \u003cmanual\u003e\nelse \u003ctechreport\u003e) in ((not (is_(get(dB, i), Article) and (RESULT \u003d \u003carticle\u003e))) \u003d\u003e ((not (is_(get(dB, i), Book) and (RESULT \u003d \u003cbook\u003e))) \u003d\u003e pre_get(dB, i)))))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e let RESULT \u003d (if is_(get(dB, i), Article)\nthen \u003carticle\u003e\nelseif is_(get(dB, i), Book)\nthen \u003cbook\u003e\nelseif is_(get(dB, i), Inproceeding)\nthen \u003cinproceeding\u003e\nelseif is_(get(dB, i), Manual)\nthen \u003cmanual\u003e\nelse \u003ctechreport\u003e) in ((not (is_(get(dB, i), Article) and (RESULT \u003d \u003carticle\u003e))) \u003d\u003e ((not (is_(get(dB, i), Book) and (RESULT \u003d \u003cbook\u003e))) \u003d\u003e ((not (is_(get(dB, i), Inproceeding) and (RESULT \u003d \u003cinproceeding\u003e))) \u003d\u003e pre_get(dB, i))))))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e let RESULT \u003d (if is_(get(dB, i), Article)\nthen \u003carticle\u003e\nelseif is_(get(dB, i), Book)\nthen \u003cbook\u003e\nelseif is_(get(dB, i), Inproceeding)\nthen \u003cinproceeding\u003e\nelseif is_(get(dB, i), Manual)\nthen \u003cmanual\u003e\nelse \u003ctechreport\u003e) in ((not (is_(get(dB, i), Article) and (RESULT \u003d \u003carticle\u003e))) \u003d\u003e ((not (is_(get(dB, i), Book) and (RESULT \u003d \u003cbook\u003e))) \u003d\u003e ((not (is_(get(dB, i), Inproceeding) and (RESULT \u003d \u003cinproceeding\u003e))) \u003d\u003e ((not (is_(get(dB, i), Manual) and (RESULT \u003d \u003cmanual\u003e))) \u003d\u003e pre_get(dB, i)))))))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e pre_get(dB, i)))","function establishes postcondition obligation:(forall rt:Recordtype \u0026 post_required(rt, (cases rt :\n\u003carticle\u003e -\u003e {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e},\n\u003cbook\u003e -\u003e {\u003ctitle\u003e, \u003cauthor\u003e, \u003cpublisher\u003e, \u003cyear\u003e},\n\u003cinproceeding\u003e -\u003e {\u003ctitle\u003e, \u003cauthor\u003e, \u003cbooktitle\u003e, \u003cyear\u003e},\n\u003cmanual\u003e -\u003e {\u003ctitle\u003e},\n\u003ctechreport\u003e -\u003e {\u003ctitle\u003e, \u003cauthor\u003e, \u003cinstitution\u003e, \u003cyear\u003e}\n end)))","cases exhaustive obligation:(forall rt:Recordtype \u0026 (((((rt \u003d \u003carticle\u003e) or (rt \u003d \u003cbook\u003e)) or (rt \u003d \u003cinproceeding\u003e)) or (rt \u003d \u003cmanual\u003e)) or (rt \u003d \u003ctechreport\u003e)))","function postcondition satisfiable obligation:(forall s:String, i:nat1, j:nat1 \u0026 (pre_substring(s, i, j) \u003d\u003e (exists r:String \u0026 post_substring(s, i, j, r))))","function establishes postcondition obligation:(forall dB:set of (Record) \u0026 post_usedIds(dB, idset(dB, {})))","let be st existence obligation:(forall dB:set of (Record), ids:set of (Id) \u0026 ((not (dB \u003d {})) \u003d\u003e (exists record in set dB \u0026 true)))","recursive function obligation:(forall dB:set of (Record), ids:set of (Id) \u0026 ((not (dB \u003d {})) \u003d\u003e (forall record in set dB \u0026 (CardRecords(dB, ids) \u003e CardRecords((dB \\ {record}), (ids union {(record.id)}))))))","while loop termination obligation:NotYetImplemented","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Month(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Year(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Edition(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Month(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Year(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Month(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Year(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Edition(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Month(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Year(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Month(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Year(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((RESULT not in set usedIds(dB~)) \u003d\u003e ((e \u003d \u003carticle\u003e) \u003d\u003e inv_Month(\u003cnil\u003e))))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((RESULT not in set usedIds(dB~)) \u003d\u003e ((e \u003d \u003carticle\u003e) \u003d\u003e inv_Year(\u003cnil\u003e))))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((not ((RESULT not in set usedIds(dB~)) and ((e \u003d \u003carticle\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Article(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))))) \u003d\u003e ((e \u003d \u003cbook\u003e) \u003d\u003e inv_Edition(\u003cnil\u003e))))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((not ((RESULT not in set usedIds(dB~)) and ((e \u003d \u003carticle\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Article(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))))) \u003d\u003e ((e \u003d \u003cbook\u003e) \u003d\u003e inv_Month(\u003cnil\u003e))))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((not ((RESULT not in set usedIds(dB~)) and ((e \u003d \u003carticle\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Article(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))))) \u003d\u003e ((e \u003d \u003cbook\u003e) \u003d\u003e inv_Year(\u003cnil\u003e))))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((not ((RESULT not in set usedIds(dB~)) and ((e \u003d \u003carticle\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Article(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))))) \u003d\u003e ((not ((e \u003d \u003cbook\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Book(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((e \u003d \u003cinproceeding\u003e) \u003d\u003e inv_Month(\u003cnil\u003e)))))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((not ((RESULT not in set usedIds(dB~)) and ((e \u003d \u003carticle\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Article(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))))) \u003d\u003e ((not ((e \u003d \u003cbook\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Book(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((e \u003d \u003cinproceeding\u003e) \u003d\u003e inv_Year(\u003cnil\u003e)))))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((not ((RESULT not in set usedIds(dB~)) and ((e \u003d \u003carticle\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Article(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))))) \u003d\u003e ((not ((e \u003d \u003cbook\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Book(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((not ((e \u003d \u003cinproceeding\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Inproceeding(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((e \u003d \u003cmanual\u003e) \u003d\u003e inv_Edition(\u003cnil\u003e))))))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((not ((RESULT not in set usedIds(dB~)) and ((e \u003d \u003carticle\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Article(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))))) \u003d\u003e ((not ((e \u003d \u003cbook\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Book(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((not ((e \u003d \u003cinproceeding\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Inproceeding(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((e \u003d \u003cmanual\u003e) \u003d\u003e inv_Month(\u003cnil\u003e))))))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((not ((RESULT not in set usedIds(dB~)) and ((e \u003d \u003carticle\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Article(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))))) \u003d\u003e ((not ((e \u003d \u003cbook\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Book(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((not ((e \u003d \u003cinproceeding\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Inproceeding(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((e \u003d \u003cmanual\u003e) \u003d\u003e inv_Year(\u003cnil\u003e))))))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((not ((RESULT not in set usedIds(dB~)) and ((e \u003d \u003carticle\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Article(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))))) \u003d\u003e ((not ((e \u003d \u003cbook\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Book(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((not ((e \u003d \u003cinproceeding\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Inproceeding(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((not ((e \u003d \u003cmanual\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Manual(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((e \u003d \u003ctechreport\u003e) \u003d\u003e inv_Month(\u003cnil\u003e)))))))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((not ((RESULT not in set usedIds(dB~)) and ((e \u003d \u003carticle\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Article(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))))) \u003d\u003e ((not ((e \u003d \u003cbook\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Book(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((not ((e \u003d \u003cinproceeding\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Inproceeding(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((not ((e \u003d \u003cmanual\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Manual(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((e \u003d \u003ctechreport\u003e) \u003d\u003e inv_Year(\u003cnil\u003e)))))))","operation establishes postcondition obligation:(forall e:Recordtype, oldstate:mgd \u0026 (((RESULT not in set usedIds(dB~)) and ((e \u003d \u003carticle\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Article(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) or (((e \u003d \u003cbook\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Book(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))) or (((e \u003d \u003cinproceeding\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Inproceeding(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))) or (((e \u003d \u003cmanual\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Manual(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))) or ((e \u003d \u003ctechreport\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Techreport(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))))))))","legal function application obligation:((i in set usedIds(dB)) \u003d\u003e pre_recordtype(dB, i))","legal function application obligation:((i in set usedIds(dB)) \u003d\u003e ((f in set field(recordtype(dB, i))) \u003d\u003e (isvalueoffield(v, f) \u003d\u003e pre_iscomplete(dB, i))))","legal function application obligation:(((i in set usedIds(dB)) and ((f in set field(recordtype(dB, i))) and (isvalueoffield(v, f) and (not (iscomplete(dB, i) and isidentical(dB)))))) \u003d\u003e pre_getvalue(f, dB, i))","legal function application obligation:(((i in set usedIds(dB)) and ((f in set field(recordtype(dB, i))) and (isvalueoffield(v, f) and (not (iscomplete(dB, i) and isidentical(dB)))))) \u003d\u003e ((getvalue(f, dB, i) \u003d v) \u003d\u003e pre_get(dB, i)))","legal function application obligation:(((i in set usedIds(dB)) and ((f in set field(recordtype(dB, i))) and (isvalueoffield(v, f) and (not (iscomplete(dB, i) and isidentical(dB)))))) \u003d\u003e ((getvalue(f, dB, i) \u003d v) \u003d\u003e pre_get(dB~, i)))","legal function application obligation:(((i in set usedIds(dB)) and ((f in set field(recordtype(dB, i))) and (isvalueoffield(v, f) and (not (iscomplete(dB, i) and isidentical(dB)))))) \u003d\u003e ((getvalue(f, dB, i) \u003d v) \u003d\u003e (((dB \\ {get(dB, i)}) \u003d (dB~ \\ {get(dB~, i)})) \u003d\u003e pre_recordtype(dB, i))))","legal function application obligation:(((i in set usedIds(dB)) and ((f in set field(recordtype(dB, i))) and (isvalueoffield(v, f) and (not (iscomplete(dB, i) and isidentical(dB)))))) \u003d\u003e ((getvalue(f, dB, i) \u003d v) \u003d\u003e (((dB \\ {get(dB, i)}) \u003d (dB~ \\ {get(dB~, i)})) \u003d\u003e (forall x in set (field(recordtype(dB, i)) \\ {f}) \u0026 pre_getvalue(x, dB, i)))))","legal function application obligation:(((i in set usedIds(dB)) and ((f in set field(recordtype(dB, i))) and (isvalueoffield(v, f) and (not (iscomplete(dB, i) and isidentical(dB)))))) \u003d\u003e ((getvalue(f, dB, i) \u003d v) \u003d\u003e (((dB \\ {get(dB, i)}) \u003d (dB~ \\ {get(dB~, i)})) \u003d\u003e (forall x in set (field(recordtype(dB, i)) \\ {f}) \u0026 pre_getvalue(x, dB~, i)))))","legal function application obligation:((i in set usedIds(dB)) \u003d\u003e pre_recordtype(dB, i))","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, seq of (char)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, seq of (char)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, seq of (char)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(inv_Edition(v) and (is_(v, \u003cnil\u003e) or is_(v, nat)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, seq of (char)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, seq of (char)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, seq of (char)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(inv_Month(v) and (is_(v, \u003cnil\u003e) or is_(v, nat)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, seq of (char)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, nat1))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, seq of (char)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, nat1))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, seq of (char)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, seq of (char)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, seq of (char)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, nat1))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(inv_Year(v) and (is_(v, \u003cnil\u003e) or is_(v, nat)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_iscomplete(dB, i)","operation call obligation:(i in set usedIds(dB))","legal function application obligation:(forall i:Id, oldstate:mgd \u0026 ((i in set usedIds(dB)) \u003d\u003e pre_iscomplete(dB, i)))","legal function application obligation:(forall i:Id, oldstate:mgd \u0026 ((i in set usedIds(dB)) \u003d\u003e pre_iscomplete(dB, i)))","operation establishes postcondition obligation:(forall i:Id, oldstate:mgd \u0026 ((i in set usedIds(dB)) \u003d\u003e (iscomplete(dB, i) \u003c\u003d\u003e RESULT)))","legal function application obligation:((i in set usedIds(dB)) \u003d\u003e pre_get(dB~, i))","legal function application obligation:pre_get(dB, i)","legal function application obligation:(forall a:String, oldstate:mgd \u0026 (forall i in set RESULT \u0026 pre_get(dB, i)))","legal function application obligation:(forall a:String, oldstate:mgd \u0026 (forall i in set RESULT \u0026 (issubstring(a, (get(dB, i).author)) \u003d\u003e (forall record in set dB \u0026 (((record.id) not in set RESULT) \u003d\u003e pre_get(dB, i))))))","operation establishes postcondition obligation:(forall a:String, oldstate:mgd \u0026 (forall i in set RESULT \u0026 (issubstring(a, (get(dB, i).author)) and (not (exists record in set dB \u0026 (((record.id) not in set RESULT) and issubstring(a, (get(dB, i).author))))))))","legal function application obligation:(forall i:Id, oldstate:mgd \u0026 ((i in set usedIds(dB)) \u003d\u003e pre_get(dB, i)))","legal function application obligation:(forall i:Id, oldstate:mgd \u0026 ((i in set usedIds(dB)) \u003d\u003e pre_get(dB, i)))","operation establishes postcondition obligation:(forall i:Id, oldstate:mgd \u0026 ((i in set usedIds(dB)) \u003d\u003e (RESULT \u003d get(dB, i))))"] \ No newline at end of file +["type invariant satisfiable obligation:(exists e:Edition \u0026 (e in set ({1, ... ,50} union {\u003cnil\u003e})))","type invariant satisfiable obligation:(exists e:Month \u0026 (e in set ({1, ... ,12} union {\u003cnil\u003e})))","type invariant satisfiable obligation:(exists e:Year \u0026 (e in set ({1800, ... ,1998} union {\u003cnil\u003e})))","function establishes postcondition obligation:(forall rt:Recordtype \u0026 post_field(rt, (required(rt) union optional(rt))))","function establishes postcondition obligation:(forall dB:set of (Record), i:Id \u0026 (pre_get(dB, i) \u003d\u003e post_get(dB, i, let record in set dB in (if ((record.id) \u003d i)\nthen record\nelse get((dB \\ {record}), i)))))","let be st existence obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e (exists record in set dB \u0026 true)))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e (forall record in set dB \u0026 ((not ((record.id) \u003d i)) \u003d\u003e pre_get((dB \\ {record}), i)))))","recursive function obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e (forall record in set dB \u0026 ((not ((record.id) \u003d i)) \u003d\u003e (CardDb(dB, i) \u003e CardDb((dB \\ {record}), i))))))","function establishes postcondition obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (pre_getvalue(valuetype, dB, i) \u003d\u003e post_getvalue(valuetype, dB, i, (cases valuetype :\n\u003ctitle\u003e -\u003e (get(dB, i).title),\n\u003cauthor\u003e -\u003e (get(dB, i).author),\n\u003cjournal\u003e -\u003e (get(dB, i).journal),\n\u003cyear\u003e -\u003e (get(dB, i).year),\n\u003cbooktitle\u003e -\u003e (get(dB, i).booktitle),\n\u003cinstitution\u003e -\u003e (get(dB, i).institution),\n\u003cpublisher\u003e -\u003e (get(dB, i).publisher)\n end))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e let RESULT \u003d (cases valuetype :\n\u003ctitle\u003e -\u003e (get(dB, i).title),\n\u003cauthor\u003e -\u003e (get(dB, i).author),\n\u003cjournal\u003e -\u003e (get(dB, i).journal),\n\u003cyear\u003e -\u003e (get(dB, i).year),\n\u003cbooktitle\u003e -\u003e (get(dB, i).booktitle),\n\u003cinstitution\u003e -\u003e (get(dB, i).institution),\n\u003cpublisher\u003e -\u003e (get(dB, i).publisher)\n end) in ((valuetype \u003d \u003ctitle\u003e) \u003d\u003e pre_get(dB, i))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e let RESULT \u003d (cases valuetype :\n\u003ctitle\u003e -\u003e (get(dB, i).title),\n\u003cauthor\u003e -\u003e (get(dB, i).author),\n\u003cjournal\u003e -\u003e (get(dB, i).journal),\n\u003cyear\u003e -\u003e (get(dB, i).year),\n\u003cbooktitle\u003e -\u003e (get(dB, i).booktitle),\n\u003cinstitution\u003e -\u003e (get(dB, i).institution),\n\u003cpublisher\u003e -\u003e (get(dB, i).publisher)\n end) in ((not ((valuetype \u003d \u003ctitle\u003e) and (RESULT \u003d (get(dB, i).title)))) \u003d\u003e ((valuetype \u003d \u003cauthor\u003e) \u003d\u003e pre_get(dB, i)))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e let RESULT \u003d (cases valuetype :\n\u003ctitle\u003e -\u003e (get(dB, i).title),\n\u003cauthor\u003e -\u003e (get(dB, i).author),\n\u003cjournal\u003e -\u003e (get(dB, i).journal),\n\u003cyear\u003e -\u003e (get(dB, i).year),\n\u003cbooktitle\u003e -\u003e (get(dB, i).booktitle),\n\u003cinstitution\u003e -\u003e (get(dB, i).institution),\n\u003cpublisher\u003e -\u003e (get(dB, i).publisher)\n end) in ((not ((valuetype \u003d \u003ctitle\u003e) and (RESULT \u003d (get(dB, i).title)))) \u003d\u003e ((not ((valuetype \u003d \u003cauthor\u003e) and (RESULT \u003d (get(dB, i).author)))) \u003d\u003e ((valuetype \u003d \u003cjournal\u003e) \u003d\u003e pre_get(dB, i))))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e let RESULT \u003d (cases valuetype :\n\u003ctitle\u003e -\u003e (get(dB, i).title),\n\u003cauthor\u003e -\u003e (get(dB, i).author),\n\u003cjournal\u003e -\u003e (get(dB, i).journal),\n\u003cyear\u003e -\u003e (get(dB, i).year),\n\u003cbooktitle\u003e -\u003e (get(dB, i).booktitle),\n\u003cinstitution\u003e -\u003e (get(dB, i).institution),\n\u003cpublisher\u003e -\u003e (get(dB, i).publisher)\n end) in ((not ((valuetype \u003d \u003ctitle\u003e) and (RESULT \u003d (get(dB, i).title)))) \u003d\u003e ((not ((valuetype \u003d \u003cauthor\u003e) and (RESULT \u003d (get(dB, i).author)))) \u003d\u003e ((not ((valuetype \u003d \u003cjournal\u003e) and (RESULT \u003d (get(dB, i).journal)))) \u003d\u003e ((valuetype \u003d \u003cyear\u003e) \u003d\u003e pre_get(dB, i)))))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e let RESULT \u003d (cases valuetype :\n\u003ctitle\u003e -\u003e (get(dB, i).title),\n\u003cauthor\u003e -\u003e (get(dB, i).author),\n\u003cjournal\u003e -\u003e (get(dB, i).journal),\n\u003cyear\u003e -\u003e (get(dB, i).year),\n\u003cbooktitle\u003e -\u003e (get(dB, i).booktitle),\n\u003cinstitution\u003e -\u003e (get(dB, i).institution),\n\u003cpublisher\u003e -\u003e (get(dB, i).publisher)\n end) in ((not ((valuetype \u003d \u003ctitle\u003e) and (RESULT \u003d (get(dB, i).title)))) \u003d\u003e ((not ((valuetype \u003d \u003cauthor\u003e) and (RESULT \u003d (get(dB, i).author)))) \u003d\u003e ((not ((valuetype \u003d \u003cjournal\u003e) and (RESULT \u003d (get(dB, i).journal)))) \u003d\u003e ((not ((valuetype \u003d \u003cyear\u003e) and (RESULT \u003d (get(dB, i).year)))) \u003d\u003e ((valuetype \u003d \u003cbooktitle\u003e) \u003d\u003e pre_get(dB, i))))))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e let RESULT \u003d (cases valuetype :\n\u003ctitle\u003e -\u003e (get(dB, i).title),\n\u003cauthor\u003e -\u003e (get(dB, i).author),\n\u003cjournal\u003e -\u003e (get(dB, i).journal),\n\u003cyear\u003e -\u003e (get(dB, i).year),\n\u003cbooktitle\u003e -\u003e (get(dB, i).booktitle),\n\u003cinstitution\u003e -\u003e (get(dB, i).institution),\n\u003cpublisher\u003e -\u003e (get(dB, i).publisher)\n end) in ((not ((valuetype \u003d \u003ctitle\u003e) and (RESULT \u003d (get(dB, i).title)))) \u003d\u003e ((not ((valuetype \u003d \u003cauthor\u003e) and (RESULT \u003d (get(dB, i).author)))) \u003d\u003e ((not ((valuetype \u003d \u003cjournal\u003e) and (RESULT \u003d (get(dB, i).journal)))) \u003d\u003e ((not ((valuetype \u003d \u003cyear\u003e) and (RESULT \u003d (get(dB, i).year)))) \u003d\u003e ((not ((valuetype \u003d \u003cbooktitle\u003e) and (RESULT \u003d (get(dB, i).booktitle)))) \u003d\u003e ((valuetype \u003d \u003cinstitution\u003e) \u003d\u003e pre_get(dB, i)))))))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e let RESULT \u003d (cases valuetype :\n\u003ctitle\u003e -\u003e (get(dB, i).title),\n\u003cauthor\u003e -\u003e (get(dB, i).author),\n\u003cjournal\u003e -\u003e (get(dB, i).journal),\n\u003cyear\u003e -\u003e (get(dB, i).year),\n\u003cbooktitle\u003e -\u003e (get(dB, i).booktitle),\n\u003cinstitution\u003e -\u003e (get(dB, i).institution),\n\u003cpublisher\u003e -\u003e (get(dB, i).publisher)\n end) in ((not ((valuetype \u003d \u003ctitle\u003e) and (RESULT \u003d (get(dB, i).title)))) \u003d\u003e ((not ((valuetype \u003d \u003cauthor\u003e) and (RESULT \u003d (get(dB, i).author)))) \u003d\u003e ((not ((valuetype \u003d \u003cjournal\u003e) and (RESULT \u003d (get(dB, i).journal)))) \u003d\u003e ((not ((valuetype \u003d \u003cyear\u003e) and (RESULT \u003d (get(dB, i).year)))) \u003d\u003e ((not ((valuetype \u003d \u003cbooktitle\u003e) and (RESULT \u003d (get(dB, i).booktitle)))) \u003d\u003e ((not ((valuetype \u003d \u003cinstitution\u003e) and (RESULT \u003d (get(dB, i).institution)))) \u003d\u003e ((valuetype \u003d \u003cpublisher\u003e) \u003d\u003e pre_get(dB, i))))))))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e ((\u003ctitle\u003e \u003d valuetype) \u003d\u003e pre_get(dB, i))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e ((not (\u003ctitle\u003e \u003d valuetype)) \u003d\u003e ((\u003cauthor\u003e \u003d valuetype) \u003d\u003e pre_get(dB, i)))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e ((not (\u003ctitle\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cauthor\u003e \u003d valuetype)) \u003d\u003e ((\u003cjournal\u003e \u003d valuetype) \u003d\u003e pre_get(dB, i))))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e ((not (\u003ctitle\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cauthor\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cjournal\u003e \u003d valuetype)) \u003d\u003e ((\u003cyear\u003e \u003d valuetype) \u003d\u003e pre_get(dB, i)))))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e ((not (\u003ctitle\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cauthor\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cjournal\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cyear\u003e \u003d valuetype)) \u003d\u003e ((\u003cbooktitle\u003e \u003d valuetype) \u003d\u003e pre_get(dB, i))))))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e ((not (\u003ctitle\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cauthor\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cjournal\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cyear\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cbooktitle\u003e \u003d valuetype)) \u003d\u003e ((\u003cinstitution\u003e \u003d valuetype) \u003d\u003e pre_get(dB, i)))))))))","legal function application obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e ((not (\u003ctitle\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cauthor\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cjournal\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cyear\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cbooktitle\u003e \u003d valuetype)) \u003d\u003e ((not (\u003cinstitution\u003e \u003d valuetype)) \u003d\u003e ((\u003cpublisher\u003e \u003d valuetype) \u003d\u003e pre_get(dB, i))))))))))","cases exhaustive obligation:(forall valuetype:Valuetype, dB:set of (Record), i:Id \u0026 (((i in set usedIds(dB)) and (valuetype in set {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e, \u003cbooktitle\u003e, \u003cinstitution\u003e, \u003cpublisher\u003e})) \u003d\u003e (((((((valuetype \u003d \u003ctitle\u003e) or (valuetype \u003d \u003cauthor\u003e)) or (valuetype \u003d \u003cjournal\u003e)) or (valuetype \u003d \u003cyear\u003e)) or (valuetype \u003d \u003cbooktitle\u003e)) or (valuetype \u003d \u003cinstitution\u003e)) or (valuetype \u003d \u003cpublisher\u003e))))","function establishes postcondition obligation:(forall dB:set of (Record), i:Id \u0026 (pre_iscomplete(dB, i) \u003d\u003e post_iscomplete(dB, i, (required(recordtype(dB, i)) \u003d {f | f in set required(recordtype(dB, i)) \u0026 (not isempty(getvalue(f, dB, i)))}))))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e let RESULT \u003d (required(recordtype(dB, i)) \u003d {f | f in set required(recordtype(dB, i)) \u0026 (not isempty(getvalue(f, dB, i)))}) in pre_recordtype(dB, i)))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e let RESULT \u003d (required(recordtype(dB, i)) \u003d {f | f in set required(recordtype(dB, i)) \u0026 (not isempty(getvalue(f, dB, i)))}) in (forall x in set required(recordtype(dB, i)) \u0026 pre_getvalue(x, dB, i))))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e pre_recordtype(dB, i)))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e pre_recordtype(dB, i)))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e (forall f in set required(recordtype(dB, i)) \u0026 pre_getvalue(f, dB, i))))","function establishes postcondition obligation:(forall value:Value \u0026 post_isempty(value, (if (value \u003d \u003cnil\u003e)\nthen true\nelse false)))","function establishes postcondition obligation:(forall dB:set of (Record) \u0026 post_isidentical(dB, (if (dB \u003d {})\nthen false\nelse let record1 in set dB in (if iscomplete(dB, (record1.id))\nthen isidentical2(dB, (dB \\ {record1}), dB, record1)\nelse isidentical((dB \\ {record1}))))))","legal function application obligation:(forall dB:set of (Record) \u0026 let RESULT \u003d (if (dB \u003d {})\nthen false\nelse let record1 in set dB in (if iscomplete(dB, (record1.id))\nthen isidentical2(dB, (dB \\ {record1}), dB, record1)\nelse isidentical((dB \\ {record1})))) in (forall i, j in set usedIds(dB) \u0026 ((i \u003c\u003e j) \u003d\u003e pre_iscomplete(dB, i))))","legal function application obligation:(forall dB:set of (Record) \u0026 let RESULT \u003d (if (dB \u003d {})\nthen false\nelse let record1 in set dB in (if iscomplete(dB, (record1.id))\nthen isidentical2(dB, (dB \\ {record1}), dB, record1)\nelse isidentical((dB \\ {record1})))) in (forall i, j in set usedIds(dB) \u0026 ((i \u003c\u003e j) \u003d\u003e (iscomplete(dB, i) \u003d\u003e pre_iscomplete(dB, j)))))","legal function application obligation:(forall dB:set of (Record) \u0026 let RESULT \u003d (if (dB \u003d {})\nthen false\nelse let record1 in set dB in (if iscomplete(dB, (record1.id))\nthen isidentical2(dB, (dB \\ {record1}), dB, record1)\nelse isidentical((dB \\ {record1})))) in (forall i, j in set usedIds(dB) \u0026 ((i \u003c\u003e j) \u003d\u003e (iscomplete(dB, i) \u003d\u003e (iscomplete(dB, j) \u003d\u003e pre_recordtype(dB, i))))))","legal function application obligation:(forall dB:set of (Record) \u0026 let RESULT \u003d (if (dB \u003d {})\nthen false\nelse let record1 in set dB in (if iscomplete(dB, (record1.id))\nthen isidentical2(dB, (dB \\ {record1}), dB, record1)\nelse isidentical((dB \\ {record1})))) in (forall i, j in set usedIds(dB) \u0026 ((i \u003c\u003e j) \u003d\u003e (iscomplete(dB, i) \u003d\u003e (iscomplete(dB, j) \u003d\u003e pre_recordtype(dB, j))))))","legal function application obligation:(forall dB:set of (Record) \u0026 let RESULT \u003d (if (dB \u003d {})\nthen false\nelse let record1 in set dB in (if iscomplete(dB, (record1.id))\nthen isidentical2(dB, (dB \\ {record1}), dB, record1)\nelse isidentical((dB \\ {record1})))) in (forall i, j in set usedIds(dB) \u0026 ((i \u003c\u003e j) \u003d\u003e (iscomplete(dB, i) \u003d\u003e (iscomplete(dB, j) \u003d\u003e ((recordtype(dB, i) \u003d recordtype(dB, j)) \u003d\u003e pre_recordtype(dB, i)))))))","legal function application obligation:(forall dB:set of (Record) \u0026 let RESULT \u003d (if (dB \u003d {})\nthen false\nelse let record1 in set dB in (if iscomplete(dB, (record1.id))\nthen isidentical2(dB, (dB \\ {record1}), dB, record1)\nelse isidentical((dB \\ {record1})))) in (forall i, j in set usedIds(dB) \u0026 ((i \u003c\u003e j) \u003d\u003e (iscomplete(dB, i) \u003d\u003e (iscomplete(dB, j) \u003d\u003e ((recordtype(dB, i) \u003d recordtype(dB, j)) \u003d\u003e (forall x in set required(recordtype(dB, i)) \u0026 pre_getvalue(x, dB, i))))))))","legal function application obligation:(forall dB:set of (Record) \u0026 let RESULT \u003d (if (dB \u003d {})\nthen false\nelse let record1 in set dB in (if iscomplete(dB, (record1.id))\nthen isidentical2(dB, (dB \\ {record1}), dB, record1)\nelse isidentical((dB \\ {record1})))) in (forall i, j in set usedIds(dB) \u0026 ((i \u003c\u003e j) \u003d\u003e (iscomplete(dB, i) \u003d\u003e (iscomplete(dB, j) \u003d\u003e ((recordtype(dB, i) \u003d recordtype(dB, j)) \u003d\u003e (forall x in set required(recordtype(dB, i)) \u0026 pre_getvalue(x, dB, j))))))))","let be st existence obligation:(forall dB:set of (Record) \u0026 ((not (dB \u003d {})) \u003d\u003e (exists record1 in set dB \u0026 true)))","legal function application obligation:(forall dB:set of (Record) \u0026 ((not (dB \u003d {})) \u003d\u003e (forall record1 in set dB \u0026 pre_iscomplete(dB, (record1.id)))))","let be st existence obligation:(forall dB1:set of (Record), dB2:set of (Record), olddB:set of (Record), record1:Record \u0026 ((not (dB2 \u003d {})) \u003d\u003e (exists record2 in set dB2 \u0026 true)))","legal function application obligation:(forall dB1:set of (Record), dB2:set of (Record), olddB:set of (Record), record1:Record \u0026 ((not (dB2 \u003d {})) \u003d\u003e (forall record2 in set dB2 \u0026 pre_iscomplete(olddB, (record2.id)))))","legal function application obligation:(forall dB1:set of (Record), dB2:set of (Record), olddB:set of (Record), record1:Record \u0026 ((not (dB2 \u003d {})) \u003d\u003e (forall record2 in set dB2 \u0026 (iscomplete(olddB, (record2.id)) \u003d\u003e pre_recordtype(olddB, (record1.id))))))","let be st existence obligation:(forall dB1:set of (Record), dB2:set of (Record), olddB:set of (Record), record1:Record, record2:Record, requiredfields:set of (Valuetype) \u0026 ((not (requiredfields \u003d {})) \u003d\u003e (exists field in set requiredfields \u0026 true)))","legal function application obligation:(forall dB1:set of (Record), dB2:set of (Record), olddB:set of (Record), record1:Record, record2:Record, requiredfields:set of (Valuetype) \u0026 ((not (requiredfields \u003d {})) \u003d\u003e (forall field in set requiredfields \u0026 pre_getvalue(field, olddB, (record1.id)))))","legal function application obligation:(forall dB1:set of (Record), dB2:set of (Record), olddB:set of (Record), record1:Record, record2:Record, requiredfields:set of (Valuetype) \u0026 ((not (requiredfields \u003d {})) \u003d\u003e (forall field in set requiredfields \u0026 pre_getvalue(field, olddB, (record2.id)))))","non-empty sequence obligation:(forall v:Value \u0026 ((not is_(v, real)) \u003d\u003e ((not (v \u003d [])) \u003d\u003e (is_((hd v), char) \u003d\u003e (v \u003c\u003e [])))))","function establishes postcondition obligation:(forall string1:String, string2:String \u0026 post_issubstring(string1, string2, (if (string1 \u003d [])\nthen true\nelseif ((string2 \u003d []) or ((string1 \u003d \u003cnil\u003e) or (string2 \u003d \u003cnil\u003e)))\nthen false\nelseif ((hd string1) \u003d (hd string2))\nthen issubstring2((tl string1), (tl string2), string1)\nelse issubstring(string1, (tl string2)))))","legal function application obligation:(forall string1:String, string2:String \u0026 let RESULT \u003d (if (string1 \u003d [])\nthen true\nelseif ((string2 \u003d []) or ((string1 \u003d \u003cnil\u003e) or (string2 \u003d \u003cnil\u003e)))\nthen false\nelseif ((hd string1) \u003d (hd string2))\nthen issubstring2((tl string1), (tl string2), string1)\nelse issubstring(string1, (tl string2))) in ((not (string2 \u003d \u003cnil\u003e)) \u003d\u003e (forall i, j in set (inds string2) \u0026 pre_substring(string2, i, j))))","non-empty sequence obligation:(forall string1:String, string2:String \u0026 ((not (string1 \u003d [])) \u003d\u003e ((not ((string2 \u003d []) or ((string1 \u003d \u003cnil\u003e) or (string2 \u003d \u003cnil\u003e)))) \u003d\u003e (((hd string1) \u003d (hd string2)) \u003d\u003e (string1 \u003c\u003e [])))))","non-empty sequence obligation:(forall string1:String, string2:String \u0026 ((not (string1 \u003d [])) \u003d\u003e ((not ((string2 \u003d []) or ((string1 \u003d \u003cnil\u003e) or (string2 \u003d \u003cnil\u003e)))) \u003d\u003e (((hd string1) \u003d (hd string2)) \u003d\u003e (string2 \u003c\u003e [])))))","non-empty sequence obligation:(forall string1:String, string2:String \u0026 ((not (string1 \u003d [])) \u003d\u003e ((not ((string2 \u003d []) or ((string1 \u003d \u003cnil\u003e) or (string2 \u003d \u003cnil\u003e)))) \u003d\u003e ((not ((hd string1) \u003d (hd string2))) \u003d\u003e (string2 \u003c\u003e [])))))","non-empty sequence obligation:(forall string1:String, string2:String, oldstring1:String \u0026 ((not (string1 \u003d [])) \u003d\u003e ((not (string2 \u003d [])) \u003d\u003e (((hd string1) \u003d (hd string2)) \u003d\u003e (string1 \u003c\u003e [])))))","non-empty sequence obligation:(forall string1:String, string2:String, oldstring1:String \u0026 ((not (string1 \u003d [])) \u003d\u003e ((not (string2 \u003d [])) \u003d\u003e (((hd string1) \u003d (hd string2)) \u003d\u003e (string2 \u003c\u003e [])))))","function establishes postcondition obligation:(forall v:Value, f:Valuetype \u0026 post_isvalueoffield(v, f, (cases f :\n\u003caddress\u003e -\u003e isstring(v),\n\u003cauthor\u003e -\u003e isstring(v),\n\u003cbooktitle\u003e -\u003e isstring(v),\n\u003cedition\u003e -\u003e isedition(v),\n\u003ceditor\u003e -\u003e isstring(v),\n\u003cinstitution\u003e -\u003e isstring(v),\n\u003cjournal\u003e -\u003e isstring(v),\n\u003cmonth\u003e -\u003e ismonth(v),\n\u003cnote\u003e -\u003e isstring(v),\n\u003cnumber\u003e -\u003e isnumber(v),\n\u003corganization\u003e -\u003e isstring(v),\n\u003cpages\u003e -\u003e ispages(v),\n\u003cpublisher\u003e -\u003e isstring(v),\n\u003ctitle\u003e -\u003e isstring(v),\n\u003ctype\u003e -\u003e isstring(v),\n\u003cvolume\u003e -\u003e isvolume(v),\n\u003cyear\u003e -\u003e isyear(v)\n end)))","cases exhaustive obligation:(forall v:Value, f:Valuetype \u0026 (((((((((((((((((f \u003d \u003caddress\u003e) or (f \u003d \u003cauthor\u003e)) or (f \u003d \u003cbooktitle\u003e)) or (f \u003d \u003cedition\u003e)) or (f \u003d \u003ceditor\u003e)) or (f \u003d \u003cinstitution\u003e)) or (f \u003d \u003cjournal\u003e)) or (f \u003d \u003cmonth\u003e)) or (f \u003d \u003cnote\u003e)) or (f \u003d \u003cnumber\u003e)) or (f \u003d \u003corganization\u003e)) or (f \u003d \u003cpages\u003e)) or (f \u003d \u003cpublisher\u003e)) or (f \u003d \u003ctitle\u003e)) or (f \u003d \u003ctype\u003e)) or (f \u003d \u003cvolume\u003e)) or (f \u003d \u003cyear\u003e)))","function establishes postcondition obligation:(forall rt:Recordtype \u0026 post_optional(rt, (cases rt :\n\u003carticle\u003e -\u003e {\u003cvolume\u003e, \u003cnumber\u003e, \u003cmonth\u003e, \u003cnote\u003e},\n\u003cbook\u003e -\u003e {\u003cvolume\u003e, \u003cseries\u003e, \u003caddress\u003e, \u003cedition\u003e, \u003cmonth\u003e, \u003cnote\u003e, \u003cpublisher\u003e},\n\u003cinproceeding\u003e -\u003e {\u003ceditor\u003e, \u003cpages\u003e, \u003corganization\u003e, \u003cpublisher\u003e, \u003caddress\u003e, \u003cpages\u003e, \u003corganization\u003e},\n\u003cmanual\u003e -\u003e {\u003cedition\u003e, \u003cnote\u003e, \u003corganization\u003e, \u003cmonth\u003e, \u003caddress\u003e, \u003cauthor\u003e, \u003corganization\u003e, \u003cyear\u003e},\n\u003ctechreport\u003e -\u003e {\u003cnumber\u003e, \u003cnote\u003e, \u003ctype\u003e, \u003cmonth\u003e, \u003caddress\u003e}\n end)))","cases exhaustive obligation:(forall rt:Recordtype \u0026 (((((rt \u003d \u003carticle\u003e) or (rt \u003d \u003cbook\u003e)) or (rt \u003d \u003cinproceeding\u003e)) or (rt \u003d \u003cmanual\u003e)) or (rt \u003d \u003ctechreport\u003e)))","function establishes postcondition obligation:(forall dB:set of (Record), i:Id \u0026 (pre_recordtype(dB, i) \u003d\u003e post_recordtype(dB, i, (if is_(get(dB, i), Article)\nthen \u003carticle\u003e\nelseif is_(get(dB, i), Book)\nthen \u003cbook\u003e\nelseif is_(get(dB, i), Inproceeding)\nthen \u003cinproceeding\u003e\nelseif is_(get(dB, i), Manual)\nthen \u003cmanual\u003e\nelse \u003ctechreport\u003e))))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e let RESULT \u003d (if is_(get(dB, i), Article)\nthen \u003carticle\u003e\nelseif is_(get(dB, i), Book)\nthen \u003cbook\u003e\nelseif is_(get(dB, i), Inproceeding)\nthen \u003cinproceeding\u003e\nelseif is_(get(dB, i), Manual)\nthen \u003cmanual\u003e\nelse \u003ctechreport\u003e) in pre_get(dB, i)))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e let RESULT \u003d (if is_(get(dB, i), Article)\nthen \u003carticle\u003e\nelseif is_(get(dB, i), Book)\nthen \u003cbook\u003e\nelseif is_(get(dB, i), Inproceeding)\nthen \u003cinproceeding\u003e\nelseif is_(get(dB, i), Manual)\nthen \u003cmanual\u003e\nelse \u003ctechreport\u003e) in ((not (is_(get(dB, i), Article) and (RESULT \u003d \u003carticle\u003e))) \u003d\u003e pre_get(dB, i))))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e let RESULT \u003d (if is_(get(dB, i), Article)\nthen \u003carticle\u003e\nelseif is_(get(dB, i), Book)\nthen \u003cbook\u003e\nelseif is_(get(dB, i), Inproceeding)\nthen \u003cinproceeding\u003e\nelseif is_(get(dB, i), Manual)\nthen \u003cmanual\u003e\nelse \u003ctechreport\u003e) in ((not (is_(get(dB, i), Article) and (RESULT \u003d \u003carticle\u003e))) \u003d\u003e ((not (is_(get(dB, i), Book) and (RESULT \u003d \u003cbook\u003e))) \u003d\u003e pre_get(dB, i)))))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e let RESULT \u003d (if is_(get(dB, i), Article)\nthen \u003carticle\u003e\nelseif is_(get(dB, i), Book)\nthen \u003cbook\u003e\nelseif is_(get(dB, i), Inproceeding)\nthen \u003cinproceeding\u003e\nelseif is_(get(dB, i), Manual)\nthen \u003cmanual\u003e\nelse \u003ctechreport\u003e) in ((not (is_(get(dB, i), Article) and (RESULT \u003d \u003carticle\u003e))) \u003d\u003e ((not (is_(get(dB, i), Book) and (RESULT \u003d \u003cbook\u003e))) \u003d\u003e ((not (is_(get(dB, i), Inproceeding) and (RESULT \u003d \u003cinproceeding\u003e))) \u003d\u003e pre_get(dB, i))))))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e let RESULT \u003d (if is_(get(dB, i), Article)\nthen \u003carticle\u003e\nelseif is_(get(dB, i), Book)\nthen \u003cbook\u003e\nelseif is_(get(dB, i), Inproceeding)\nthen \u003cinproceeding\u003e\nelseif is_(get(dB, i), Manual)\nthen \u003cmanual\u003e\nelse \u003ctechreport\u003e) in ((not (is_(get(dB, i), Article) and (RESULT \u003d \u003carticle\u003e))) \u003d\u003e ((not (is_(get(dB, i), Book) and (RESULT \u003d \u003cbook\u003e))) \u003d\u003e ((not (is_(get(dB, i), Inproceeding) and (RESULT \u003d \u003cinproceeding\u003e))) \u003d\u003e ((not (is_(get(dB, i), Manual) and (RESULT \u003d \u003cmanual\u003e))) \u003d\u003e pre_get(dB, i)))))))","legal function application obligation:(forall dB:set of (Record), i:Id \u0026 ((i in set usedIds(dB)) \u003d\u003e pre_get(dB, i)))","function establishes postcondition obligation:(forall rt:Recordtype \u0026 post_required(rt, (cases rt :\n\u003carticle\u003e -\u003e {\u003ctitle\u003e, \u003cauthor\u003e, \u003cjournal\u003e, \u003cyear\u003e},\n\u003cbook\u003e -\u003e {\u003ctitle\u003e, \u003cauthor\u003e, \u003cpublisher\u003e, \u003cyear\u003e},\n\u003cinproceeding\u003e -\u003e {\u003ctitle\u003e, \u003cauthor\u003e, \u003cbooktitle\u003e, \u003cyear\u003e},\n\u003cmanual\u003e -\u003e {\u003ctitle\u003e},\n\u003ctechreport\u003e -\u003e {\u003ctitle\u003e, \u003cauthor\u003e, \u003cinstitution\u003e, \u003cyear\u003e}\n end)))","cases exhaustive obligation:(forall rt:Recordtype \u0026 (((((rt \u003d \u003carticle\u003e) or (rt \u003d \u003cbook\u003e)) or (rt \u003d \u003cinproceeding\u003e)) or (rt \u003d \u003cmanual\u003e)) or (rt \u003d \u003ctechreport\u003e)))","function postcondition satisfiable obligation:(forall s:String, i:nat1, j:nat1 \u0026 (pre_substring(s, i, j) \u003d\u003e (exists r:String \u0026 post_substring(s, i, j, r))))","function establishes postcondition obligation:(forall dB:set of (Record) \u0026 post_usedIds(dB, idset(dB, {})))","let be st existence obligation:(forall dB:set of (Record), ids:set of (Id) \u0026 ((not (dB \u003d {})) \u003d\u003e (exists record in set dB \u0026 true)))","recursive function obligation:(forall dB:set of (Record), ids:set of (Id) \u0026 ((not (dB \u003d {})) \u003d\u003e (forall record in set dB \u0026 (CardRecords(dB, ids) \u003e CardRecords((dB \\ {record}), (ids union {(record.id)}))))))","while loop termination obligation:...","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Month(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Year(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Edition(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Month(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Year(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Month(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Year(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Edition(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Month(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Year(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Month(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 inv_Year(\u003cnil\u003e))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((RESULT not in set usedIds(dB~)) \u003d\u003e ((e \u003d \u003carticle\u003e) \u003d\u003e inv_Month(\u003cnil\u003e))))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((RESULT not in set usedIds(dB~)) \u003d\u003e ((e \u003d \u003carticle\u003e) \u003d\u003e inv_Year(\u003cnil\u003e))))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((not ((RESULT not in set usedIds(dB~)) and ((e \u003d \u003carticle\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Article(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))))) \u003d\u003e ((e \u003d \u003cbook\u003e) \u003d\u003e inv_Edition(\u003cnil\u003e))))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((not ((RESULT not in set usedIds(dB~)) and ((e \u003d \u003carticle\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Article(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))))) \u003d\u003e ((e \u003d \u003cbook\u003e) \u003d\u003e inv_Month(\u003cnil\u003e))))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((not ((RESULT not in set usedIds(dB~)) and ((e \u003d \u003carticle\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Article(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))))) \u003d\u003e ((e \u003d \u003cbook\u003e) \u003d\u003e inv_Year(\u003cnil\u003e))))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((not ((RESULT not in set usedIds(dB~)) and ((e \u003d \u003carticle\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Article(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))))) \u003d\u003e ((not ((e \u003d \u003cbook\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Book(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((e \u003d \u003cinproceeding\u003e) \u003d\u003e inv_Month(\u003cnil\u003e)))))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((not ((RESULT not in set usedIds(dB~)) and ((e \u003d \u003carticle\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Article(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))))) \u003d\u003e ((not ((e \u003d \u003cbook\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Book(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((e \u003d \u003cinproceeding\u003e) \u003d\u003e inv_Year(\u003cnil\u003e)))))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((not ((RESULT not in set usedIds(dB~)) and ((e \u003d \u003carticle\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Article(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))))) \u003d\u003e ((not ((e \u003d \u003cbook\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Book(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((not ((e \u003d \u003cinproceeding\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Inproceeding(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((e \u003d \u003cmanual\u003e) \u003d\u003e inv_Edition(\u003cnil\u003e))))))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((not ((RESULT not in set usedIds(dB~)) and ((e \u003d \u003carticle\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Article(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))))) \u003d\u003e ((not ((e \u003d \u003cbook\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Book(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((not ((e \u003d \u003cinproceeding\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Inproceeding(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((e \u003d \u003cmanual\u003e) \u003d\u003e inv_Month(\u003cnil\u003e))))))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((not ((RESULT not in set usedIds(dB~)) and ((e \u003d \u003carticle\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Article(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))))) \u003d\u003e ((not ((e \u003d \u003cbook\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Book(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((not ((e \u003d \u003cinproceeding\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Inproceeding(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((e \u003d \u003cmanual\u003e) \u003d\u003e inv_Year(\u003cnil\u003e))))))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((not ((RESULT not in set usedIds(dB~)) and ((e \u003d \u003carticle\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Article(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))))) \u003d\u003e ((not ((e \u003d \u003cbook\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Book(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((not ((e \u003d \u003cinproceeding\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Inproceeding(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((not ((e \u003d \u003cmanual\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Manual(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((e \u003d \u003ctechreport\u003e) \u003d\u003e inv_Month(\u003cnil\u003e)))))))","type compatibility obligation:(forall e:Recordtype, oldstate:mgd \u0026 ((not ((RESULT not in set usedIds(dB~)) and ((e \u003d \u003carticle\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Article(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))))) \u003d\u003e ((not ((e \u003d \u003cbook\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Book(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((not ((e \u003d \u003cinproceeding\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Inproceeding(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((not ((e \u003d \u003cmanual\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Manual(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) \u003d\u003e ((e \u003d \u003ctechreport\u003e) \u003d\u003e inv_Year(\u003cnil\u003e)))))))","operation establishes postcondition obligation:(forall e:Recordtype, oldstate:mgd \u0026 (((RESULT not in set usedIds(dB~)) and ((e \u003d \u003carticle\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Article(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)})))) or (((e \u003d \u003cbook\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Book(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))) or (((e \u003d \u003cinproceeding\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Inproceeding(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))) or (((e \u003d \u003cmanual\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Manual(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))) or ((e \u003d \u003ctechreport\u003e) and ((((((dB union {mk_Article(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Book(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Inproceeding(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Manual(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) union {mk_Techreport(i, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}) \u003d (dB~ union {mk_Techreport(RESULT, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e, \u003cnil\u003e)}))))))))","legal function application obligation:((i in set usedIds(dB)) \u003d\u003e pre_recordtype(dB, i))","legal function application obligation:((i in set usedIds(dB)) \u003d\u003e ((f in set field(recordtype(dB, i))) \u003d\u003e (isvalueoffield(v, f) \u003d\u003e pre_iscomplete(dB, i))))","legal function application obligation:(((i in set usedIds(dB)) and ((f in set field(recordtype(dB, i))) and (isvalueoffield(v, f) and (not (iscomplete(dB, i) and isidentical(dB)))))) \u003d\u003e pre_getvalue(f, dB, i))","legal function application obligation:(((i in set usedIds(dB)) and ((f in set field(recordtype(dB, i))) and (isvalueoffield(v, f) and (not (iscomplete(dB, i) and isidentical(dB)))))) \u003d\u003e ((getvalue(f, dB, i) \u003d v) \u003d\u003e pre_get(dB, i)))","legal function application obligation:(((i in set usedIds(dB)) and ((f in set field(recordtype(dB, i))) and (isvalueoffield(v, f) and (not (iscomplete(dB, i) and isidentical(dB)))))) \u003d\u003e ((getvalue(f, dB, i) \u003d v) \u003d\u003e pre_get(dB~, i)))","legal function application obligation:(((i in set usedIds(dB)) and ((f in set field(recordtype(dB, i))) and (isvalueoffield(v, f) and (not (iscomplete(dB, i) and isidentical(dB)))))) \u003d\u003e ((getvalue(f, dB, i) \u003d v) \u003d\u003e (((dB \\ {get(dB, i)}) \u003d (dB~ \\ {get(dB~, i)})) \u003d\u003e pre_recordtype(dB, i))))","legal function application obligation:(((i in set usedIds(dB)) and ((f in set field(recordtype(dB, i))) and (isvalueoffield(v, f) and (not (iscomplete(dB, i) and isidentical(dB)))))) \u003d\u003e ((getvalue(f, dB, i) \u003d v) \u003d\u003e (((dB \\ {get(dB, i)}) \u003d (dB~ \\ {get(dB~, i)})) \u003d\u003e (forall x in set (field(recordtype(dB, i)) \\ {f}) \u0026 pre_getvalue(x, dB, i)))))","legal function application obligation:(((i in set usedIds(dB)) and ((f in set field(recordtype(dB, i))) and (isvalueoffield(v, f) and (not (iscomplete(dB, i) and isidentical(dB)))))) \u003d\u003e ((getvalue(f, dB, i) \u003d v) \u003d\u003e (((dB \\ {get(dB, i)}) \u003d (dB~ \\ {get(dB~, i)})) \u003d\u003e (forall x in set (field(recordtype(dB, i)) \\ {f}) \u0026 pre_getvalue(x, dB~, i)))))","legal function application obligation:((i in set usedIds(dB)) \u003d\u003e pre_recordtype(dB, i))","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, seq of (char)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, seq of (char)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, seq of (char)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(inv_Edition(v) and (is_(v, \u003cnil\u003e) or is_(v, nat)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, seq of (char)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, seq of (char)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, seq of (char)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(inv_Month(v) and (is_(v, \u003cnil\u003e) or is_(v, nat)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, seq of (char)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, nat1))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, seq of (char)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, nat1))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, seq of (char)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, seq of (char)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, seq of (char)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(is_(v, \u003cnil\u003e) or is_(v, nat1))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_get(dB, i)","type compatibility obligation:(inv_Year(v) and (is_(v, \u003cnil\u003e) or is_(v, nat)))","legal function application obligation:pre_get(dB, i)","legal function application obligation:pre_iscomplete(dB, i)","operation call obligation:(i in set usedIds(dB))","legal function application obligation:(forall i:Id, oldstate:mgd \u0026 ((i in set usedIds(dB)) \u003d\u003e pre_iscomplete(dB, i)))","legal function application obligation:(forall i:Id, oldstate:mgd \u0026 ((i in set usedIds(dB)) \u003d\u003e pre_iscomplete(dB, i)))","operation establishes postcondition obligation:(forall i:Id, oldstate:mgd \u0026 ((i in set usedIds(dB)) \u003d\u003e (iscomplete(dB, i) \u003c\u003d\u003e RESULT)))","legal function application obligation:((i in set usedIds(dB)) \u003d\u003e pre_get(dB~, i))","legal function application obligation:pre_get(dB, i)","legal function application obligation:(forall a:String, oldstate:mgd \u0026 (forall i in set RESULT \u0026 pre_get(dB, i)))","legal function application obligation:(forall a:String, oldstate:mgd \u0026 (forall i in set RESULT \u0026 (issubstring(a, (get(dB, i).author)) \u003d\u003e (forall record in set dB \u0026 (((record.id) not in set RESULT) \u003d\u003e pre_get(dB, i))))))","operation establishes postcondition obligation:(forall a:String, oldstate:mgd \u0026 (forall i in set RESULT \u0026 (issubstring(a, (get(dB, i).author)) and (not (exists record in set dB \u0026 (((record.id) not in set RESULT) and issubstring(a, (get(dB, i).author))))))))","legal function application obligation:(forall i:Id, oldstate:mgd \u0026 ((i in set usedIds(dB)) \u003d\u003e pre_get(dB, i)))","legal function application obligation:(forall i:Id, oldstate:mgd \u0026 ((i in set usedIds(dB)) \u003d\u003e pre_get(dB, i)))","operation establishes postcondition obligation:(forall i:Id, oldstate:mgd \u0026 ((i in set usedIds(dB)) \u003d\u003e (RESULT \u003d get(dB, i))))"] \ No newline at end of file diff --git a/core/pog/src/test/resources/old/direct/sl/shmemSL.vdmsl.result b/core/pog/src/test/resources/old/direct/sl/shmemSL.vdmsl.result index cb92ccb379..7bca5e0b8e 100644 --- a/core/pog/src/test/resources/old/direct/sl/shmemSL.vdmsl.result +++ b/core/pog/src/test/resources/old/direct/sl/shmemSL.vdmsl.result @@ -1 +1 @@ -["type invariant satisfiable obligation:(exists mk_M(-, a, b):M \u0026 (b \u003e\u003d a))","type compatibility obligation:(forall m:M \u0026 ((((m.stop) - (m.start)) + 1) \u003e 0))","recursive function obligation:(forall size:nat1, Q:Quadrant \u0026 ((not ([] \u003d Q)) \u003d\u003e (exists [h] ^ tail:Quadrant \u0026 ((([h] ^ tail) \u003d Q) \u003d\u003e let [h] ^ tail \u003d Q in ((not (((h.type) \u003d \u003cFREE\u003e) and (sizeof(h) \u003e\u003d size))) \u003d\u003e (QuadrantLen(size, Q) \u003e QuadrantLen(size, tail)))))))","cases exhaustive obligation:(forall size:nat1, Q:Quadrant \u0026 ((Q \u003d []) or (exists [h] ^ tail:Quadrant \u0026 (Q \u003d ([h] ^ tail)))))","recursive function obligation:(forall size:nat1, Q:Quadrant \u0026 ((not ([] \u003d Q)) \u003d\u003e (exists [h] ^ tail:Quadrant \u0026 ((([h] ^ tail) \u003d Q) \u003d\u003e let [h] ^ tail \u003d Q in ((((h.type) \u003d \u003cFREE\u003e) and (sizeof(h) \u003e\u003d size)) \u003d\u003e (QuadrantLen(size, Q) \u003e QuadrantLen(size, tail)))))))","recursive function obligation:(forall size:nat1, Q:Quadrant \u0026 ((not ([] \u003d Q)) \u003d\u003e (exists [h] ^ tail:Quadrant \u0026 ((([h] ^ tail) \u003d Q) \u003d\u003e let [h] ^ tail \u003d Q in ((not (((h.type) \u003d \u003cFREE\u003e) and (sizeof(h) \u003e\u003d size))) \u003d\u003e (QuadrantLen(size, Q) \u003e QuadrantLen(size, tail)))))))","cases exhaustive obligation:(forall size:nat1, Q:Quadrant \u0026 ((Q \u003d []) or (exists [h] ^ tail:Quadrant \u0026 (Q \u003d ([h] ^ tail)))))","type compatibility obligation:(forall size:nat1, hole:nat1, Q:Quadrant \u0026 ((hole \u003e\u003d size) \u003d\u003e (exists [h] ^ tail:Quadrant \u0026 ((([h] ^ tail) \u003d Q) \u003d\u003e let [h] ^ tail \u003d Q in ((((h.type) \u003d \u003cFREE\u003e) and (sizeof(h) \u003d hole)) \u003d\u003e ((hole \u003d size) \u003d\u003e inv_M(mk_M(\u003cUSED\u003e, (h.start), (h.stop)))))))))","type compatibility obligation:(forall size:nat1, hole:nat1, Q:Quadrant \u0026 ((hole \u003e\u003d size) \u003d\u003e (exists [h] ^ tail:Quadrant \u0026 ((([h] ^ tail) \u003d Q) \u003d\u003e let [h] ^ tail \u003d Q in ((((h.type) \u003d \u003cFREE\u003e) and (sizeof(h) \u003d hole)) \u003d\u003e ((not (hole \u003d size)) \u003d\u003e ((((h.start) + size) - 1) \u003e\u003d 0)))))))","type compatibility obligation:(forall size:nat1, hole:nat1, Q:Quadrant \u0026 ((hole \u003e\u003d size) \u003d\u003e (exists [h] ^ tail:Quadrant \u0026 ((([h] ^ tail) \u003d Q) \u003d\u003e let [h] ^ tail \u003d Q in ((((h.type) \u003d \u003cFREE\u003e) and (sizeof(h) \u003d hole)) \u003d\u003e ((not (hole \u003d size)) \u003d\u003e (inv_M(mk_M(\u003cUSED\u003e, (h.start), (((h.start) + size) - 1))) and ((((h.start) + size) - 1) \u003e\u003d 0))))))))","type compatibility obligation:(forall size:nat1, hole:nat1, Q:Quadrant \u0026 ((hole \u003e\u003d size) \u003d\u003e (exists [h] ^ tail:Quadrant \u0026 ((([h] ^ tail) \u003d Q) \u003d\u003e let [h] ^ tail \u003d Q in ((((h.type) \u003d \u003cFREE\u003e) and (sizeof(h) \u003d hole)) \u003d\u003e ((not (hole \u003d size)) \u003d\u003e inv_M(mk_M(\u003cFREE\u003e, ((h.start) + size), (h.stop)))))))))","legal function application obligation:(forall size:nat1, hole:nat1, Q:Quadrant \u0026 ((hole \u003e\u003d size) \u003d\u003e (exists [h] ^ tail:Quadrant \u0026 ((([h] ^ tail) \u003d Q) \u003d\u003e let [h] ^ tail \u003d Q in ((not (((h.type) \u003d \u003cFREE\u003e) and (sizeof(h) \u003d hole))) \u003d\u003e pre_add(size, hole, tail))))))","recursive function obligation:(forall size:nat1, hole:nat1, Q:Quadrant \u0026 ((hole \u003e\u003d size) \u003d\u003e (exists [h] ^ tail:Quadrant \u0026 ((([h] ^ tail) \u003d Q) \u003d\u003e let [h] ^ tail \u003d Q in ((not (((h.type) \u003d \u003cFREE\u003e) and (sizeof(h) \u003d hole))) \u003d\u003e (QuadrantLen2(size, hole, Q) \u003e QuadrantLen2(size, hole, tail)))))))","recursive function obligation:(forall Q:Quadrant \u0026 (exists [h1, h2] ^ tail:Quadrant \u0026 ((([h1, h2] ^ tail) \u003d Q) \u003d\u003e let [h1, h2] ^ tail \u003d Q in ((((h1.type) \u003d \u003cFREE\u003e) and ((h2.type) \u003d \u003cFREE\u003e)) \u003d\u003e (QuadrantLen0(Q) \u003e QuadrantLen0(([mk_M(\u003cFREE\u003e, (h1.start), (h2.stop))] ^ tail)))))))","type compatibility obligation:(forall Q:Quadrant \u0026 (exists [h1, h2] ^ tail:Quadrant \u0026 ((([h1, h2] ^ tail) \u003d Q) \u003d\u003e let [h1, h2] ^ tail \u003d Q in ((((h1.type) \u003d \u003cFREE\u003e) and ((h2.type) \u003d \u003cFREE\u003e)) \u003d\u003e inv_M(mk_M(\u003cFREE\u003e, (h1.start), (h2.stop)))))))","recursive function obligation:(forall Q:Quadrant \u0026 (exists [h1, h2] ^ tail:Quadrant \u0026 ((([h1, h2] ^ tail) \u003d Q) \u003d\u003e let [h1, h2] ^ tail \u003d Q in ((not (((h1.type) \u003d \u003cFREE\u003e) and ((h2.type) \u003d \u003cFREE\u003e))) \u003d\u003e (QuadrantLen0(Q) \u003e QuadrantLen0((tl Q)))))))","non-empty sequence obligation:(forall Q:Quadrant \u0026 (exists [h1, h2] ^ tail:Quadrant \u0026 ((([h1, h2] ^ tail) \u003d Q) \u003d\u003e let [h1, h2] ^ tail \u003d Q in ((not (((h1.type) \u003d \u003cFREE\u003e) and ((h2.type) \u003d \u003cFREE\u003e))) \u003d\u003e (Q \u003c\u003e [])))))","non-empty sequence obligation:(forall item:M, Q:Quadrant \u0026 (Q \u003c\u003e []))","type compatibility obligation:(forall item:M, Q:Quadrant \u0026 (((hd Q) \u003d item) \u003d\u003e inv_M(mk_M(\u003cFREE\u003e, (item.start), (item.stop)))))","non-empty sequence obligation:(forall item:M, Q:Quadrant \u0026 (((hd Q) \u003d item) \u003d\u003e (Q \u003c\u003e [])))","non-empty sequence obligation:(forall item:M, Q:Quadrant \u0026 ((not ((hd Q) \u003d item)) \u003d\u003e (Q \u003c\u003e [])))","recursive function obligation:(forall item:M, Q:Quadrant \u0026 ((not ((hd Q) \u003d item)) \u003d\u003e (MQuadrantLen(item, Q) \u003e MQuadrantLen(item, (tl Q)))))","non-empty sequence obligation:(forall item:M, Q:Quadrant \u0026 ((not ((hd Q) \u003d item)) \u003d\u003e (Q \u003c\u003e [])))","type compatibility obligation:(forall Q:Quadrant \u0026 (((card {x | x in set (elems Q) \u0026 ((x.type) \u003d \u003cFREE\u003e)}) - 1) \u003e\u003d 0))","state invariant holds obligation:(forall n:nat1, oldstate:Memory \u0026 let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0)))","state invariant holds obligation:let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0))","type compatibility obligation:((((rseed * 69069) + 5) mod 4294967296) \u003e\u003d 0)","type compatibility obligation:(forall n:nat1, oldstate:Memory \u0026 (true \u003d\u003e (RESULT \u003e 0)))","state invariant holds obligation:(forall size:nat1, oldstate:Memory \u0026 let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0)))","legal function application obligation:(forall size:nat1, oldstate:Memory \u0026 pre_add(size, q4, Q4))","state invariant holds obligation:(forall size:nat1, oldstate:Memory \u0026 let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0)))","legal function application obligation:(forall size:nat1, oldstate:Memory \u0026 pre_add(size, q3, Q3))","state invariant holds obligation:(forall size:nat1, oldstate:Memory \u0026 let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0)))","legal function application obligation:(forall size:nat1, oldstate:Memory \u0026 pre_add(size, q4, Q4))","state invariant holds obligation:(forall size:nat1, oldstate:Memory \u0026 let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0)))","legal function application obligation:(forall size:nat1, oldstate:Memory \u0026 pre_add(size, q3, Q3))","state invariant holds obligation:let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0))","type compatibility obligation:((MAXMEM - 1) \u003e\u003d 0)","type compatibility obligation:(inv_M(mk_M(\u003cFREE\u003e, 0, (MAXMEM - 1))) and ((MAXMEM - 1) \u003e\u003d 0))","state invariant holds obligation:let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0))","type compatibility obligation:((MAXMEM - 1) \u003e\u003d 0)","type compatibility obligation:(inv_M(mk_M(\u003cFREE\u003e, 0, (MAXMEM - 1))) and ((MAXMEM - 1) \u003e\u003d 0))","legal sequence application obligation:(((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e))) \u003d\u003e (i in set (inds Q3)))","state invariant holds obligation:(((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e))) \u003d\u003e let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0)))","legal sequence application obligation:(((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e))) \u003d\u003e (i in set (inds Q3)))","operation call obligation:(((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e))) \u003d\u003e ((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e))))","legal sequence application obligation:(((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e))) \u003d\u003e (true \u003d\u003e (i in set (inds Q4))))","state invariant holds obligation:(((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e))) \u003d\u003e (true \u003d\u003e let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0))))","legal sequence application obligation:(((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e))) \u003d\u003e (true \u003d\u003e (i in set (inds Q4))))","operation call obligation:(((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e))) \u003d\u003e (true \u003d\u003e ((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e)))))","while loop termination obligation:NotYetImplemented","operation call obligation:(forall loops:nat, oldstate:Memory \u0026 ((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e))))","state invariant holds obligation:(forall loops:nat, oldstate:Memory \u0026 (true \u003d\u003e let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0))))","while loop termination obligation:NotYetImplemented","operation call obligation:(forall loops:nat, oldstate:Memory \u0026 ((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e))))","state invariant holds obligation:(forall loops:nat, oldstate:Memory \u0026 (true \u003d\u003e let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0))))","state invariant holds obligation:(forall tries:nat1, loops:nat1, oldstate:Memory \u0026 (true \u003d\u003e (true \u003d\u003e let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0)))))","state invariant holds obligation:(forall tries:nat1, loops:nat1, oldstate:Memory \u0026 (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0)))))))","state invariant holds obligation:(forall tries:nat1, loops:nat1, oldstate:Memory \u0026 (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0)))))))","state invariant holds obligation:(forall tries:nat1, loops:nat1, oldstate:Memory \u0026 (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0)))))))","state invariant holds obligation:(forall tries:nat1, loops:nat1, oldstate:Memory \u0026 (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0)))))))"] \ No newline at end of file +["type invariant satisfiable obligation:(exists mk_M(-, a, b):M \u0026 (b \u003e\u003d a))","type compatibility obligation:(forall m:M \u0026 ((((m.stop) - (m.start)) + 1) \u003e 0))","recursive function obligation:(forall size:nat1, Q:Quadrant \u0026 ((not ([] \u003d Q)) \u003d\u003e (exists [h] ^ tail:Quadrant \u0026 ((([h] ^ tail) \u003d Q) \u003d\u003e let [h] ^ tail \u003d Q in ((not (((h.type) \u003d \u003cFREE\u003e) and (sizeof(h) \u003e\u003d size))) \u003d\u003e (QuadrantLen(size, Q) \u003e QuadrantLen(size, tail)))))))","cases exhaustive obligation:(forall size:nat1, Q:Quadrant \u0026 ((Q \u003d []) or (exists [h] ^ tail:Quadrant \u0026 (Q \u003d ([h] ^ tail)))))","recursive function obligation:(forall size:nat1, Q:Quadrant \u0026 ((not ([] \u003d Q)) \u003d\u003e (exists [h] ^ tail:Quadrant \u0026 ((([h] ^ tail) \u003d Q) \u003d\u003e let [h] ^ tail \u003d Q in ((((h.type) \u003d \u003cFREE\u003e) and (sizeof(h) \u003e\u003d size)) \u003d\u003e (QuadrantLen(size, Q) \u003e QuadrantLen(size, tail)))))))","recursive function obligation:(forall size:nat1, Q:Quadrant \u0026 ((not ([] \u003d Q)) \u003d\u003e (exists [h] ^ tail:Quadrant \u0026 ((([h] ^ tail) \u003d Q) \u003d\u003e let [h] ^ tail \u003d Q in ((not (((h.type) \u003d \u003cFREE\u003e) and (sizeof(h) \u003e\u003d size))) \u003d\u003e (QuadrantLen(size, Q) \u003e QuadrantLen(size, tail)))))))","cases exhaustive obligation:(forall size:nat1, Q:Quadrant \u0026 ((Q \u003d []) or (exists [h] ^ tail:Quadrant \u0026 (Q \u003d ([h] ^ tail)))))","type compatibility obligation:(forall size:nat1, hole:nat1, Q:Quadrant \u0026 ((hole \u003e\u003d size) \u003d\u003e (exists [h] ^ tail:Quadrant \u0026 ((([h] ^ tail) \u003d Q) \u003d\u003e let [h] ^ tail \u003d Q in ((((h.type) \u003d \u003cFREE\u003e) and (sizeof(h) \u003d hole)) \u003d\u003e ((hole \u003d size) \u003d\u003e inv_M(mk_M(\u003cUSED\u003e, (h.start), (h.stop)))))))))","type compatibility obligation:(forall size:nat1, hole:nat1, Q:Quadrant \u0026 ((hole \u003e\u003d size) \u003d\u003e (exists [h] ^ tail:Quadrant \u0026 ((([h] ^ tail) \u003d Q) \u003d\u003e let [h] ^ tail \u003d Q in ((((h.type) \u003d \u003cFREE\u003e) and (sizeof(h) \u003d hole)) \u003d\u003e ((not (hole \u003d size)) \u003d\u003e ((((h.start) + size) - 1) \u003e\u003d 0)))))))","type compatibility obligation:(forall size:nat1, hole:nat1, Q:Quadrant \u0026 ((hole \u003e\u003d size) \u003d\u003e (exists [h] ^ tail:Quadrant \u0026 ((([h] ^ tail) \u003d Q) \u003d\u003e let [h] ^ tail \u003d Q in ((((h.type) \u003d \u003cFREE\u003e) and (sizeof(h) \u003d hole)) \u003d\u003e ((not (hole \u003d size)) \u003d\u003e (inv_M(mk_M(\u003cUSED\u003e, (h.start), (((h.start) + size) - 1))) and ((((h.start) + size) - 1) \u003e\u003d 0))))))))","type compatibility obligation:(forall size:nat1, hole:nat1, Q:Quadrant \u0026 ((hole \u003e\u003d size) \u003d\u003e (exists [h] ^ tail:Quadrant \u0026 ((([h] ^ tail) \u003d Q) \u003d\u003e let [h] ^ tail \u003d Q in ((((h.type) \u003d \u003cFREE\u003e) and (sizeof(h) \u003d hole)) \u003d\u003e ((not (hole \u003d size)) \u003d\u003e inv_M(mk_M(\u003cFREE\u003e, ((h.start) + size), (h.stop)))))))))","legal function application obligation:(forall size:nat1, hole:nat1, Q:Quadrant \u0026 ((hole \u003e\u003d size) \u003d\u003e (exists [h] ^ tail:Quadrant \u0026 ((([h] ^ tail) \u003d Q) \u003d\u003e let [h] ^ tail \u003d Q in ((not (((h.type) \u003d \u003cFREE\u003e) and (sizeof(h) \u003d hole))) \u003d\u003e pre_add(size, hole, tail))))))","recursive function obligation:(forall size:nat1, hole:nat1, Q:Quadrant \u0026 ((hole \u003e\u003d size) \u003d\u003e (exists [h] ^ tail:Quadrant \u0026 ((([h] ^ tail) \u003d Q) \u003d\u003e let [h] ^ tail \u003d Q in ((not (((h.type) \u003d \u003cFREE\u003e) and (sizeof(h) \u003d hole))) \u003d\u003e (QuadrantLen2(size, hole, Q) \u003e QuadrantLen2(size, hole, tail)))))))","recursive function obligation:(forall Q:Quadrant \u0026 (exists [h1, h2] ^ tail:Quadrant \u0026 ((([h1, h2] ^ tail) \u003d Q) \u003d\u003e let [h1, h2] ^ tail \u003d Q in ((((h1.type) \u003d \u003cFREE\u003e) and ((h2.type) \u003d \u003cFREE\u003e)) \u003d\u003e (QuadrantLen0(Q) \u003e QuadrantLen0(([mk_M(\u003cFREE\u003e, (h1.start), (h2.stop))] ^ tail)))))))","type compatibility obligation:(forall Q:Quadrant \u0026 (exists [h1, h2] ^ tail:Quadrant \u0026 ((([h1, h2] ^ tail) \u003d Q) \u003d\u003e let [h1, h2] ^ tail \u003d Q in ((((h1.type) \u003d \u003cFREE\u003e) and ((h2.type) \u003d \u003cFREE\u003e)) \u003d\u003e inv_M(mk_M(\u003cFREE\u003e, (h1.start), (h2.stop)))))))","recursive function obligation:(forall Q:Quadrant \u0026 (exists [h1, h2] ^ tail:Quadrant \u0026 ((([h1, h2] ^ tail) \u003d Q) \u003d\u003e let [h1, h2] ^ tail \u003d Q in ((not (((h1.type) \u003d \u003cFREE\u003e) and ((h2.type) \u003d \u003cFREE\u003e))) \u003d\u003e (QuadrantLen0(Q) \u003e QuadrantLen0((tl Q)))))))","non-empty sequence obligation:(forall Q:Quadrant \u0026 (exists [h1, h2] ^ tail:Quadrant \u0026 ((([h1, h2] ^ tail) \u003d Q) \u003d\u003e let [h1, h2] ^ tail \u003d Q in ((not (((h1.type) \u003d \u003cFREE\u003e) and ((h2.type) \u003d \u003cFREE\u003e))) \u003d\u003e (Q \u003c\u003e [])))))","non-empty sequence obligation:(forall item:M, Q:Quadrant \u0026 (Q \u003c\u003e []))","type compatibility obligation:(forall item:M, Q:Quadrant \u0026 (((hd Q) \u003d item) \u003d\u003e inv_M(mk_M(\u003cFREE\u003e, (item.start), (item.stop)))))","non-empty sequence obligation:(forall item:M, Q:Quadrant \u0026 (((hd Q) \u003d item) \u003d\u003e (Q \u003c\u003e [])))","non-empty sequence obligation:(forall item:M, Q:Quadrant \u0026 ((not ((hd Q) \u003d item)) \u003d\u003e (Q \u003c\u003e [])))","recursive function obligation:(forall item:M, Q:Quadrant \u0026 ((not ((hd Q) \u003d item)) \u003d\u003e (MQuadrantLen(item, Q) \u003e MQuadrantLen(item, (tl Q)))))","non-empty sequence obligation:(forall item:M, Q:Quadrant \u0026 ((not ((hd Q) \u003d item)) \u003d\u003e (Q \u003c\u003e [])))","type compatibility obligation:(forall Q:Quadrant \u0026 (((card {x | x in set (elems Q) \u0026 ((x.type) \u003d \u003cFREE\u003e)}) - 1) \u003e\u003d 0))","state invariant holds obligation:(forall n:nat1, oldstate:Memory \u0026 let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0)))","state invariant holds obligation:let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0))","type compatibility obligation:((((rseed * 69069) + 5) mod 4294967296) \u003e\u003d 0)","type compatibility obligation:(forall n:nat1, oldstate:Memory \u0026 (true \u003d\u003e (RESULT \u003e 0)))","state invariant holds obligation:(forall size:nat1, oldstate:Memory \u0026 let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0)))","legal function application obligation:(forall size:nat1, oldstate:Memory \u0026 pre_add(size, q4, Q4))","state invariant holds obligation:(forall size:nat1, oldstate:Memory \u0026 let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0)))","legal function application obligation:(forall size:nat1, oldstate:Memory \u0026 pre_add(size, q3, Q3))","state invariant holds obligation:(forall size:nat1, oldstate:Memory \u0026 let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0)))","legal function application obligation:(forall size:nat1, oldstate:Memory \u0026 pre_add(size, q4, Q4))","state invariant holds obligation:(forall size:nat1, oldstate:Memory \u0026 let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0)))","legal function application obligation:(forall size:nat1, oldstate:Memory \u0026 pre_add(size, q3, Q3))","state invariant holds obligation:let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0))","type compatibility obligation:((MAXMEM - 1) \u003e\u003d 0)","type compatibility obligation:(inv_M(mk_M(\u003cFREE\u003e, 0, (MAXMEM - 1))) and ((MAXMEM - 1) \u003e\u003d 0))","state invariant holds obligation:let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0))","type compatibility obligation:((MAXMEM - 1) \u003e\u003d 0)","type compatibility obligation:(inv_M(mk_M(\u003cFREE\u003e, 0, (MAXMEM - 1))) and ((MAXMEM - 1) \u003e\u003d 0))","legal sequence application obligation:(((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e))) \u003d\u003e (i in set (inds Q3)))","state invariant holds obligation:(((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e))) \u003d\u003e let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0)))","legal sequence application obligation:(((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e))) \u003d\u003e (i in set (inds Q3)))","operation call obligation:(((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e))) \u003d\u003e ((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e))))","legal sequence application obligation:(((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e))) \u003d\u003e (true \u003d\u003e (i in set (inds Q4))))","state invariant holds obligation:(((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e))) \u003d\u003e (true \u003d\u003e let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0))))","legal sequence application obligation:(((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e))) \u003d\u003e (true \u003d\u003e (i in set (inds Q4))))","operation call obligation:(((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e))) \u003d\u003e (true \u003d\u003e ((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e)))))","while loop termination obligation:...","operation call obligation:(forall loops:nat, oldstate:Memory \u0026 ((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e))))","state invariant holds obligation:(forall loops:nat, oldstate:Memory \u0026 (true \u003d\u003e let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0))))","while loop termination obligation:...","operation call obligation:(forall loops:nat, oldstate:Memory \u0026 ((exists m in set (elems Q3) \u0026 ((m.type) \u003d \u003cUSED\u003e)) or (exists m in set (elems Q4) \u0026 ((m.type) \u003d \u003cUSED\u003e))))","state invariant holds obligation:(forall loops:nat, oldstate:Memory \u0026 (true \u003d\u003e let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0))))","state invariant holds obligation:(forall tries:nat1, loops:nat1, oldstate:Memory \u0026 (true \u003d\u003e (true \u003d\u003e let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0)))))","state invariant holds obligation:(forall tries:nat1, loops:nat1, oldstate:Memory \u0026 (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0)))))))","state invariant holds obligation:(forall tries:nat1, loops:nat1, oldstate:Memory \u0026 (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0)))))))","state invariant holds obligation:(forall tries:nat1, loops:nat1, oldstate:Memory \u0026 (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0)))))))","state invariant holds obligation:(forall tries:nat1, loops:nat1, oldstate:Memory \u0026 (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e (true \u003d\u003e let mk_Memory(-, q3, q4) \u003d Memory in (((len q3) \u003e 0) and ((len q4) \u003e 0)))))))"] \ No newline at end of file From 49789598ed21d81e82ef2d6147bf41a543a3dec3 Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Mon, 30 Mar 2015 08:23:21 +0200 Subject: [PATCH 321/323] Add 2.2.4 release notes. [Issue: ] --- .../releasenotes/ReleaseNotes_2.2.4.md | 83 +++++++++++++++++++ .../releasenotes/ReleaseNotes_2.2.4_abbrev.md | 41 +++++++++ 2 files changed, 124 insertions(+) create mode 100644 documentation/releasenotes/ReleaseNotes_2.2.4.md create mode 100644 documentation/releasenotes/ReleaseNotes_2.2.4_abbrev.md diff --git a/documentation/releasenotes/ReleaseNotes_2.2.4.md b/documentation/releasenotes/ReleaseNotes_2.2.4.md new file mode 100644 index 0000000000..64080c58c4 --- /dev/null +++ b/documentation/releasenotes/ReleaseNotes_2.2.4.md @@ -0,0 +1,83 @@ +# Overture 2.2.4 Release Notes — 30 March 2015 + +## What's New? + +This release contains bugfixes and a few usability improvements. + +## System Requirements + +Overture is based on the Eclipse platform. To run it, you must have a Java runtime system installed, version 7 or later. + +## Download & Installation + +Documentation, including tutorials and a language manual, are bundled in the download package, and are also available from the [Overture website](http://www.overturetool.org/). + +Overture can be downloaded from GitHub at . + +The download file is a ZIP archive. To install the tool, unzip the file in a convenient location. The main executable is in the top level directory, called `Overture`. + +We will be making an exe-based installer available for Windows user at a future point. + + +### Upgrading: + +* ATTENTION: If you are using the ZIP archive to update and if your workspace was located inside the previous installation directory, DO NOT FORGET TO BACKUP the workspace or it will be lost when the old version is deleted. +* If you are upgrading with the ZIP archive: do not unzip the latest version on top of the oldest one. You will need to delete the previous version before continuing the installation. + + +### Uninstalling + +To uninstall Overture, remove the contents of the directory where you installed it. There are no other files stored on the system, apart from any workspace files you may have created. + +For Windows users, if the Overture installer was used previously, it is possible to uninstall via the uninstall shortcut created by the installer in the start programs or via the Uninstall menu in the Control Panel. + + +## Reporting Problems and Troubleshooting + +Please report bugs, problems, and other issues with the tool at . + +If you encounter a problem with the Overture IDE itself, please contact the Overture project and we will try to help. You can contact us at info@overturetool.org, or use [StackOverflow](http://stackoverflow.com/questions/tagged/vdm%2b%2b) — we monitor for questions using the `vdm`, `vdm++`, or `vdmrt` tags. + +If you encounter a problem with a VDM specification, please try to make a small example that illustrates the problem before you contact us. If you are sure the bug is not already known in the GitHub issues list, you can create a new bug report. + + +## Frequently Asked Questions + +* Who's behind Overture? +> Overture was written by the members of the Overture project, a group of industry and academic researchers interested in the use of VDM. + +* How is Overture licensed? +> Overture is open source. It is released under a GPLv3 license. + +* What can I do to help? +> If you are interested in helping you can drop a mail to info@overturetool.org. You are also very welcome to fork our code on GitHub and send us pull requests. + +* Where is Overture source code? +> Overture source code is hosted by GitHub, within the [overturetool](https://github.com/overturetool) organisation account. + + +## Other Resources and Links + +* [Overture Community site](http://www.overturetool.org) +* [VDM Tutorials](http://overturetool.org/documentation/tutorials.html) +* [VDM Examples](http://overturetool.org/download/examples/) +* [Wikipedia on VDM](http://en.wikipedia.org/wiki/Vienna_Development_Method) +* [Overture Developers Wiki on GitHub](https://github.com/overturetool/overture/wiki/) +* [The Old Overture Wiki for developers](http://wiki.overturetool.org) + + +## Bug fixes + +Please note that the interactive list is at + +* [#435 Typecheck problem with forward references](https://github.com/overturetool/overture/issues/435) +* [#434 Bug tracker link in Welcome page](https://github.com/overturetool/overture/issues/434) +* [#433 Incorrect type check of "++" operator](https://github.com/overturetool/overture/issues/433) +* [#432 Subset and psubsets should give TC error if the types do not match](https://github.com/overturetool/overture/issues/432) +* [#431 Inherited definitions not visible in the launch configuration view](https://github.com/overturetool/overture/issues/431) +* [#429 JVM version misreported?](https://github.com/overturetool/overture/issues/429) +* [#428 Isagen and CG extensibility improvements](https://github.com/overturetool/overture/issues/428) +* [#425 Improvements to the Java code generator based on feedback from the INTO-CPS project](https://github.com/overturetool/overture/issues/425) +* [#424 The is_expression does not work for function types](https://github.com/overturetool/overture/issues/424) +* [#421 Improving the usability of the Java code generator plugin](https://github.com/overturetool/overture/issues/421) +* [#420 POG not implemented for while loops](https://github.com/overturetool/overture/issues/420) diff --git a/documentation/releasenotes/ReleaseNotes_2.2.4_abbrev.md b/documentation/releasenotes/ReleaseNotes_2.2.4_abbrev.md new file mode 100644 index 0000000000..fc180e5715 --- /dev/null +++ b/documentation/releasenotes/ReleaseNotes_2.2.4_abbrev.md @@ -0,0 +1,41 @@ +# Overture 2.2.0 Release Notes — 27 February 2015 + +## What's New? + +This release contains bugfixes and a few usability improvements. + +## Reporting Problems and Troubleshooting + +Please report bugs, problems, and other issues with the tool at . + +If you encounter a problem with the Overture IDE itself, please contact the Overture project and we will try to help. You can contact us at info@overturetool.org, or use [StackOverflow](http://stackoverflow.com/questions/tagged/vdm%2b%2b) — we monitor for questions using the `vdm`, `vdm++`, or `vdmrt` tags. + +If you encounter a problem with a VDM specification, please try to make a small example that illustrates the problem before you contact us. If you are sure the bug is not already known in the GitHub issues list, you can create a new bug report. + + +## Other Resources and Links + +* [Overture Community site](http://www.overturetool.org) +* [VDM Tutorials](http://overturetool.org/documentation/tutorials.html) +* [VDM Examples](http://overturetool.org/download/examples/) +* [Wikipedia on VDM](http://en.wikipedia.org/wiki/Vienna_Development_Method) +* [Overture Developers Wiki on GitHub](https://github.com/overturetool/overture/wiki/) +* [The Old Overture Wiki for developers](http://wiki.overturetool.org) + + +## Bug fixes + +Please note that the interactive list is at + +* [#435 Typecheck problem with forward references](https://github.com/overturetool/overture/issues/435) +* [#434 Bug tracker link in Welcome page](https://github.com/overturetool/overture/issues/434) +* [#433 Incorrect type check of "++" operator](https://github.com/overturetool/overture/issues/433) +* [#432 Subset and psubsets should give TC error if the types do not match](https://github.com/overturetool/overture/issues/432) +* [#431 Inherited definitions not visible in the launch configuration view](https://github.com/overturetool/overture/issues/431) +* [#429 JVM version misreported?](https://github.com/overturetool/overture/issues/429) +* [#428 Isagen and CG extensibility improvements](https://github.com/overturetool/overture/issues/428) +* [#425 Improvements to the Java code generator based on feedback from the INTO-CPS project](https://github.com/overturetool/overture/issues/425) +* [#424 The is_expression does not work for function types](https://github.com/overturetool/overture/issues/424) +* [#421 Improving the usability of the Java code generator plugin](https://github.com/overturetool/overture/issues/421) +* [#420 POG not implemented for while loops](https://github.com/overturetool/overture/issues/420) + From cee506ce3c28bd15f73f5cc6fb4f78801f4e64aa Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Mon, 30 Mar 2015 12:32:33 +0200 Subject: [PATCH 322/323] [maven-release-plugin] prepare release Release/2.2.4 --- core/ast/pom.xml | 2 +- core/codegen/codegen-maven-plugin/pom.xml | 4 ++-- core/codegen/codegen-runtime/pom.xml | 2 +- core/codegen/javagen/pom.xml | 2 +- core/codegen/pom.xml | 2 +- core/combinatorialtesting/ctruntime/pom.xml | 2 +- core/combinatorialtesting/ctutils/pom.xml | 2 +- core/combinatorialtesting/pom.xml | 2 +- core/commandline/pom.xml | 2 +- core/guibuilder/pom.xml | 2 +- core/interpreter/pom.xml | 2 +- core/modelcheckers/pom.xml | 2 +- core/modelcheckers/probsolver/pom.xml | 2 +- core/modelcheckers/probsolverintegration/pom.xml | 2 +- core/parser/pom.xml | 2 +- core/pog/pom.xml | 2 +- core/pom.xml | 2 +- core/prettyprinting/npp/pom.xml | 2 +- core/prettyprinting/pom.xml | 2 +- core/prettyprinting/prettyprinter/pom.xml | 2 +- core/testframework/pom.xml | 2 +- core/testing/exsupport/pom.xml | 2 +- core/testing/extests/pom.xml | 2 +- core/testing/framework/pom.xml | 2 +- core/testing/pom.xml | 2 +- core/testing/tests/pom.xml | 2 +- core/typechecker/pom.xml | 2 +- core/vdmjc/pom.xml | 2 +- externals/documentation/pom.xml | 2 +- externals/examples/pom.xml | 2 +- externals/pom.xml | 2 +- pom.xml | 4 ++-- 32 files changed, 34 insertions(+), 34 deletions(-) diff --git a/core/ast/pom.xml b/core/ast/pom.xml index 196e55a482..3a009145a0 100644 --- a/core/ast/pom.xml +++ b/core/ast/pom.xml @@ -4,7 +4,7 @@ org.overturetool core - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/core/codegen/codegen-maven-plugin/pom.xml b/core/codegen/codegen-maven-plugin/pom.xml index c1fbc2ea12..5a291be9ce 100644 --- a/core/codegen/codegen-maven-plugin/pom.xml +++ b/core/codegen/codegen-maven-plugin/pom.xml @@ -4,7 +4,7 @@ org.overturetool.core codegen - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml @@ -46,7 +46,7 @@ - + diff --git a/core/codegen/codegen-runtime/pom.xml b/core/codegen/codegen-runtime/pom.xml index 0cdf760e36..35df63e508 100644 --- a/core/codegen/codegen-runtime/pom.xml +++ b/core/codegen/codegen-runtime/pom.xml @@ -4,7 +4,7 @@ org.overturetool.core codegen - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/core/codegen/javagen/pom.xml b/core/codegen/javagen/pom.xml index abfa242b77..0489e88998 100644 --- a/core/codegen/javagen/pom.xml +++ b/core/codegen/javagen/pom.xml @@ -4,7 +4,7 @@ org.overturetool.core codegen - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/core/codegen/pom.xml b/core/codegen/pom.xml index 2238f72666..8b7735d6fc 100644 --- a/core/codegen/pom.xml +++ b/core/codegen/pom.xml @@ -4,7 +4,7 @@ core org.overturetool - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/core/combinatorialtesting/ctruntime/pom.xml b/core/combinatorialtesting/ctruntime/pom.xml index 7434e84874..77665ca221 100644 --- a/core/combinatorialtesting/ctruntime/pom.xml +++ b/core/combinatorialtesting/ctruntime/pom.xml @@ -4,7 +4,7 @@ org.overturetool.core combinatorialtesting - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/core/combinatorialtesting/ctutils/pom.xml b/core/combinatorialtesting/ctutils/pom.xml index a2e99c9531..223fd28263 100644 --- a/core/combinatorialtesting/ctutils/pom.xml +++ b/core/combinatorialtesting/ctutils/pom.xml @@ -4,7 +4,7 @@ org.overturetool.core combinatorialtesting - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/core/combinatorialtesting/pom.xml b/core/combinatorialtesting/pom.xml index 54c9a7912c..43c5d53076 100644 --- a/core/combinatorialtesting/pom.xml +++ b/core/combinatorialtesting/pom.xml @@ -4,7 +4,7 @@ core org.overturetool - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/core/commandline/pom.xml b/core/commandline/pom.xml index 70f309d376..8bfbcbc25f 100644 --- a/core/commandline/pom.xml +++ b/core/commandline/pom.xml @@ -4,7 +4,7 @@ org.overturetool core - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/core/guibuilder/pom.xml b/core/guibuilder/pom.xml index 905189b2fc..c221b5b68d 100644 --- a/core/guibuilder/pom.xml +++ b/core/guibuilder/pom.xml @@ -4,7 +4,7 @@ org.overturetool core - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/core/interpreter/pom.xml b/core/interpreter/pom.xml index efe21ca7f8..4929de1b60 100644 --- a/core/interpreter/pom.xml +++ b/core/interpreter/pom.xml @@ -4,7 +4,7 @@ org.overturetool core - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/core/modelcheckers/pom.xml b/core/modelcheckers/pom.xml index 1b5d47cfdc..baf4eb7e56 100644 --- a/core/modelcheckers/pom.xml +++ b/core/modelcheckers/pom.xml @@ -4,7 +4,7 @@ org.overturetool core - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/core/modelcheckers/probsolver/pom.xml b/core/modelcheckers/probsolver/pom.xml index b2447e83aa..7d721d3d2a 100644 --- a/core/modelcheckers/probsolver/pom.xml +++ b/core/modelcheckers/probsolver/pom.xml @@ -4,7 +4,7 @@ org.overturetool.core modelcheckers - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/core/modelcheckers/probsolverintegration/pom.xml b/core/modelcheckers/probsolverintegration/pom.xml index 221ef2fb0e..614e070507 100644 --- a/core/modelcheckers/probsolverintegration/pom.xml +++ b/core/modelcheckers/probsolverintegration/pom.xml @@ -4,7 +4,7 @@ org.overturetool.core modelcheckers - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/core/parser/pom.xml b/core/parser/pom.xml index 58dc06d503..f38665948d 100644 --- a/core/parser/pom.xml +++ b/core/parser/pom.xml @@ -4,7 +4,7 @@ org.overturetool core - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/core/pog/pom.xml b/core/pog/pom.xml index a62efa5d45..d3a7ea0929 100644 --- a/core/pog/pom.xml +++ b/core/pog/pom.xml @@ -4,7 +4,7 @@ org.overturetool core - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/core/pom.xml b/core/pom.xml index 27041300ef..55a7549b20 100644 --- a/core/pom.xml +++ b/core/pom.xml @@ -4,7 +4,7 @@ org.overturetool root - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/core/prettyprinting/npp/pom.xml b/core/prettyprinting/npp/pom.xml index 90a94a4b08..2e84290f11 100644 --- a/core/prettyprinting/npp/pom.xml +++ b/core/prettyprinting/npp/pom.xml @@ -4,7 +4,7 @@ org.overturetool.core prettyprinting - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/core/prettyprinting/pom.xml b/core/prettyprinting/pom.xml index e442073170..bff663fd16 100644 --- a/core/prettyprinting/pom.xml +++ b/core/prettyprinting/pom.xml @@ -4,7 +4,7 @@ org.overturetool core - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/core/prettyprinting/prettyprinter/pom.xml b/core/prettyprinting/prettyprinter/pom.xml index 0b24703368..184d673bb0 100644 --- a/core/prettyprinting/prettyprinter/pom.xml +++ b/core/prettyprinting/prettyprinter/pom.xml @@ -4,7 +4,7 @@ org.overturetool.core prettyprinting - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/core/testframework/pom.xml b/core/testframework/pom.xml index 226aa73404..2f20100542 100644 --- a/core/testframework/pom.xml +++ b/core/testframework/pom.xml @@ -4,7 +4,7 @@ org.overturetool core - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/core/testing/exsupport/pom.xml b/core/testing/exsupport/pom.xml index 24e9921476..0e85e94a4d 100644 --- a/core/testing/exsupport/pom.xml +++ b/core/testing/exsupport/pom.xml @@ -4,7 +4,7 @@ org.overturetool.core testing - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/core/testing/extests/pom.xml b/core/testing/extests/pom.xml index 28adfc1f3e..f29e0db3b5 100644 --- a/core/testing/extests/pom.xml +++ b/core/testing/extests/pom.xml @@ -4,7 +4,7 @@ org.overturetool.core testing - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/core/testing/framework/pom.xml b/core/testing/framework/pom.xml index 52787a950e..9df2bfad4d 100644 --- a/core/testing/framework/pom.xml +++ b/core/testing/framework/pom.xml @@ -4,7 +4,7 @@ org.overturetool.core testing - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/core/testing/pom.xml b/core/testing/pom.xml index 91fb7b4ac2..e743fa1152 100644 --- a/core/testing/pom.xml +++ b/core/testing/pom.xml @@ -4,7 +4,7 @@ org.overturetool core - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/core/testing/tests/pom.xml b/core/testing/tests/pom.xml index 4c7d34d55b..2cfc7a3e1d 100644 --- a/core/testing/tests/pom.xml +++ b/core/testing/tests/pom.xml @@ -4,7 +4,7 @@ org.overturetool.core testing - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/core/typechecker/pom.xml b/core/typechecker/pom.xml index 6a08344408..0be65c300b 100644 --- a/core/typechecker/pom.xml +++ b/core/typechecker/pom.xml @@ -4,7 +4,7 @@ org.overturetool core - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/core/vdmjc/pom.xml b/core/vdmjc/pom.xml index 69545523d6..bbca39d29b 100644 --- a/core/vdmjc/pom.xml +++ b/core/vdmjc/pom.xml @@ -4,7 +4,7 @@ core org.overturetool - 2.2.3-SNAPSHOT + 2.2.4 org.overturetool.core diff --git a/externals/documentation/pom.xml b/externals/documentation/pom.xml index 499d552f7b..9ba1c6e33c 100644 --- a/externals/documentation/pom.xml +++ b/externals/documentation/pom.xml @@ -4,7 +4,7 @@ org.overturetool externals - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/externals/examples/pom.xml b/externals/examples/pom.xml index d6834c48e8..35ff1c20d8 100644 --- a/externals/examples/pom.xml +++ b/externals/examples/pom.xml @@ -4,7 +4,7 @@ org.overturetool externals - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/externals/pom.xml b/externals/pom.xml index 80435003b0..da8b85e168 100644 --- a/externals/pom.xml +++ b/externals/pom.xml @@ -4,7 +4,7 @@ org.overturetool root - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/pom.xml b/pom.xml index 1c35bd2a77..fe9c8c9ba7 100644 --- a/pom.xml +++ b/pom.xml @@ -13,7 +13,7 @@ org.overturetool root - 2.2.3-SNAPSHOT + 2.2.4 The Overture Tool Platform root @@ -302,7 +302,7 @@ git@github.com:overturetool/overture.git scm:git:git://github.com/overturetool/overture.git scm:git:git@github.com:overturetool/overture.git - HEAD + Release/2.2.4 From 43bef230341051f0a4edfae8bfbf4b760759b472 Mon Sep 17 00:00:00 2001 From: Luis Diogo Couto Date: Mon, 30 Mar 2015 13:35:57 +0200 Subject: [PATCH 323/323] Bump ide/ to version 2.2.4 --- ide/builders/pom.xml | 2 +- ide/builders/vdmj/META-INF/MANIFEST.MF | 2 +- ide/builders/vdmj/pom.xml | 2 +- ide/core/META-INF/MANIFEST.MF | 2 +- ide/core/pom.xml | 2 +- ide/debug/META-INF/MANIFEST.MF | 2 +- ide/debug/pom.xml | 2 +- ide/features/core/feature.xml | 2 +- ide/features/core/pom.xml | 2 +- ide/features/pom.xml | 2 +- ide/features/rcp/feature.xml | 2 +- ide/features/rcp/pom.xml | 2 +- ide/help/META-INF/MANIFEST.MF | 2 +- ide/help/pom.xml | 2 +- ide/parsers/pom.xml | 2 +- ide/parsers/vdmj/META-INF/MANIFEST.MF | 2 +- ide/parsers/vdmj/pom.xml | 2 +- ide/platform/META-INF/MANIFEST.MF | 2 +- ide/platform/pom.xml | 2 +- ide/plugins/codegen/META-INF/MANIFEST.MF | 2 +- ide/plugins/codegen/pom.xml | 2 +- ide/plugins/combinatorialtesting/META-INF/MANIFEST.MF | 2 +- ide/plugins/combinatorialtesting/pom.xml | 2 +- ide/plugins/coverageeditor/META-INF/MANIFEST.MF | 2 +- ide/plugins/coverageeditor/pom.xml | 2 +- ide/plugins/csk/META-INF/MANIFEST.MF | 2 +- ide/plugins/csk/pom.xml | 2 +- ide/plugins/developerutils/META-INF/MANIFEST.MF | 2 +- ide/plugins/developerutils/pom.xml | 2 +- ide/plugins/externaleditor/META-INF/MANIFEST.MF | 2 +- ide/plugins/externaleditor/pom.xml | 2 +- ide/plugins/features/codegen/feature.xml | 2 +- ide/plugins/features/codegen/pom.xml | 2 +- ide/plugins/features/combinatorialtesting/feature.xml | 2 +- ide/plugins/features/combinatorialtesting/pom.xml | 2 +- ide/plugins/features/coverageeditor/feature.xml | 2 +- ide/plugins/features/coverageeditor/pom.xml | 2 +- ide/plugins/features/csk/feature.xml | 2 +- ide/plugins/features/csk/pom.xml | 2 +- ide/plugins/features/developerutils/feature.xml | 2 +- ide/plugins/features/developerutils/pom.xml | 2 +- ide/plugins/features/guibuilder/feature.xml | 2 +- ide/plugins/features/guibuilder/pom.xml | 2 +- ide/plugins/features/latex/feature.xml | 2 +- ide/plugins/features/latex/pom.xml | 2 +- ide/plugins/features/pom.xml | 2 +- ide/plugins/features/poviewer/feature.xml | 2 +- ide/plugins/features/poviewer/pom.xml | 2 +- ide/plugins/features/probruntime/feature.xml | 2 +- ide/plugins/features/probruntime/pom.xml | 2 +- ide/plugins/features/quickinterpreter/feature.xml | 2 +- ide/plugins/features/quickinterpreter/pom.xml | 2 +- ide/plugins/features/rttraceviewer/feature.xml | 2 +- ide/plugins/features/rttraceviewer/pom.xml | 2 +- ide/plugins/features/uml2/feature.xml | 2 +- ide/plugins/features/uml2/pom.xml | 2 +- ide/plugins/guibuilder/META-INF/MANIFEST.MF | 2 +- ide/plugins/guibuilder/pom.xml | 2 +- ide/plugins/latex/META-INF/MANIFEST.MF | 2 +- ide/plugins/latex/pom.xml | 2 +- ide/plugins/pom.xml | 2 +- ide/plugins/poviewer/META-INF/MANIFEST.MF | 2 +- ide/plugins/poviewer/pom.xml | 2 +- ide/plugins/prob-runtime/core/META-INF/MANIFEST.MF | 2 +- ide/plugins/prob-runtime/core/pom.xml | 2 +- ide/plugins/prob-runtime/linux.x86/META-INF/MANIFEST.MF | 2 +- ide/plugins/prob-runtime/linux.x86/pom.xml | 2 +- ide/plugins/prob-runtime/linux.x86_64/META-INF/MANIFEST.MF | 2 +- ide/plugins/prob-runtime/linux.x86_64/pom.xml | 2 +- .../prob-runtime/macosx.x86_64/META-INF/MANIFEST.MF | 2 +- ide/plugins/prob-runtime/macosx.x86_64/pom.xml | 2 +- ide/plugins/prob-runtime/pom.xml | 2 +- ide/plugins/prob-runtime/win32.win32/META-INF/MANIFEST.MF | 2 +- ide/plugins/prob-runtime/win32.win32/pom.xml | 2 +- ide/plugins/quickinterpreter/META-INF/MANIFEST.MF | 2 +- ide/plugins/quickinterpreter/pom.xml | 2 +- ide/plugins/rttraceviewer/META-INF/MANIFEST.MF | 2 +- ide/plugins/rttraceviewer/pom.xml | 2 +- ide/plugins/uml2.tests/META-INF/MANIFEST.MF | 2 +- ide/plugins/uml2.tests/pom.xml | 2 +- ide/plugins/uml2/META-INF/MANIFEST.MF | 2 +- ide/plugins/uml2/pom.xml | 2 +- ide/pom.xml | 7 ++++--- ide/product/overture.product | 2 +- ide/product/pom.xml | 2 +- ide/tests/pom.xml | 2 +- ide/tests/ui/META-INF/MANIFEST.MF | 2 +- ide/tests/ui/pom.xml | 2 +- ide/ui/META-INF/MANIFEST.MF | 2 +- ide/ui/pom.xml | 2 +- ide/vdmpp/core/META-INF/MANIFEST.MF | 2 +- ide/vdmpp/core/pom.xml | 2 +- ide/vdmpp/debug/META-INF/MANIFEST.MF | 2 +- ide/vdmpp/debug/pom.xml | 2 +- ide/vdmpp/pom.xml | 2 +- ide/vdmpp/ui/META-INF/MANIFEST.MF | 2 +- ide/vdmpp/ui/pom.xml | 2 +- ide/vdmrt/core/META-INF/MANIFEST.MF | 2 +- ide/vdmrt/core/pom.xml | 2 +- ide/vdmrt/debug/META-INF/MANIFEST.MF | 2 +- ide/vdmrt/debug/pom.xml | 2 +- ide/vdmrt/pom.xml | 2 +- ide/vdmrt/ui/META-INF/MANIFEST.MF | 2 +- ide/vdmrt/ui/pom.xml | 2 +- ide/vdmsl/core/META-INF/MANIFEST.MF | 2 +- ide/vdmsl/core/pom.xml | 2 +- ide/vdmsl/debug/META-INF/MANIFEST.MF | 2 +- ide/vdmsl/debug/pom.xml | 2 +- ide/vdmsl/pom.xml | 2 +- ide/vdmsl/ui/META-INF/MANIFEST.MF | 2 +- ide/vdmsl/ui/pom.xml | 2 +- 111 files changed, 114 insertions(+), 113 deletions(-) diff --git a/ide/builders/pom.xml b/ide/builders/pom.xml index ab3450d404..b49d879c67 100644 --- a/ide/builders/pom.xml +++ b/ide/builders/pom.xml @@ -5,7 +5,7 @@ org.overturetool ide - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/builders/vdmj/META-INF/MANIFEST.MF b/ide/builders/vdmj/META-INF/MANIFEST.MF index 7dc4c22e90..8f50095c5c 100644 --- a/ide/builders/vdmj/META-INF/MANIFEST.MF +++ b/ide/builders/vdmj/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.3.qualifier +Bundle-Version: 2.2.4 Eclipse-BuddyPolicy: registered Eclipse-BundleShape: dir Bundle-Localization: plugin diff --git a/ide/builders/vdmj/pom.xml b/ide/builders/vdmj/pom.xml index 078f8b6985..7bf7793059 100644 --- a/ide/builders/vdmj/pom.xml +++ b/ide/builders/vdmj/pom.xml @@ -4,7 +4,7 @@ org.overturetool.ide org.overture.ide.builders - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/core/META-INF/MANIFEST.MF b/ide/core/META-INF/MANIFEST.MF index 7dec713e2f..3e6370d545 100644 --- a/ide/core/META-INF/MANIFEST.MF +++ b/ide/core/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.3.qualifier +Bundle-Version: 2.2.4 Eclipse-BuddyPolicy: registered Eclipse-BundleShape: dir Bundle-Localization: plugin diff --git a/ide/core/pom.xml b/ide/core/pom.xml index dcccf1fe5c..dd88de7955 100644 --- a/ide/core/pom.xml +++ b/ide/core/pom.xml @@ -5,7 +5,7 @@ org.overturetool ide - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/debug/META-INF/MANIFEST.MF b/ide/debug/META-INF/MANIFEST.MF index 4f47467b28..f2bb711417 100644 --- a/ide/debug/META-INF/MANIFEST.MF +++ b/ide/debug/META-INF/MANIFEST.MF @@ -1,6 +1,6 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture -Bundle-Version: 2.2.3.qualifier +Bundle-Version: 2.2.4 Eclipse-BuddyPolicy: registered Eclipse-BundleShape: dir Bundle-Localization: plugin diff --git a/ide/debug/pom.xml b/ide/debug/pom.xml index e6fe5fd056..1285079e28 100644 --- a/ide/debug/pom.xml +++ b/ide/debug/pom.xml @@ -5,7 +5,7 @@ org.overturetool ide - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/features/core/feature.xml b/ide/features/core/feature.xml index bf1961bf55..18cc022c27 100644 --- a/ide/features/core/feature.xml +++ b/ide/features/core/feature.xml @@ -2,7 +2,7 @@ diff --git a/ide/features/core/pom.xml b/ide/features/core/pom.xml index cbbd6b3b5d..952883c897 100644 --- a/ide/features/core/pom.xml +++ b/ide/features/core/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide features - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/features/pom.xml b/ide/features/pom.xml index ca9cbeef0d..0da91f374a 100644 --- a/ide/features/pom.xml +++ b/ide/features/pom.xml @@ -5,7 +5,7 @@ org.overturetool ide - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/features/rcp/feature.xml b/ide/features/rcp/feature.xml index 047a34efd0..24b4665a29 100644 --- a/ide/features/rcp/feature.xml +++ b/ide/features/rcp/feature.xml @@ -2,7 +2,7 @@ + version="2.2.4"> %description diff --git a/ide/features/rcp/pom.xml b/ide/features/rcp/pom.xml index f1092bb0c5..0319bb8298 100644 --- a/ide/features/rcp/pom.xml +++ b/ide/features/rcp/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide features - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/help/META-INF/MANIFEST.MF b/ide/help/META-INF/MANIFEST.MF index 716d6003d2..9bba7d9c78 100644 --- a/ide/help/META-INF/MANIFEST.MF +++ b/ide/help/META-INF/MANIFEST.MF @@ -1,6 +1,6 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture -Bundle-Version: 2.2.3.qualifier +Bundle-Version: 2.2.4 Eclipse-BuddyPolicy: registered Eclipse-BundleShape: dir Bundle-Localization: plugin diff --git a/ide/help/pom.xml b/ide/help/pom.xml index 7540946221..e3c667f197 100644 --- a/ide/help/pom.xml +++ b/ide/help/pom.xml @@ -5,7 +5,7 @@ org.overturetool ide - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/parsers/pom.xml b/ide/parsers/pom.xml index c23e6d5048..a48c03ca5e 100644 --- a/ide/parsers/pom.xml +++ b/ide/parsers/pom.xml @@ -5,7 +5,7 @@ org.overturetool ide - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/parsers/vdmj/META-INF/MANIFEST.MF b/ide/parsers/vdmj/META-INF/MANIFEST.MF index 8be8e927fb..1117fefc26 100644 --- a/ide/parsers/vdmj/META-INF/MANIFEST.MF +++ b/ide/parsers/vdmj/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.3.qualifier +Bundle-Version: 2.2.4 Eclipse-BuddyPolicy: registered Bundle-Localization: plugin Bundle-Name: org.overture.ide.parsers.vdmj diff --git a/ide/parsers/vdmj/pom.xml b/ide/parsers/vdmj/pom.xml index 32c3e37e4b..7a0dc2e635 100644 --- a/ide/parsers/vdmj/pom.xml +++ b/ide/parsers/vdmj/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide org.overture.ide.parsers - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/platform/META-INF/MANIFEST.MF b/ide/platform/META-INF/MANIFEST.MF index d5bee844ee..1a940f19a8 100644 --- a/ide/platform/META-INF/MANIFEST.MF +++ b/ide/platform/META-INF/MANIFEST.MF @@ -2,7 +2,7 @@ Manifest-Version: 1.0 Bundle-ManifestVersion: 2 Bundle-Name: org.overture.ide.platform Bundle-SymbolicName: org.overture.ide.platform;singleton:=true -Bundle-Version: 2.2.3.qualifier +Bundle-Version: 2.2.4 Bundle-Localization: plugin Require-Bundle: org.eclipse.core.runtime, org.eclipse.ui, diff --git a/ide/platform/pom.xml b/ide/platform/pom.xml index 59062d8cad..1e9c6ef3f6 100644 --- a/ide/platform/pom.xml +++ b/ide/platform/pom.xml @@ -5,7 +5,7 @@ org.overturetool ide - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/plugins/codegen/META-INF/MANIFEST.MF b/ide/plugins/codegen/META-INF/MANIFEST.MF index d0656c98c0..94422b65df 100644 --- a/ide/plugins/codegen/META-INF/MANIFEST.MF +++ b/ide/plugins/codegen/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.3.qualifier +Bundle-Version: 2.2.4 Eclipse-BuddyPolicy: registered Bundle-Name: Code Generator Bundle-ManifestVersion: 2 diff --git a/ide/plugins/codegen/pom.xml b/ide/plugins/codegen/pom.xml index 8ad1614f00..23c3ee8fd4 100644 --- a/ide/plugins/codegen/pom.xml +++ b/ide/plugins/codegen/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide org.overture.ide.plugins - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/plugins/combinatorialtesting/META-INF/MANIFEST.MF b/ide/plugins/combinatorialtesting/META-INF/MANIFEST.MF index 5639a98d9f..ae19c302de 100644 --- a/ide/plugins/combinatorialtesting/META-INF/MANIFEST.MF +++ b/ide/plugins/combinatorialtesting/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.3.qualifier +Bundle-Version: 2.2.4 Eclipse-BuddyPolicy: registered Eclipse-BundleShape: dir Bundle-Localization: plugin diff --git a/ide/plugins/combinatorialtesting/pom.xml b/ide/plugins/combinatorialtesting/pom.xml index d3725214d9..a14f2ff7c4 100644 --- a/ide/plugins/combinatorialtesting/pom.xml +++ b/ide/plugins/combinatorialtesting/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide org.overture.ide.plugins - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/plugins/coverageeditor/META-INF/MANIFEST.MF b/ide/plugins/coverageeditor/META-INF/MANIFEST.MF index be0332fc49..60daf8f61f 100644 --- a/ide/plugins/coverageeditor/META-INF/MANIFEST.MF +++ b/ide/plugins/coverageeditor/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.3.qualifier +Bundle-Version: 2.2.4 Eclipse-BuddyPolicy: registered Bundle-Localization: plugin Bundle-Name: org.overture.ide.plugins.coverageeditor diff --git a/ide/plugins/coverageeditor/pom.xml b/ide/plugins/coverageeditor/pom.xml index 2948efec9b..dfe207995d 100644 --- a/ide/plugins/coverageeditor/pom.xml +++ b/ide/plugins/coverageeditor/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide org.overture.ide.plugins - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/plugins/csk/META-INF/MANIFEST.MF b/ide/plugins/csk/META-INF/MANIFEST.MF index a70eb94587..efce5e2abc 100644 --- a/ide/plugins/csk/META-INF/MANIFEST.MF +++ b/ide/plugins/csk/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.3.qualifier +Bundle-Version: 2.2.4 Eclipse-BuddyPolicy: registered Bundle-Localization: plugin Bundle-Name: org.overture.ide.plugins.csk diff --git a/ide/plugins/csk/pom.xml b/ide/plugins/csk/pom.xml index c45e5b2bcd..561f5cbf1b 100644 --- a/ide/plugins/csk/pom.xml +++ b/ide/plugins/csk/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide org.overture.ide.plugins - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/plugins/developerutils/META-INF/MANIFEST.MF b/ide/plugins/developerutils/META-INF/MANIFEST.MF index b147f6eda3..6fbe58d20c 100644 --- a/ide/plugins/developerutils/META-INF/MANIFEST.MF +++ b/ide/plugins/developerutils/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.3.qualifier +Bundle-Version: 2.2.4 Eclipse-BuddyPolicy: registered Bundle-Localization: plugin Bundle-Name: Developer Utilities for Overture diff --git a/ide/plugins/developerutils/pom.xml b/ide/plugins/developerutils/pom.xml index 54d799bdbb..c76159dfc7 100644 --- a/ide/plugins/developerutils/pom.xml +++ b/ide/plugins/developerutils/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide org.overture.ide.plugins - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/plugins/externaleditor/META-INF/MANIFEST.MF b/ide/plugins/externaleditor/META-INF/MANIFEST.MF index 561cdd79b8..119106947f 100644 --- a/ide/plugins/externaleditor/META-INF/MANIFEST.MF +++ b/ide/plugins/externaleditor/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.3.qualifier +Bundle-Version: 2.2.4 Eclipse-BuddyPolicy: registered Bundle-Localization: plugin Bundle-Name: org.overture.ide.plugins.externaleditor diff --git a/ide/plugins/externaleditor/pom.xml b/ide/plugins/externaleditor/pom.xml index c1fcc3acc5..d0548696b0 100644 --- a/ide/plugins/externaleditor/pom.xml +++ b/ide/plugins/externaleditor/pom.xml @@ -4,7 +4,7 @@ org.overturetool.ide org.overture.ide.plugins - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/plugins/features/codegen/feature.xml b/ide/plugins/features/codegen/feature.xml index e758786ad1..691d5d18b0 100644 --- a/ide/plugins/features/codegen/feature.xml +++ b/ide/plugins/features/codegen/feature.xml @@ -2,7 +2,7 @@ + version="2.2.4"> %description diff --git a/ide/plugins/features/codegen/pom.xml b/ide/plugins/features/codegen/pom.xml index a3038d9b09..6510ac2859 100644 --- a/ide/plugins/features/codegen/pom.xml +++ b/ide/plugins/features/codegen/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide.plugins org.overture.ide.plugins.features - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/plugins/features/combinatorialtesting/feature.xml b/ide/plugins/features/combinatorialtesting/feature.xml index f59147ebc2..df3c423bf7 100644 --- a/ide/plugins/features/combinatorialtesting/feature.xml +++ b/ide/plugins/features/combinatorialtesting/feature.xml @@ -2,7 +2,7 @@ + version="2.2.4"> %description diff --git a/ide/plugins/features/combinatorialtesting/pom.xml b/ide/plugins/features/combinatorialtesting/pom.xml index bcb356d3f7..92a49dea07 100644 --- a/ide/plugins/features/combinatorialtesting/pom.xml +++ b/ide/plugins/features/combinatorialtesting/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide.plugins org.overture.ide.plugins.features - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/plugins/features/coverageeditor/feature.xml b/ide/plugins/features/coverageeditor/feature.xml index 0b558bff3e..a095df40c5 100644 --- a/ide/plugins/features/coverageeditor/feature.xml +++ b/ide/plugins/features/coverageeditor/feature.xml @@ -2,7 +2,7 @@ + version="2.2.4"> %description diff --git a/ide/plugins/features/coverageeditor/pom.xml b/ide/plugins/features/coverageeditor/pom.xml index 7fc99f6748..627dc5c1d9 100644 --- a/ide/plugins/features/coverageeditor/pom.xml +++ b/ide/plugins/features/coverageeditor/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide.plugins org.overture.ide.plugins.features - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/plugins/features/csk/feature.xml b/ide/plugins/features/csk/feature.xml index 8a7b3e4900..334ae92269 100644 --- a/ide/plugins/features/csk/feature.xml +++ b/ide/plugins/features/csk/feature.xml @@ -2,7 +2,7 @@ + version="2.2.4"> %description diff --git a/ide/plugins/features/csk/pom.xml b/ide/plugins/features/csk/pom.xml index aa28c0ae37..b9f6217edf 100644 --- a/ide/plugins/features/csk/pom.xml +++ b/ide/plugins/features/csk/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide.plugins org.overture.ide.plugins.features - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/plugins/features/developerutils/feature.xml b/ide/plugins/features/developerutils/feature.xml index 44f6231a7d..4ea4013cdd 100644 --- a/ide/plugins/features/developerutils/feature.xml +++ b/ide/plugins/features/developerutils/feature.xml @@ -2,7 +2,7 @@ + version="2.2.4"> %description diff --git a/ide/plugins/features/developerutils/pom.xml b/ide/plugins/features/developerutils/pom.xml index 3067534697..4d57094693 100644 --- a/ide/plugins/features/developerutils/pom.xml +++ b/ide/plugins/features/developerutils/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide.plugins org.overture.ide.plugins.features - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/plugins/features/guibuilder/feature.xml b/ide/plugins/features/guibuilder/feature.xml index 9c190f4044..40a145db4a 100644 --- a/ide/plugins/features/guibuilder/feature.xml +++ b/ide/plugins/features/guibuilder/feature.xml @@ -2,7 +2,7 @@ + version="2.2.4"> %description diff --git a/ide/plugins/features/guibuilder/pom.xml b/ide/plugins/features/guibuilder/pom.xml index d03312a201..d0ec7957d3 100644 --- a/ide/plugins/features/guibuilder/pom.xml +++ b/ide/plugins/features/guibuilder/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide.plugins org.overture.ide.plugins.features - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/plugins/features/latex/feature.xml b/ide/plugins/features/latex/feature.xml index b859700acf..e4603dadb0 100644 --- a/ide/plugins/features/latex/feature.xml +++ b/ide/plugins/features/latex/feature.xml @@ -2,7 +2,7 @@ + version="2.2.4"> %description diff --git a/ide/plugins/features/latex/pom.xml b/ide/plugins/features/latex/pom.xml index c9d9a2a553..4df1cfc644 100644 --- a/ide/plugins/features/latex/pom.xml +++ b/ide/plugins/features/latex/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide.plugins org.overture.ide.plugins.features - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/plugins/features/pom.xml b/ide/plugins/features/pom.xml index b5ea48a30e..35e736ac61 100644 --- a/ide/plugins/features/pom.xml +++ b/ide/plugins/features/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide org.overture.ide.plugins - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/plugins/features/poviewer/feature.xml b/ide/plugins/features/poviewer/feature.xml index 567feb0d98..97a447d5b9 100644 --- a/ide/plugins/features/poviewer/feature.xml +++ b/ide/plugins/features/poviewer/feature.xml @@ -2,7 +2,7 @@ + version="2.2.4"> %description diff --git a/ide/plugins/features/poviewer/pom.xml b/ide/plugins/features/poviewer/pom.xml index b209409431..0be579e317 100644 --- a/ide/plugins/features/poviewer/pom.xml +++ b/ide/plugins/features/poviewer/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide.plugins org.overture.ide.plugins.features - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/plugins/features/probruntime/feature.xml b/ide/plugins/features/probruntime/feature.xml index 94355db3e5..1c4480a3b5 100644 --- a/ide/plugins/features/probruntime/feature.xml +++ b/ide/plugins/features/probruntime/feature.xml @@ -2,7 +2,7 @@ diff --git a/ide/plugins/features/probruntime/pom.xml b/ide/plugins/features/probruntime/pom.xml index 9de8b7a6e1..5df942022b 100644 --- a/ide/plugins/features/probruntime/pom.xml +++ b/ide/plugins/features/probruntime/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide.plugins org.overture.ide.plugins.features - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/plugins/features/quickinterpreter/feature.xml b/ide/plugins/features/quickinterpreter/feature.xml index 9d5b15d94d..a5054b77a1 100644 --- a/ide/plugins/features/quickinterpreter/feature.xml +++ b/ide/plugins/features/quickinterpreter/feature.xml @@ -2,7 +2,7 @@ + version="2.2.4"> %description diff --git a/ide/plugins/features/quickinterpreter/pom.xml b/ide/plugins/features/quickinterpreter/pom.xml index d9627ce571..e2fd90f59c 100644 --- a/ide/plugins/features/quickinterpreter/pom.xml +++ b/ide/plugins/features/quickinterpreter/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide.plugins org.overture.ide.plugins.features - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/plugins/features/rttraceviewer/feature.xml b/ide/plugins/features/rttraceviewer/feature.xml index 7653b3570c..17acadec3f 100644 --- a/ide/plugins/features/rttraceviewer/feature.xml +++ b/ide/plugins/features/rttraceviewer/feature.xml @@ -2,7 +2,7 @@ + version="2.2.4"> %description diff --git a/ide/plugins/features/rttraceviewer/pom.xml b/ide/plugins/features/rttraceviewer/pom.xml index c317a5b78e..69dfd53da1 100644 --- a/ide/plugins/features/rttraceviewer/pom.xml +++ b/ide/plugins/features/rttraceviewer/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide.plugins org.overture.ide.plugins.features - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/plugins/features/uml2/feature.xml b/ide/plugins/features/uml2/feature.xml index ac642f4c3a..e55ddace6e 100644 --- a/ide/plugins/features/uml2/feature.xml +++ b/ide/plugins/features/uml2/feature.xml @@ -2,7 +2,7 @@ + version="2.2.4"> %description diff --git a/ide/plugins/features/uml2/pom.xml b/ide/plugins/features/uml2/pom.xml index fd5f7b01d2..d6aee06b8d 100644 --- a/ide/plugins/features/uml2/pom.xml +++ b/ide/plugins/features/uml2/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide.plugins org.overture.ide.plugins.features - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/plugins/guibuilder/META-INF/MANIFEST.MF b/ide/plugins/guibuilder/META-INF/MANIFEST.MF index 358a5be3c2..d3ff2c64ac 100644 --- a/ide/plugins/guibuilder/META-INF/MANIFEST.MF +++ b/ide/plugins/guibuilder/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.3.qualifier +Bundle-Version: 2.2.4 Eclipse-BuddyPolicy: registered Eclipse-BundleShape: dir Bundle-Localization: plugin diff --git a/ide/plugins/guibuilder/pom.xml b/ide/plugins/guibuilder/pom.xml index 472a605392..784862743c 100644 --- a/ide/plugins/guibuilder/pom.xml +++ b/ide/plugins/guibuilder/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide org.overture.ide.plugins - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/plugins/latex/META-INF/MANIFEST.MF b/ide/plugins/latex/META-INF/MANIFEST.MF index 592050f109..794cc00691 100644 --- a/ide/plugins/latex/META-INF/MANIFEST.MF +++ b/ide/plugins/latex/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.3.qualifier +Bundle-Version: 2.2.4 Eclipse-BuddyPolicy: registered Bundle-Localization: plugin Bundle-Name: org.overture.ide.plugins.latex diff --git a/ide/plugins/latex/pom.xml b/ide/plugins/latex/pom.xml index da1f98c79b..838b2051df 100644 --- a/ide/plugins/latex/pom.xml +++ b/ide/plugins/latex/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide org.overture.ide.plugins - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/plugins/pom.xml b/ide/plugins/pom.xml index 4e15a24bac..926a219b1a 100644 --- a/ide/plugins/pom.xml +++ b/ide/plugins/pom.xml @@ -5,7 +5,7 @@ org.overturetool ide - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/plugins/poviewer/META-INF/MANIFEST.MF b/ide/plugins/poviewer/META-INF/MANIFEST.MF index 48204bcfe8..78e2c68db2 100644 --- a/ide/plugins/poviewer/META-INF/MANIFEST.MF +++ b/ide/plugins/poviewer/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.3.qualifier +Bundle-Version: 2.2.4 Eclipse-BuddyPolicy: registered Eclipse-BundleShape: dir Bundle-Localization: plugin diff --git a/ide/plugins/poviewer/pom.xml b/ide/plugins/poviewer/pom.xml index 3bf2620b9b..5218155364 100644 --- a/ide/plugins/poviewer/pom.xml +++ b/ide/plugins/poviewer/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide org.overture.ide.plugins - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/plugins/prob-runtime/core/META-INF/MANIFEST.MF b/ide/plugins/prob-runtime/core/META-INF/MANIFEST.MF index 5e420c38ee..2b919f7a0e 100644 --- a/ide/plugins/prob-runtime/core/META-INF/MANIFEST.MF +++ b/ide/plugins/prob-runtime/core/META-INF/MANIFEST.MF @@ -1,6 +1,6 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture -Bundle-Version: 2.2.3.qualifier +Bundle-Version: 2.2.4 Eclipse-BuddyPolicy: registered Eclipse-BundleShape: dir Bundle-Name: ProB Runtime diff --git a/ide/plugins/prob-runtime/core/pom.xml b/ide/plugins/prob-runtime/core/pom.xml index 7e4c475d30..4c982c3fbd 100644 --- a/ide/plugins/prob-runtime/core/pom.xml +++ b/ide/plugins/prob-runtime/core/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide.plugins org.overture.ide.plugins.probruntime - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/plugins/prob-runtime/linux.x86/META-INF/MANIFEST.MF b/ide/plugins/prob-runtime/linux.x86/META-INF/MANIFEST.MF index a36bb64b36..79d42ea2f8 100644 --- a/ide/plugins/prob-runtime/linux.x86/META-INF/MANIFEST.MF +++ b/ide/plugins/prob-runtime/linux.x86/META-INF/MANIFEST.MF @@ -3,7 +3,7 @@ Eclipse-BundleShape: dir Bundle-ManifestVersion: 2 Bundle-Name: org.overture.ide.plugins.probruntime Bundle-SymbolicName: org.overture.ide.plugins.probruntime.linux.x86;singleton:=true -Bundle-Version: 2.2.3.qualifier +Bundle-Version: 2.2.4 Fragment-Host: org.overture.ide.plugins.probruntime.core Bundle-RequiredExecutionEnvironment: JavaSE-1.7 diff --git a/ide/plugins/prob-runtime/linux.x86/pom.xml b/ide/plugins/prob-runtime/linux.x86/pom.xml index 7f5898d889..bc30f0f76e 100644 --- a/ide/plugins/prob-runtime/linux.x86/pom.xml +++ b/ide/plugins/prob-runtime/linux.x86/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide.plugins org.overture.ide.plugins.probruntime - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/plugins/prob-runtime/linux.x86_64/META-INF/MANIFEST.MF b/ide/plugins/prob-runtime/linux.x86_64/META-INF/MANIFEST.MF index d6be88606a..5d3ab1892f 100644 --- a/ide/plugins/prob-runtime/linux.x86_64/META-INF/MANIFEST.MF +++ b/ide/plugins/prob-runtime/linux.x86_64/META-INF/MANIFEST.MF @@ -3,7 +3,7 @@ Eclipse-BundleShape: dir Bundle-ManifestVersion: 2 Bundle-Name: org.overture.ide.plugins.probruntime Bundle-SymbolicName: org.overture.ide.plugins.probruntime.linux.x86_64;singleton:=true -Bundle-Version: 2.2.3.qualifier +Bundle-Version: 2.2.4 Fragment-Host: org.overture.ide.plugins.probruntime.core Bundle-RequiredExecutionEnvironment: JavaSE-1.7 diff --git a/ide/plugins/prob-runtime/linux.x86_64/pom.xml b/ide/plugins/prob-runtime/linux.x86_64/pom.xml index edef534fc0..c0151bd401 100644 --- a/ide/plugins/prob-runtime/linux.x86_64/pom.xml +++ b/ide/plugins/prob-runtime/linux.x86_64/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide.plugins org.overture.ide.plugins.probruntime - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/plugins/prob-runtime/macosx.x86_64/META-INF/MANIFEST.MF b/ide/plugins/prob-runtime/macosx.x86_64/META-INF/MANIFEST.MF index 15a05f63bb..3483e96220 100644 --- a/ide/plugins/prob-runtime/macosx.x86_64/META-INF/MANIFEST.MF +++ b/ide/plugins/prob-runtime/macosx.x86_64/META-INF/MANIFEST.MF @@ -3,7 +3,7 @@ Eclipse-BundleShape: dir Bundle-ManifestVersion: 2 Bundle-Name: org.overture.ide.plugins.probruntime Bundle-SymbolicName: org.overture.ide.plugins.probruntime.macosx.x86_64;singleton:=true -Bundle-Version: 2.2.3.qualifier +Bundle-Version: 2.2.4 Fragment-Host: org.overture.ide.plugins.probruntime.core Bundle-RequiredExecutionEnvironment: JavaSE-1.7 diff --git a/ide/plugins/prob-runtime/macosx.x86_64/pom.xml b/ide/plugins/prob-runtime/macosx.x86_64/pom.xml index 6a9aee0c33..d271fd966a 100644 --- a/ide/plugins/prob-runtime/macosx.x86_64/pom.xml +++ b/ide/plugins/prob-runtime/macosx.x86_64/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide.plugins org.overture.ide.plugins.probruntime - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/plugins/prob-runtime/pom.xml b/ide/plugins/prob-runtime/pom.xml index dcf1b1baca..950ab84f2e 100644 --- a/ide/plugins/prob-runtime/pom.xml +++ b/ide/plugins/prob-runtime/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide org.overture.ide.plugins - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/plugins/prob-runtime/win32.win32/META-INF/MANIFEST.MF b/ide/plugins/prob-runtime/win32.win32/META-INF/MANIFEST.MF index dfc701d514..1b3055e5db 100644 --- a/ide/plugins/prob-runtime/win32.win32/META-INF/MANIFEST.MF +++ b/ide/plugins/prob-runtime/win32.win32/META-INF/MANIFEST.MF @@ -3,7 +3,7 @@ Eclipse-BundleShape: dir Bundle-ManifestVersion: 2 Bundle-Name: org.overture.ide.plugins.probruntime Bundle-SymbolicName: org.overture.ide.plugins.probruntime.win32.win32;singleton:=true -Bundle-Version: 2.2.3.qualifier +Bundle-Version: 2.2.4 Fragment-Host: org.overture.ide.plugins.probruntime.core Bundle-RequiredExecutionEnvironment: JavaSE-1.7 diff --git a/ide/plugins/prob-runtime/win32.win32/pom.xml b/ide/plugins/prob-runtime/win32.win32/pom.xml index ba2ad2b470..e80e8831c2 100644 --- a/ide/plugins/prob-runtime/win32.win32/pom.xml +++ b/ide/plugins/prob-runtime/win32.win32/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide.plugins org.overture.ide.plugins.probruntime - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/plugins/quickinterpreter/META-INF/MANIFEST.MF b/ide/plugins/quickinterpreter/META-INF/MANIFEST.MF index 741c4aa89e..fd6661d095 100644 --- a/ide/plugins/quickinterpreter/META-INF/MANIFEST.MF +++ b/ide/plugins/quickinterpreter/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.3.qualifier +Bundle-Version: 2.2.4 Eclipse-BuddyPolicy: registered Bundle-Localization: plugin Bundle-Name: org.overture.ide.plugins.quickinterpreter diff --git a/ide/plugins/quickinterpreter/pom.xml b/ide/plugins/quickinterpreter/pom.xml index 39bc4f8dd6..7057d99c82 100644 --- a/ide/plugins/quickinterpreter/pom.xml +++ b/ide/plugins/quickinterpreter/pom.xml @@ -4,7 +4,7 @@ org.overturetool.ide org.overture.ide.plugins - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/plugins/rttraceviewer/META-INF/MANIFEST.MF b/ide/plugins/rttraceviewer/META-INF/MANIFEST.MF index 39ac82df50..6aa285e27f 100644 --- a/ide/plugins/rttraceviewer/META-INF/MANIFEST.MF +++ b/ide/plugins/rttraceviewer/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.3.qualifier +Bundle-Version: 2.2.4 Eclipse-BuddyPolicy: registered Bundle-Localization: plugin Bundle-Name: org.overture.ide.plugins.rttraceviewer diff --git a/ide/plugins/rttraceviewer/pom.xml b/ide/plugins/rttraceviewer/pom.xml index 46554d7417..6c9aaff6fe 100644 --- a/ide/plugins/rttraceviewer/pom.xml +++ b/ide/plugins/rttraceviewer/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide org.overture.ide.plugins - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/plugins/uml2.tests/META-INF/MANIFEST.MF b/ide/plugins/uml2.tests/META-INF/MANIFEST.MF index 68468e1d4a..a695518775 100644 --- a/ide/plugins/uml2.tests/META-INF/MANIFEST.MF +++ b/ide/plugins/uml2.tests/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.3.qualifier +Bundle-Version: 2.2.4 Eclipse-BuddyPolicy: registered Bundle-Localization: plugin Bundle-Name: org.overture.ide.plugins.uml2.tests diff --git a/ide/plugins/uml2.tests/pom.xml b/ide/plugins/uml2.tests/pom.xml index 47307902c7..e0ce982209 100644 --- a/ide/plugins/uml2.tests/pom.xml +++ b/ide/plugins/uml2.tests/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide org.overture.ide.plugins - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/plugins/uml2/META-INF/MANIFEST.MF b/ide/plugins/uml2/META-INF/MANIFEST.MF index 383e7331d9..27e85ce7a2 100644 --- a/ide/plugins/uml2/META-INF/MANIFEST.MF +++ b/ide/plugins/uml2/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.3.qualifier +Bundle-Version: 2.2.4 Eclipse-BuddyPolicy: registered Bundle-Name: UML2 Translator Bundle-ManifestVersion: 2 diff --git a/ide/plugins/uml2/pom.xml b/ide/plugins/uml2/pom.xml index d60aa6fe16..b8b420243f 100644 --- a/ide/plugins/uml2/pom.xml +++ b/ide/plugins/uml2/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide org.overture.ide.plugins - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/pom.xml b/ide/pom.xml index 61fe2f3944..7cbd8518bf 100644 --- a/ide/pom.xml +++ b/ide/pom.xml @@ -5,10 +5,11 @@ org.overturetool root - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml - - pom + + +pom ide Overture IDE Top-level Super POM for all IDE (Eclipse) artifacts. diff --git a/ide/product/overture.product b/ide/product/overture.product index 5bd784d424..dfb6c1728e 100644 --- a/ide/product/overture.product +++ b/ide/product/overture.product @@ -1,7 +1,7 @@ - + diff --git a/ide/product/pom.xml b/ide/product/pom.xml index f25bd39d34..5b5e97d90e 100644 --- a/ide/product/pom.xml +++ b/ide/product/pom.xml @@ -5,7 +5,7 @@ org.overturetool ide - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/tests/pom.xml b/ide/tests/pom.xml index 04faaf3abf..c44c446d77 100644 --- a/ide/tests/pom.xml +++ b/ide/tests/pom.xml @@ -5,7 +5,7 @@ org.overturetool ide - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/tests/ui/META-INF/MANIFEST.MF b/ide/tests/ui/META-INF/MANIFEST.MF index 488bac8ed7..c990b90d5e 100644 --- a/ide/tests/ui/META-INF/MANIFEST.MF +++ b/ide/tests/ui/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.3.qualifier +Bundle-Version: 2.2.4 Eclipse-BuddyPolicy: registered Bundle-Localization: plugin Bundle-Name: org.overture.ide.tests.ui diff --git a/ide/tests/ui/pom.xml b/ide/tests/ui/pom.xml index 6e5bf8b5a4..a659d3c2a0 100644 --- a/ide/tests/ui/pom.xml +++ b/ide/tests/ui/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide org.overture.ide.tests - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/ui/META-INF/MANIFEST.MF b/ide/ui/META-INF/MANIFEST.MF index 10804aaa9a..6cf4ebb45e 100644 --- a/ide/ui/META-INF/MANIFEST.MF +++ b/ide/ui/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.3.qualifier +Bundle-Version: 2.2.4 Eclipse-BuddyPolicy: registered Bundle-Localization: plugin Bundle-Name: org.overture.ide.ui diff --git a/ide/ui/pom.xml b/ide/ui/pom.xml index cb3ee16fad..64d9543260 100644 --- a/ide/ui/pom.xml +++ b/ide/ui/pom.xml @@ -5,7 +5,7 @@ org.overturetool ide - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/vdmpp/core/META-INF/MANIFEST.MF b/ide/vdmpp/core/META-INF/MANIFEST.MF index 47c64269c3..98695652c5 100644 --- a/ide/vdmpp/core/META-INF/MANIFEST.MF +++ b/ide/vdmpp/core/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.3.qualifier +Bundle-Version: 2.2.4 Eclipse-BuddyPolicy: registered Bundle-Localization: plugin Bundle-Name: org.overture.ide.vdmpp.core diff --git a/ide/vdmpp/core/pom.xml b/ide/vdmpp/core/pom.xml index 1d65e87fbe..2785b2b932 100644 --- a/ide/vdmpp/core/pom.xml +++ b/ide/vdmpp/core/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide org.overture.ide.vdmpp - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/vdmpp/debug/META-INF/MANIFEST.MF b/ide/vdmpp/debug/META-INF/MANIFEST.MF index ae76e56694..5f2a7b3565 100644 --- a/ide/vdmpp/debug/META-INF/MANIFEST.MF +++ b/ide/vdmpp/debug/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.3.qualifier +Bundle-Version: 2.2.4 Eclipse-BuddyPolicy: registered Bundle-Localization: plugin Bundle-Name: org.overture.ide.vdmpp.debug diff --git a/ide/vdmpp/debug/pom.xml b/ide/vdmpp/debug/pom.xml index 54ff78b0d5..fb9869d303 100644 --- a/ide/vdmpp/debug/pom.xml +++ b/ide/vdmpp/debug/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide org.overture.ide.vdmpp - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/vdmpp/pom.xml b/ide/vdmpp/pom.xml index 48da05bfcf..98345a3a38 100644 --- a/ide/vdmpp/pom.xml +++ b/ide/vdmpp/pom.xml @@ -4,7 +4,7 @@ org.overturetool ide - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/vdmpp/ui/META-INF/MANIFEST.MF b/ide/vdmpp/ui/META-INF/MANIFEST.MF index e8b2cb1b54..e15ab1f90f 100644 --- a/ide/vdmpp/ui/META-INF/MANIFEST.MF +++ b/ide/vdmpp/ui/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.3.qualifier +Bundle-Version: 2.2.4 Eclipse-BuddyPolicy: registered Bundle-Localization: plugin Bundle-Name: org.overture.ide.vdmpp.ui diff --git a/ide/vdmpp/ui/pom.xml b/ide/vdmpp/ui/pom.xml index d4976669b3..9485e9f082 100644 --- a/ide/vdmpp/ui/pom.xml +++ b/ide/vdmpp/ui/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide org.overture.ide.vdmpp - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/vdmrt/core/META-INF/MANIFEST.MF b/ide/vdmrt/core/META-INF/MANIFEST.MF index a2d6710aa0..7db054d9d9 100644 --- a/ide/vdmrt/core/META-INF/MANIFEST.MF +++ b/ide/vdmrt/core/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.3.qualifier +Bundle-Version: 2.2.4 Eclipse-BuddyPolicy: registered Bundle-Localization: plugin Bundle-Name: org.overture.ide.vdmrt.core diff --git a/ide/vdmrt/core/pom.xml b/ide/vdmrt/core/pom.xml index ebe78dc261..77623fe4d5 100644 --- a/ide/vdmrt/core/pom.xml +++ b/ide/vdmrt/core/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide org.overture.ide.vdmrt - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/vdmrt/debug/META-INF/MANIFEST.MF b/ide/vdmrt/debug/META-INF/MANIFEST.MF index 27291dded6..88000a843c 100644 --- a/ide/vdmrt/debug/META-INF/MANIFEST.MF +++ b/ide/vdmrt/debug/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.3.qualifier +Bundle-Version: 2.2.4 Eclipse-BuddyPolicy: registered Bundle-Localization: plugin Bundle-Name: org.overture.ide.vdmrt.debug diff --git a/ide/vdmrt/debug/pom.xml b/ide/vdmrt/debug/pom.xml index a13e21b195..0bdcdb6dc2 100644 --- a/ide/vdmrt/debug/pom.xml +++ b/ide/vdmrt/debug/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide org.overture.ide.vdmrt - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/vdmrt/pom.xml b/ide/vdmrt/pom.xml index 32c57f9075..15f7fd93f1 100644 --- a/ide/vdmrt/pom.xml +++ b/ide/vdmrt/pom.xml @@ -5,7 +5,7 @@ org.overturetool ide - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/vdmrt/ui/META-INF/MANIFEST.MF b/ide/vdmrt/ui/META-INF/MANIFEST.MF index 99a6a37e7b..d6c59952c8 100644 --- a/ide/vdmrt/ui/META-INF/MANIFEST.MF +++ b/ide/vdmrt/ui/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.3.qualifier +Bundle-Version: 2.2.4 Eclipse-BuddyPolicy: registered Bundle-Localization: plugin Bundle-Name: org.overture.ide.vdmrt.ui diff --git a/ide/vdmrt/ui/pom.xml b/ide/vdmrt/ui/pom.xml index 065835bbf6..5a26a018ec 100644 --- a/ide/vdmrt/ui/pom.xml +++ b/ide/vdmrt/ui/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide org.overture.ide.vdmrt - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/vdmsl/core/META-INF/MANIFEST.MF b/ide/vdmsl/core/META-INF/MANIFEST.MF index d8ca583480..e2e95a279d 100644 --- a/ide/vdmsl/core/META-INF/MANIFEST.MF +++ b/ide/vdmsl/core/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.3.qualifier +Bundle-Version: 2.2.4 Eclipse-BuddyPolicy: registered Bundle-Localization: plugin Bundle-Name: org.overture.ide.vdmsl.core diff --git a/ide/vdmsl/core/pom.xml b/ide/vdmsl/core/pom.xml index 11f5f12236..eadf232892 100644 --- a/ide/vdmsl/core/pom.xml +++ b/ide/vdmsl/core/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide org.overture.ide.vdmsl - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/vdmsl/debug/META-INF/MANIFEST.MF b/ide/vdmsl/debug/META-INF/MANIFEST.MF index 71b5545f2d..e30be3b3cf 100644 --- a/ide/vdmsl/debug/META-INF/MANIFEST.MF +++ b/ide/vdmsl/debug/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.3.qualifier +Bundle-Version: 2.2.4 Eclipse-BuddyPolicy: registered Bundle-Localization: plugin Bundle-Name: org.overture.ide.vdmsl.debug diff --git a/ide/vdmsl/debug/pom.xml b/ide/vdmsl/debug/pom.xml index c583af22de..0ac0a90368 100644 --- a/ide/vdmsl/debug/pom.xml +++ b/ide/vdmsl/debug/pom.xml @@ -4,7 +4,7 @@ org.overturetool.ide org.overture.ide.vdmsl - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/vdmsl/pom.xml b/ide/vdmsl/pom.xml index 92972216e4..8d2a28342e 100644 --- a/ide/vdmsl/pom.xml +++ b/ide/vdmsl/pom.xml @@ -5,7 +5,7 @@ org.overturetool ide - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml diff --git a/ide/vdmsl/ui/META-INF/MANIFEST.MF b/ide/vdmsl/ui/META-INF/MANIFEST.MF index 063ae37bad..67c8b8b6db 100644 --- a/ide/vdmsl/ui/META-INF/MANIFEST.MF +++ b/ide/vdmsl/ui/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-Vendor: Overture Bundle-ActivationPolicy: lazy -Bundle-Version: 2.2.3.qualifier +Bundle-Version: 2.2.4 Eclipse-BuddyPolicy: registered Bundle-Localization: plugin Bundle-Name: org.overture.ide.vdmsl.ui diff --git a/ide/vdmsl/ui/pom.xml b/ide/vdmsl/ui/pom.xml index 57ce2cc914..9f069f5634 100644 --- a/ide/vdmsl/ui/pom.xml +++ b/ide/vdmsl/ui/pom.xml @@ -5,7 +5,7 @@ org.overturetool.ide org.overture.ide.vdmsl - 2.2.3-SNAPSHOT + 2.2.4 ../pom.xml